How to Integrate Bolt.new with Confluence

1// lib/confluence.ts
2function getAuthHeader(): string {
3  const email = process.env.CONFLUENCE_EMAIL;
4  const token = process.env.CONFLUENCE_API_TOKEN;
5  if (!email || !token) {
6    throw new Error('CONFLUENCE_EMAIL and CONFLUENCE_API_TOKEN must be set in .env');
7  }
8  return `Basic ${Buffer.from(`${email}:${token}`).toString('base64')}`;
9}
10
11function getBaseUrl(): string {
12  const domain = process.env.CONFLUENCE_DOMAIN;
13  if (!domain) throw new Error('CONFLUENCE_DOMAIN must be set in .env');
14  return `https://${domain}/wiki`;
15}
16
17type FetchOptions = {
18  method?: string;
19  body?: unknown;
20};
21
22async function confluenceFetchInternal<T = unknown>(
23  path: string,
24  params?: Record<string, string | number>,
25  options: FetchOptions = {}
26): Promise<T> {
27  const url = new URL(`${getBaseUrl()}${path}`);
28  if (params) {
29    Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, String(v)));
30  }
31
32  const response = await fetch(url.toString(), {
33    method: options.method || 'GET',
34    headers: {
35      Authorization: getAuthHeader(),
36      'Content-Type': 'application/json',
37      Accept: 'application/json',
38    },
39    body: options.body ? JSON.stringify(options.body) : undefined,
40  });
41
42  if (!response.ok) {
43    const err = await response.json().catch(() => ({ message: response.statusText })) as { message?: string };
44    throw new Error(err.message || `Confluence API error: ${response.status} ${path}`);
45  }
46
47  return response.json() as Promise<T>;
48}
49
50// REST API v2 (modern)
51export async function confluenceV2<T = unknown>(
52  path: string,
53  params?: Record<string, string | number>
54): Promise<T> {
55  return confluenceFetchInternal<T>(`/api/v2${path}`, params);
56}
57
58// REST API v1 (legacy, needed for search and some content endpoints)
59export async function confluenceV1<T = unknown>(
60  path: string,
61  params?: Record<string, string | number>
62): Promise<T> {
63  return confluenceFetchInternal<T>(`/rest/api${path}`, params);
64}

1// app/api/confluence/pages/route.ts
2import { NextResponse } from 'next/server';
3import { confluenceV2 } from '@/lib/confluence';
4
5interface ConfluencePage {
6  id: string;
7  title: string;
8  status: string;
9  version: { number: number; createdAt: string };
10  parentId: string | null;
11  spaceId: string;
12  _links: { webui: string };
13}
14
15interface ConfluencePagesResponse {
16  results: ConfluencePage[];
17  _links: { next?: string };
18}
19
20const cache = new Map<string, { data: unknown; expiresAt: number }>();
21
22export async function GET(request: Request) {
23  const { searchParams } = new URL(request.url);
24  const spaceId = searchParams.get('spaceId');
25  const parentId = searchParams.get('parentId');
26  const limit = parseInt(searchParams.get('limit') || '25', 10);
27  const cursor = searchParams.get('cursor');
28
29  if (!spaceId) {
30    return NextResponse.json({ error: 'spaceId is required' }, { status: 400 });
31  }
32
33  const cacheKey = `${spaceId}-${parentId}-${limit}-${cursor}`;
34  const cached = cache.get(cacheKey);
35  if (cached && Date.now() < cached.expiresAt) {
36    return NextResponse.json(cached.data);
37  }
38
39  try {
40    const params: Record<string, string | number> = {
41      'space-id': spaceId,
42      status: 'current',
43      limit,
44    };
45    if (parentId) params['parent-id'] = parentId;
46    if (cursor) params.cursor = cursor;
47
48    const data = await confluenceV2<ConfluencePagesResponse>('/pages', params);
49
50    const domain = process.env.CONFLUENCE_DOMAIN;
51    const result = {
52      pages: data.results.map((p) => ({
53        id: p.id,
54        title: p.title,
55        status: p.status,
56        version: p.version.number,
57        updatedAt: p.version.createdAt,
58        parentId: p.parentId,
59        url: `https://${domain}/wiki${p._links.webui}`,
60      })),
61      nextCursor: data._links.next
62        ? new URL(data._links.next, 'https://x').searchParams.get('cursor')
63        : null,
64    };
65
66    cache.set(cacheKey, { data: result, expiresAt: Date.now() + 60_000 });
67    return NextResponse.json(result);
68  } catch (err) {
69    const message = err instanceof Error ? err.message : 'Failed to fetch pages';
70    return NextResponse.json({ error: message }, { status: 500 });
71  }
72}

