fix(connectors): paginate the Confluence pages selector instead of returning one page

`/api/tools/confluence/pages` issued a single request and discarded the
`_links.next` cursor Confluence returns, so the picker showed only the first
`limit` pages of however many exist — a search for a real page found nothing,
with no error and no truncation signal.

Threads the documented opaque cursor and moves the selector to `fetchPage`, so
the option list drains like `confluence.spaces` and reports real `hasMore` /
`truncated` state. The `title` server-side filter is unchanged and now paginates
too. `limit` is deliberately left at its existing default: the endpoint's maximum
is not confirmable from Atlassian's published reference, and raising it is not
needed for correctness.

Also guards `data.results`, which threw when the response omitted it.

Author: waleedlatif1

apps/sim/app/api/tools/confluence/pages/route.ts

@@ -23,7 +23,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
     const parsed = await parseRequest(confluencePagesSelectorContract, request, {})
     if (!parsed.success) return parsed.response
 
-    const { domain, accessToken, title, cloudId: providedCloudId, limit } = parsed.data.body
+    const { domain, accessToken, title, cloudId: providedCloudId, limit, cursor } = parsed.data.body
 
     const cloudId = providedCloudId || (await getConfluenceCloudId(domain, accessToken))
 
@@ -43,6 +43,10 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       queryParams.append('title', title)
     }
 
+    if (cursor) {
+      queryParams.append('cursor', cursor)
+    }
+
     const queryString = queryParams.toString()
     const url = queryString ? `${baseUrl}?${queryString}` : baseUrl
 
@@ -82,8 +86,24 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       }
     }
 
+    /**
+     * Confluence paginates with an opaque cursor carried in `_links.next`. Reading
+     * it is what lets the selector continue past the first page — without it the
+     * dropdown silently showed only `limit` pages of however many exist.
+     */
+    let nextCursor: string | undefined
+    const nextLink = data._links?.next as string | undefined
+    if (nextLink) {
+      try {
+        nextCursor =
+          new URL(nextLink, 'https://placeholder').searchParams.get('cursor') || undefined
+      } catch {
+        nextCursor = undefined
+      }
+    }
+
     return NextResponse.json({
-      files: data.results.map((page: any) => ({
+      files: (data.results || []).map((page: any) => ({
         id: page.id,
         name: page.title,
         mimeType: 'confluence/page',
@@ -92,6 +112,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         spaceId: page.spaceId,
         webViewLink: page._links?.webui || '',
       })),
+      nextCursor,
     })
   } catch (error) {
     logger.error('Error fetching Confluence pages:', error)

apps/sim/hooks/selectors/providers/confluence/selectors.ts

@@ -88,7 +88,14 @@ export const confluenceSelectors = {
       search ?? '',
     ],
     enabled: ({ context }) => Boolean(context.oauthCredential && context.domain),
-    fetchList: async ({ context, search, signal }: SelectorQueryArgs) => {
+    /**
+     * Paged rather than a single fetch: `/pages` is cursor-paginated, so one request
+     * returned only the first `limit` pages of however many exist and the rest were
+     * unreachable — a search for a real page silently found nothing. `search` is
+     * still forwarded as the server-side `title` filter, and pagination now applies
+     * to the filtered stream too.
+     */
+    fetchPage: async ({ context, search, cursor, signal }) => {
       const credentialId = ensureCredential(context, 'confluence.pages')
       const domain = ensureDomain(context, 'confluence.pages')
       const bundle = await fetchOAuthToken(credentialId, context.workflowId)
@@ -101,13 +108,17 @@ export const confluenceSelectors = {
           accessToken: bundle.accessToken,
           cloudId: bundle.cloudId,
           title: search,
+          cursor,
         },
         signal,
       })
-      return (data.files || []).map((file) => ({
-        id: file.id,
-        label: file.name,
-      }))
+      return {
+        items: (data.files || []).map((file) => ({
+          id: file.id,
+          label: file.name,
+        })),
+        nextCursor: data.nextCursor,
+      }
     },
     fetchById: async ({ context, detailId, signal }: SelectorQueryArgs) => {
       if (!detailId) return null

apps/sim/lib/api/contracts/selectors/confluence.ts

@@ -24,6 +24,8 @@ export const confluencePagesBodySchema = z.object({
   cloudId: optionalString,
   title: optionalString,
   limit: z.number().int().positive().optional().default(50),
+  /** Opaque Confluence cursor for the next page, echoed back from `nextCursor`. */
+  cursor: optionalString,
 })
 
 /**
@@ -386,7 +388,7 @@ export const confluenceSpacesSelectorContract = definePostSelector(
 export const confluencePagesSelectorContract = definePostSelector(
   '/api/tools/confluence/pages',
   confluencePagesBodySchema,
-  z.object({ files: z.array(fileOptionSchema) })
+  z.object({ files: z.array(fileOptionSchema), nextCursor: optionalString })
 )
 
 export const confluencePageSelectorContract = definePostSelector(