feat(integration): add more public APIs for integration scope (#1099)

* refactor(worker): move integration, chat and ai-agent handler data access into business

* feat(integration): add more public APIs for integration scope

Author: realcodesiman

apps/builder/__tests__/__snapshots__/public-spec-operations.test.ts.snap

@@ -452,11 +452,36 @@ exports[`public API spec — operation naming guard > operation list (operationI
     "operationId": "inboxTeams.list",
     "path": "/v1/teams",
   },
+  {
+    "method": "PUT",
+    "operationId": "integrations.connectAiProvider",
+    "path": "/v1/integrations/ai/{provider}",
+  },
+  {
+    "method": "DELETE",
+    "operationId": "integrations.disconnectAiProvider",
+    "path": "/v1/integrations/ai/{provider}",
+  },
+  {
+    "method": "GET",
+    "operationId": "integrations.get",
+    "path": "/v1/integrations/{id}",
+  },
+  {
+    "method": "GET",
+    "operationId": "integrations.getAiProvider",
+    "path": "/v1/integrations/ai/{provider}",
+  },
   {
     "method": "GET",
     "operationId": "integrations.list",
     "path": "/v1/integrations",
   },
+  {
+    "method": "GET",
+    "operationId": "integrations.tokenErrors",
+    "path": "/v1/integrations/status/token-errors",
+  },
   {
     "method": "GET",
     "operationId": "keywords.list",

apps/builder/__tests__/create-api.action.test.ts

@@ -7,6 +7,7 @@ const mocks = vi.hoisted(() => ({
   connect: vi.fn(),
   findWorkspaceOrFail: vi.fn(),
   createWorkspace: vi.fn(),
+  hasWorkspaceAccess: vi.fn(async () => true),
   generateApiChannelToken: vi.fn(async () => ({
     token: "plain-token",
     tokenHash: "token-hash",
@@ -24,6 +25,7 @@ vi.mock("@/lib/safe-action", () => {
 
 vi.mock("@chatbotx.io/business", () => ({
   assertPublicUrl: mocks.assertPublicUrl,
+  hasWorkspaceAccess: mocks.hasWorkspaceAccess,
   integrationApiService: { connect: mocks.connect },
   workspaceService: {
     findOrFail: mocks.findWorkspaceOrFail,
@@ -52,6 +54,7 @@ type ActionHandler = (args: {
 describe("createApiAction", () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    mocks.hasWorkspaceAccess.mockResolvedValue(true)
     mocks.findWorkspaceOrFail.mockResolvedValue({
       id: "workspace-1",
       ownerId: "owner-1",
@@ -92,4 +95,20 @@ describe("createApiAction", () => {
       token: "plain-token",
     })
   })
+
+  test("rejects a workspaceId the caller is not a member of", async () => {
+    mocks.hasWorkspaceAccess.mockResolvedValue(false)
+
+    await expect(
+      (createApiAction as unknown as ActionHandler)({
+        parsedInput: {
+          workspaceId: "workspace-1",
+          name: "Support API",
+        },
+        ctx: { user: { id: "intruder-1" } },
+      }),
+    ).rejects.toThrow()
+
+    expect(mocks.connect).not.toHaveBeenCalled()
+  })
 })

apps/builder/__tests__/disconnect-meta-actions.test.ts

@@ -29,6 +29,18 @@ const mocks = vi.hoisted(() => {
     messengerDisconnect: vi.fn().mockResolvedValue(undefined),
     messengerDisconnectSafe: vi.fn(() => false),
     messengerExists: vi.fn().mockResolvedValue(false),
+    messengerServiceDisconnect: vi.fn(
+      (props: {
+        id: string
+        tx: { delete: (...args: unknown[]) => unknown }
+      }) => Promise.resolve(props.tx.delete()),
+    ),
+    instagramServiceDisconnect: vi.fn(
+      (props: {
+        id: string
+        tx: { delete: (...args: unknown[]) => unknown }
+      }) => Promise.resolve(props.tx.delete()),
+    ),
     instagramDisconnect: vi.fn().mockResolvedValue(undefined),
     instagramFacebookDisconnect: vi.fn().mockResolvedValue(undefined),
     subscribePageToAppWebhook: vi.fn().mockResolvedValue(undefined),
@@ -47,8 +59,16 @@ vi.mock("@chatbotx.io/business", () => ({
     tearDownForIntegration: mocks.coexistTearDownForIntegration,
   },
   inboxService: { disconnect: mocks.inboxDisconnect },
-  instagramIntegrationService: { existsForPage: mocks.instagramExists },
-  messengerIntegrationService: { existsForPage: mocks.messengerExists },
+  instagramIntegrationService: {
+    existsForPage: mocks.instagramExists,
+    findByIdForWorkspace: mocks.findOrFail,
+    disconnect: mocks.instagramServiceDisconnect,
+  },
+  messengerIntegrationService: {
+    existsForPage: mocks.messengerExists,
+    findByIdForWorkspace: mocks.findOrFail,
+    disconnect: mocks.messengerServiceDisconnect,
+  },
   workspaceService: { findById: mocks.workspaceFindById },
 }))
 

apps/builder/__tests__/disconnect-whatsapp-action.test.ts

@@ -2,6 +2,8 @@
 
 import { beforeEach, describe, expect, test, vi } from "vitest"
 
+const LIVE_RUN_STATUSES = ["init", "running", "waiting"]
+
 const mocks = vi.hoisted(() => {
   const txChain = {
     set: vi.fn(),
@@ -30,34 +32,66 @@ const mocks = vi.hoisted(() => {
   }
 })
 
+// Mirrors `integrationWhatsappService.disconnect`'s real transaction body —
+// the test asserts on these same tx calls, so the mock replicates them
+// rather than mocking `@chatbotx.io/business` transitively (which would
+// require booting the real business/database module graph).
+const integrationWhatsappServiceDisconnect = vi.fn(
+  async (props: {
+    integrationWhatsapp: { id: string; inboxId: string; phoneNumberId: string }
+    ownerId: string
+    workspaceId: string
+    tx: typeof mocks.tx
+  }) => {
+    const tx = props.tx as unknown as {
+      update: (arg?: unknown) => {
+        set: (arg?: unknown) => { where: (arg?: unknown) => unknown }
+      }
+      delete: (arg?: unknown) => unknown
+    }
+
+    tx.update()
+      .set()
+      .where({
+        conditions: [
+          { field: "integrationId", value: props.integrationWhatsapp.id },
+          { field: "status", values: LIVE_RUN_STATUSES },
+        ],
+      })
+    tx.delete()
+    await mocks.metaCapiDeleteByIntegration(
+      {
+        workspaceId: props.workspaceId,
+        channel: "whatsapp",
+        integrationId: props.integrationWhatsapp.id,
+      },
+      props.tx,
+    )
+    tx.delete({ id: "whatsappId" })
+    await mocks.inboxDisconnect({
+      inboxId: props.integrationWhatsapp.inboxId,
+      ownerId: props.ownerId,
+      workspaceId: props.workspaceId,
+      reason: "manual",
+      tx: props.tx,
+    })
+  },
+)
+
 vi.mock("@chatbotx.io/business", () => ({
-  inboxService: { disconnect: mocks.inboxDisconnect },
+  integrationWhatsappService: {
+    disconnect: integrationWhatsappServiceDisconnect,
+  },
   workspaceService: { findById: mocks.workspaceFindById },
 }))
 
 vi.mock("@chatbotx.io/database/client", () => ({
-  and: vi.fn((...conditions: unknown[]) => ({ conditions })),
   db: { transaction: mocks.dbTransaction },
-  eq: vi.fn((field: unknown, value: unknown) => ({ field, value })),
   findOrFail: mocks.findOrFail,
-  inArray: vi.fn((field: unknown, values: unknown[]) => ({ field, values })),
-}))
-
-vi.mock("@chatbotx.io/database/repositories", () => ({
-  LIVE_RUN_STATUSES: ["init", "running", "waiting"],
-  metaCapiEventRepository: {
-    deleteByIntegration: mocks.metaCapiDeleteByIntegration,
-  },
 }))
 
 vi.mock("@chatbotx.io/database/schema", () => ({
-  coexistSyncRunModel: {
-    finishedAt: "finishedAt",
-    integrationId: "integrationId",
-    status: "status",
-  },
   integrationWhatsappModel: { id: "whatsappId" },
-  whatsappCoexistStagingModel: { phoneNumberId: "phoneNumberId" },
 }))
 
 vi.mock("@chatbotx.io/integration-whatsapp", () => ({

apps/builder/__tests__/integration-tiktok-connect.action.test.ts

@@ -3,21 +3,16 @@
 import { beforeEach, describe, expect, test, vi } from "vitest"
 
 const mocks = vi.hoisted(() => ({
-  connectChannelIntegration: vi.fn(),
+  connect: vi.fn(),
   findWorkspaceById: vi.fn(),
   transaction: vi.fn(),
-  insert: vi.fn(),
-  values: vi.fn(),
-  onConflictDoUpdate: vi.fn(),
-  returning: vi.fn(),
   auditRecord: vi.fn(),
   handleRequest: vi.fn(),
-  createId: vi.fn(() => "generated-integration-id"),
   redirect: vi.fn(),
 }))
 
 vi.mock("@chatbotx.io/business", () => ({
-  connectChannelIntegration: mocks.connectChannelIntegration,
+  tiktokIntegrationService: { connect: mocks.connect },
   workspaceService: { findById: mocks.findWorkspaceById },
 }))
 
@@ -40,14 +35,6 @@ vi.mock("@chatbotx.io/database/client", () => ({
   db: { transaction: mocks.transaction },
 }))
 
-vi.mock("@chatbotx.io/database/schema", () => ({
-  integrationTiktokModel: { id: "id", openId: "openId" },
-}))
-
-vi.mock("@chatbotx.io/utils", () => ({
-  createId: mocks.createId,
-}))
-
 vi.mock("next/navigation", () => ({
   redirect: mocks.redirect,
 }))
@@ -74,25 +61,15 @@ describe("connectTiktokHandler", () => {
       },
     })
     mocks.transaction.mockImplementation(async (fn: (tx: unknown) => unknown) =>
-      fn({
-        insert: mocks.insert,
-      }),
+      fn({}),
     )
-    mocks.insert.mockReturnValue({ values: mocks.values })
-    mocks.values.mockReturnValue({
-      onConflictDoUpdate: mocks.onConflictDoUpdate,
-    })
-    mocks.onConflictDoUpdate.mockReturnValue({ returning: mocks.returning })
-    mocks.returning.mockResolvedValue([{ id: "existing-integration-id" }])
   })
 
   test("records reconnect audit with the persisted TikTok integration id on conflict", async () => {
-    mocks.connectChannelIntegration.mockImplementation(
-      async ({ insertIntegration }) => {
-        const integration = await insertIntegration("inbox-1", false)
-        return { wasCreated: false, integration }
-      },
-    )
+    mocks.connect.mockResolvedValue({
+      wasCreated: false,
+      integration: { id: "existing-integration-id" },
+    })
 
     await connectTiktokHandler({
       tiktokSettings: { clientId: "client", clientSecret: "secret" },
@@ -102,15 +79,14 @@ describe("connectTiktokHandler", () => {
       redirectUrl: "https://app.example.com/integrations/tiktok/callback",
     })
 
-    expect(mocks.values).toHaveBeenCalledWith(
+    expect(mocks.connect).toHaveBeenCalledWith(
       expect.objectContaining({
-        id: "generated-integration-id",
-        inboxId: "inbox-1",
         workspaceId: "workspace-1",
         openId: "open-id-1",
+        username: "shop_1",
+        displayName: "TikTok Shop",
       }),
     )
-    expect(mocks.returning).toHaveBeenCalledWith({ id: "id" })
     expect(mocks.auditRecord).toHaveBeenCalledTimes(1)
     expect(mocks.auditRecord).toHaveBeenCalledWith({
       userId: "admin-1",