chore: import upstream snapshot with attribution

apps/sim/app/api/tools/microsoft-teams/channels/route.ts

@@ -0,0 +1,158 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import { microsoftChannelsSelectorContract } from '@/lib/api/contracts/selectors/microsoft'
+import { parseRequest } from '@/lib/api/server'
+import { authorizeCredentialUse } from '@/lib/auth/credential-access'
+import { validateMicrosoftGraphId } from '@/lib/core/security/input-validation'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { refreshAccessTokenIfNeeded } from '@/app/api/auth/oauth/utils'
+import { assertGraphNextPageUrl, getGraphNextPageUrl } from '@/tools/sharepoint/utils'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('TeamsChannelsAPI')
+
+/**
+ * Upper bound on Microsoft Graph pages drained when listing a team's channels.
+ * The `teams/{id}/channels` endpoint does not support `$top`, so paging is
+ * driven entirely by the server via `@odata.nextLink`. The cap prevents an
+ * unbounded loop; hitting it is logged as a warning.
+ */
+const MAX_CHANNELS_PAGES = 20
+
+interface GraphChannel {
+  id: string
+  displayName?: string
+}
+
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  try {
+    const parsed = await parseRequest(microsoftChannelsSelectorContract, request, {})
+    if (!parsed.success) return parsed.response
+    const { credential, teamId, workflowId } = parsed.data.body
+
+    const teamIdValidation = validateMicrosoftGraphId(teamId, 'Team ID')
+    if (!teamIdValidation.isValid) {
+      logger.warn('Invalid team ID provided', { teamId, error: teamIdValidation.error })
+      return NextResponse.json({ error: teamIdValidation.error }, { status: 400 })
+    }
+
+    try {
+      const authz = await authorizeCredentialUse(request, {
+        credentialId: credential,
+        workflowId,
+      })
+      if (!authz.ok || !authz.credentialOwnerUserId) {
+        return NextResponse.json({ error: authz.error || 'Unauthorized' }, { status: 403 })
+      }
+      const accessToken = await refreshAccessTokenIfNeeded(
+        credential,
+        authz.credentialOwnerUserId,
+        'TeamsChannelsAPI'
+      )
+
+      if (!accessToken) {
+        logger.error('Failed to get access token', {
+          credentialId: credential,
+          userId: authz.credentialOwnerUserId,
+        })
+        return NextResponse.json(
+          {
+            error: 'Could not retrieve access token',
+            authRequired: true,
+          },
+          { status: 401 }
+        )
+      }
+
+      const channels: GraphChannel[] = []
+      let nextPageUrl: string | undefined =
+        `https://graph.microsoft.com/v1.0/teams/${encodeURIComponent(teamId)}/channels`
+
+      for (let page = 0; page < MAX_CHANNELS_PAGES; page++) {
+        const response = await fetch(nextPageUrl, {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+          },
+        })
+
+        if (!response.ok) {
+          const errorData = await response.json()
+          logger.error('Microsoft Graph API error getting channels', {
+            status: response.status,
+            error: errorData,
+            endpoint: nextPageUrl,
+          })
+
+          if (response.status === 401) {
+            return NextResponse.json(
+              {
+                error: 'Authentication failed. Please reconnect your Microsoft Teams account.',
+                authRequired: true,
+              },
+              { status: 401 }
+            )
+          }
+
+          throw new Error(`Microsoft Graph API error: ${JSON.stringify(errorData)}`)
+        }
+
+        const data = await response.json()
+        if (Array.isArray(data.value)) {
+          channels.push(...(data.value as GraphChannel[]))
+        }
+
+        const rawNextLink = getGraphNextPageUrl(data)
+        if (!rawNextLink) {
+          nextPageUrl = undefined
+          break
+        }
+        nextPageUrl = assertGraphNextPageUrl(rawNextLink)
+
+        if (page === MAX_CHANNELS_PAGES - 1) {
+          logger.warn(
+            'Hit Microsoft Graph channels pagination cap; channel list may be incomplete',
+            { maxPages: MAX_CHANNELS_PAGES, collected: channels.length }
+          )
+        }
+      }
+
+      return NextResponse.json({
+        channels: channels,
+      })
+    } catch (innerError) {
+      logger.error('Error during API requests:', innerError)
+
+      const errorMessage = toError(innerError).message
+      if (
+        errorMessage.includes('auth') ||
+        errorMessage.includes('token') ||
+        errorMessage.includes('unauthorized') ||
+        errorMessage.includes('unauthenticated')
+      ) {
+        return NextResponse.json(
+          {
+            error: 'Authentication failed. Please reconnect your Microsoft Teams account.',
+            authRequired: true,
+            details: errorMessage,
+          },
+          { status: 401 }
+        )
+      }
+
+      throw innerError
+    }
+  } catch (error) {
+    logger.error('Error processing Channels request:', error)
+    return NextResponse.json(
+      {
+        error: 'Failed to retrieve Microsoft Teams channels',
+        details: (error as Error).message,
+      },
+      { status: 500 }
+    )
+  }
+})