1// app/api/confluence/pages/[id]/route.ts
2import { NextResponse } from 'next/server';
3import { confluenceV2 } from '@/lib/confluence';
4
5interface ConfluencePageDetail {
6  id: string;
7  title: string;
8  status: string;
9  version: { number: number; createdAt: string; authorId: string };
10  spaceId: string;
11  body: { view: { value: string; representation: string } };
12  _links: { webui: string };
13}
14
15function cleanConfluenceHtml(html: string): string {
16  if (!html) return '';
17  return html
18    // Remove inline style attributes
19    .replace(/\sstyle="[^"]*"/gi, '')
20    // Remove Confluence-specific data attributes
21    .replace(/\sdata-[a-z-]+="[^"]*"/gi, '')
22    // Remove ac: namespace elements (Confluence macros rendered as HTML)
23    .replace(/<ac:[^>]*>.*?<\/ac:[^>]*>/gs, '')
24    .replace(/<ac:[^/]*/gi, '')
25    // Normalize spaces
26    .replace(/\s+/g, ' ')
27    .trim();
28}
29
30export async function GET(
31  _request: Request,
32  { params }: { params: { id: string } }
33) {
34  try {
35    const page = await confluenceV2<ConfluencePageDetail>(`/pages/${params.id}`, {
36      'body-format': 'view',
37    });
38
39    const domain = process.env.CONFLUENCE_DOMAIN;
40    const cleanHtml = cleanConfluenceHtml(page.body?.view?.value || '');
41
42    return NextResponse.json({
43      id: page.id,
44      title: page.title,
45      html: cleanHtml,
46      lastUpdated: page.version.createdAt,
47      version: page.version.number,
48      spaceId: page.spaceId,
49      url: `https://${domain}/wiki${page._links.webui}`,
50    });
51  } catch (err) {
52    const message = err instanceof Error ? err.message : 'Failed to fetch page content';
53    return NextResponse.json({ error: message }, { status: 500 });
54  }
55}

1// app/api/confluence/search/route.ts
2import { NextResponse } from 'next/server';
3import { confluenceV1 } from '@/lib/confluence';
4
5interface SearchResult {
6  id: string;
7  title: string;
8  type: string;
9  excerpt: string;
10  space: { key: string; name: string };
11  history: { lastUpdated: { when: string; by: { displayName: string } } };
12  _links: { webui: string };
13}
14
15interface SearchResponse {
16  results: SearchResult[];
17  totalSize: number;
18  start: number;
19  limit: number;
20}
21
22export async function GET(request: Request) {
23  const { searchParams } = new URL(request.url);
24  const query = searchParams.get('query')?.trim();
25  const spaceKey = searchParams.get('spaceKey');
26  const type = searchParams.get('type') || 'page';
27  const limit = parseInt(searchParams.get('limit') || '10', 10);
28
29  if (!query) {
30    return NextResponse.json({ error: 'query parameter is required' }, { status: 400 });
31  }
32
33  // Escape CQL special characters in query
34  const escapedQuery = query.replace(/"/g, '\\"');
35
36  let cql = `type = "${type}" AND (title ~ "${escapedQuery}" OR text ~ "${escapedQuery}")`;
37  if (spaceKey) cql += ` AND space.key = "${spaceKey}"`;
38  cql += ' ORDER BY score DESC';
39
40  try {
41    const domain = process.env.CONFLUENCE_DOMAIN;
42    const data = await confluenceV1<SearchResponse>('/content/search', {
43      cql,
44      limit,
45      expand: 'space,history,history.lastUpdated',
46    });
47
48    const results = data.results.map((r) => ({
49      id: r.id,
50      title: r.title,
51      type: r.type,
52      excerpt: r.excerpt || '',
53      space: { key: r.space?.key, name: r.space?.name },
54      lastUpdated: r.history?.lastUpdated?.when,
55      updatedBy: r.history?.lastUpdated?.by?.displayName,
56      url: `https://${domain}/wiki${r._links.webui}`,
57    }));
58
59    return NextResponse.json({ results, total: data.totalSize });
60  } catch (err) {
61    const message = err instanceof Error ? err.message : 'Confluence search failed';
62    return NextResponse.json({ error: message }, { status: 500 });
63  }
64}