refactor(builder): move ai feature data access into business services (#1096)

* refactor(builder): move ai feature data access into business services

Removes direct db usage from the builder AI surface (Claude, DeepSeek,
Gemini, OpenAI connect actions and queries, ai-files, ai-functions,
ai-mcp-servers, ai-triggers, personas) per .agents/rules/data-access.md.

- add connect() to the four LLM provider services (mirrors openrouter)
- add aiFileService (create/delete/listWithEmbeddingStatus) and
  aiTriggerService (list/create/duplicate)
- add aiFunctionService.list and
  integrationMessengerRepository.listPersonasByWorkspaceId
- actions/queries become thin wrappers; cache invalidation stays in the
  builder because business must not import @chatbotx.io/ai
- OpenAI connect audits via dispatchAuditRecord with an explicit
  workspaceId (authActionClient has no workspace in the audit context)

* chore: minor changes

Author: realcodesiman

apps/builder/__tests__/ai-files-actions.test.ts

@@ -1,15 +1,8 @@
 import { beforeEach, describe, expect, test, vi } from "vitest"
 
 const mocks = vi.hoisted(() => ({
-  auditRecord: vi.fn(),
-  deleteObject: vi.fn(),
-  findFirstGemini: vi.fn(),
-  findFirstOpenai: vi.fn(),
-  findOrFail: vi.fn(),
-  insertReturning: vi.fn(),
-  loggerWarn: vi.fn(),
-  queueAdd: vi.fn(),
-  txDeleteWhere: vi.fn(),
+  create: vi.fn(),
+  delete: vi.fn(),
 }))
 
 vi.mock("@/lib/safe-action", () => {
@@ -24,33 +17,35 @@ vi.mock("@/features/common/schema", () => ({
   workspaceIdrequestParams: [],
 }))
 
-vi.mock("@/lib/log", () => ({
-  logger: { warn: mocks.loggerWarn },
-}))
-
-vi.mock("@chatbotx.io/business/audit", () => ({
-  auditService: { record: mocks.auditRecord },
+vi.mock("@chatbotx.io/business", () => ({
+  aiFileService: {
+    create: mocks.create,
+    delete: mocks.delete,
+  },
 }))
 
 vi.mock("@chatbotx.io/business/errors", () => ({
-  ChatbotXException: class ChatbotXException extends Error {},
-}))
-
-vi.mock("@chatbotx.io/filesystem", () => ({
-  uploader: { deleteObject: mocks.deleteObject },
+  ChatbotXException: class ChatbotXException extends Error {
+    code = "systemError"
+    httpStatusCode = 400
+
+    constructor(message: string, code?: string, httpStatusCode?: number) {
+      super(message)
+      this.name = "ChatbotXException"
+      if (code) {
+        this.code = code
+      }
+      if (httpStatusCode) {
+        this.httpStatusCode = httpStatusCode
+      }
+    }
+  },
 }))
 
 vi.mock("@chatbotx.io/utils", () => ({
-  createId: () => "file-1",
   zodBigintAsString: () => "mocked-schema",
 }))
 
-vi.mock("@chatbotx.io/worker-config", () => ({
-  HeavyJobAction: { processAIFile: "processAIFile" },
-  getHeavyJobOptions: () => ({}),
-  heavyQueue: { add: mocks.queueAdd },
-}))
-
 vi.mock("next-intl/server", () => ({
   getTranslations: vi.fn(async () => (key: string) => key),
 }))
@@ -59,33 +54,11 @@ vi.mock("../src/features/ai-files/schema", () => ({
   createAIFileRequest: {},
 }))
 
-vi.mock("@chatbotx.io/database/schema", () => ({
-  aiEmbeddingModel: { id: "id" },
-  aiFileModel: { id: "id" },
-}))
-
-vi.mock("@chatbotx.io/database/client", () => ({
-  db: {
-    delete: vi.fn(() => ({ where: mocks.txDeleteWhere })),
-    insert: vi.fn(() => ({
-      values: vi.fn(() => ({ returning: mocks.insertReturning })),
-    })),
-    query: {
-      integrationGeminiModel: { findFirst: mocks.findFirstGemini },
-      integrationOpenaiModel: { findFirst: mocks.findFirstOpenai },
-    },
-    transaction: vi.fn(async (callback: (tx: unknown) => unknown) =>
-      callback({ delete: vi.fn(() => ({ where: mocks.txDeleteWhere })) }),
-    ),
-  },
-  eq: vi.fn((field: unknown, value: unknown) => ({ field, value })),
-  findOrFail: mocks.findOrFail,
-}))
-
+const { ChatbotXException } = await import("@chatbotx.io/business/errors")
 const { createAIFileAction } = await import(
   "@/features/ai-files/actions/create-ai-file.action"
 )
-const { deleteAIFile } = await import(
+const { deleteAIFileAction } = await import(
   "@/features/ai-files/actions/delete-ai-file.action"
 )
 
@@ -98,74 +71,97 @@ const workspaceId = "workspace-1"
 
 beforeEach(() => {
   vi.clearAllMocks()
-  mocks.findFirstOpenai.mockResolvedValue({ id: "openai-1" })
-  mocks.findFirstGemini.mockResolvedValue(undefined)
-  mocks.insertReturning.mockResolvedValue([{ id: "file-1" }])
-  mocks.findOrFail.mockResolvedValue({ id: "file-1", path: "path/to/file" })
 })
 
-describe("Knowledge tab audit messages", () => {
-  test("allows creating a Knowledge with Gemini as the only provider", async () => {
-    mocks.findFirstOpenai.mockResolvedValue(undefined)
-    mocks.findFirstGemini.mockResolvedValue({ id: "gemini-1" })
-
-    await (
-      createAIFileAction as unknown as ActionHandler<{ name: string }, [string]>
-    )({
-      parsedInput: { name: "manual.pdf" },
-      bindArgsParsedInputs: [workspaceId],
-    })
-
-    expect(mocks.insertReturning).toHaveBeenCalled()
-    expect(mocks.queueAdd).toHaveBeenCalled()
-  })
+describe("createAIFileAction", () => {
+  test("forwards workspaceId + parsedInput to aiFileService.create", async () => {
+    mocks.create.mockResolvedValue({ id: "file-1" })
 
-  test("createAIFileAction logs created a new Knowledge by id", async () => {
     await (
-      createAIFileAction as unknown as ActionHandler<{ name: string }, [string]>
+      createAIFileAction as unknown as ActionHandler<
+        { name: string; path: string; mimeType: string; size: number },
+        [string]
+      >
     )({
-      parsedInput: { name: "manual.pdf" },
+      parsedInput: {
+        name: "manual.pdf",
+        path: "path/to/file",
+        mimeType: "application/pdf",
+        size: 100,
+      },
       bindArgsParsedInputs: [workspaceId],
     })
 
-    expect(mocks.auditRecord).toHaveBeenCalledWith({
+    expect(mocks.create).toHaveBeenCalledWith({
       workspaceId,
-      action: "create",
-      detail: "created a new Knowledge (#file-1)",
+      name: "manual.pdf",
+      path: "path/to/file",
+      mimeType: "application/pdf",
+      size: 100,
     })
-    expect(mocks.queueAdd).toHaveBeenCalledWith(
-      "processAIFile",
-      {
-        type: "processAIFile",
-        data: { aiFileId: "file-1" },
-      },
-      { jobId: "heavy-ai-file-file-1" },
-    )
   })
 
-  test("deleteAIFile logs deleted a Knowledge by id", async () => {
-    await deleteAIFile({ workspaceId, id: "file-1" })
+  test("translates a noEmbeddingProvider service error", async () => {
+    mocks.create.mockRejectedValue(
+      new ChatbotXException(
+        "AI file requires an embedding provider",
+        "noEmbeddingProvider",
+        400,
+      ),
+    )
 
-    expect(mocks.auditRecord).toHaveBeenCalledWith({
-      workspaceId,
-      action: "delete",
-      detail: "deleted a Knowledge (#file-1)",
-    })
+    await expect(
+      (
+        createAIFileAction as unknown as ActionHandler<
+          { name: string; path: string; mimeType: string; size: number },
+          [string]
+        >
+      )({
+        parsedInput: {
+          name: "manual.pdf",
+          path: "path/to/file",
+          mimeType: "application/pdf",
+          size: 100,
+        },
+        bindArgsParsedInputs: [workspaceId],
+      }),
+    ).rejects.toMatchObject({ message: "noEmbeddingProvider" })
+  })
+
+  test("rethrows other service errors untranslated", async () => {
+    mocks.create.mockRejectedValue(new Error("db exploded"))
+
+    await expect(
+      (
+        createAIFileAction as unknown as ActionHandler<
+          { name: string; path: string; mimeType: string; size: number },
+          [string]
+        >
+      )({
+        parsedInput: {
+          name: "manual.pdf",
+          path: "path/to/file",
+          mimeType: "application/pdf",
+          size: 100,
+        },
+        bindArgsParsedInputs: [workspaceId],
+      }),
+    ).rejects.toMatchObject({ message: "db exploded" })
   })
+})
 
-  test("does not log the legacy AI Agent knowledge base message", async () => {
+describe("deleteAIFileAction", () => {
+  test("forwards workspaceId + id to aiFileService.delete", async () => {
     await (
-      createAIFileAction as unknown as ActionHandler<{ name: string }, [string]>
+      deleteAIFileAction as unknown as ActionHandler<
+        undefined,
+        [string, string]
+      >
     )({
-      parsedInput: { name: "manual.pdf" },
-      bindArgsParsedInputs: [workspaceId],
+      parsedInput: undefined,
+      bindArgsParsedInputs: [workspaceId, "file-1"],
     })
-    await deleteAIFile({ workspaceId, id: "file-1" })
 
-    for (const call of mocks.auditRecord.mock.calls) {
-      expect(call[0].detail).not.toContain(
-        "updated the AI Agent knowledge base",
-      )
-    }
+    expect(mocks.delete).toHaveBeenCalledWith({ workspaceId, id: "file-1" })
   })
 })

apps/builder/__tests__/ai-triggers-actions.test.ts

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, test, vi } from "vitest"
+
+// ---------------------------------------------------------------------------
+// AI Triggers create/duplicate/list actions — thin wrappers delegating to
+// aiTriggerService. `list` still gates on assertCurrentUserCanAccessChatbot
+// before calling the service.
+// ---------------------------------------------------------------------------
+
+const mocks = vi.hoisted(() => ({
+  assertCurrentUserCanAccessChatbot: vi.fn(),
+  create: vi.fn(),
+  duplicate: vi.fn(),
+  list: vi.fn(),
+}))
+
+vi.mock("@/lib/safe-action", () => {
+  const chain: Record<string, unknown> = {}
+  chain.bindArgsSchemas = () => chain
+  chain.inputSchema = () => chain
+  chain.action = (fn: unknown) => fn
+  return { workspaceActionClient: chain }
+})
+
+vi.mock("@/features/common/schema", () => ({
+  workspaceIdrequestParams: [],
+}))
+
+vi.mock("@/features/ai-triggers/schema/action", () => ({
+  createAITriggerRequest: {},
+}))
+
+vi.mock("@/lib/auth/utils", () => ({
+  assertCurrentUserCanAccessChatbot: mocks.assertCurrentUserCanAccessChatbot,
+}))
+
+vi.mock("@chatbotx.io/utils", () => ({
+  zodBigintAsString: () => "mocked-schema",
+}))
+
+vi.mock("@chatbotx.io/business", () => ({
+  aiTriggerService: {
+    create: mocks.create,
+    duplicate: mocks.duplicate,
+    list: mocks.list,
+  },
+}))
+
+const { createAITriggerAction } = await import(
+  "@/features/ai-triggers/actions/create.action"
+)
+const { duplicateAITriggerAction } = await import(
+  "@/features/ai-triggers/actions/duplicate.action"
+)
+const { listAITriggers } = await import(
+  "@/features/ai-triggers/actions/list.action"
+)
+
+type ActionHandler<TParsedInput, TBindArgs extends unknown[]> = (props: {
+  parsedInput: TParsedInput
+  bindArgsParsedInputs: TBindArgs
+}) => Promise<unknown>
+
+const workspaceId = "workspace-1"
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe("createAITriggerAction", () => {
+  test("delegates to aiTriggerService.create with workspaceId + parsedInput", async () => {
+    const parsedInput = {
+      name: "New trigger",
+      description: null,
+      questions: [],
+      flowId: null,
+      finalMessage: null,
+    }
+
+    await (
+      createAITriggerAction as unknown as ActionHandler<
+        typeof parsedInput,
+        [string]
+      >
+    )({
+      parsedInput,
+      bindArgsParsedInputs: [workspaceId],
+    })
+
+    expect(mocks.create).toHaveBeenCalledWith({
+      workspaceId,
+      data: parsedInput,
+    })
+  })
+})
+
+describe("duplicateAITriggerAction", () => {
+  test("delegates to aiTriggerService.duplicate with workspaceId + id", async () => {
+    await (
+      duplicateAITriggerAction as unknown as ActionHandler<
+        undefined,
+        [string, string]
+      >
+    )({
+      parsedInput: undefined,
+      bindArgsParsedInputs: [workspaceId, "trigger-1"],
+    })
+
+    expect(mocks.duplicate).toHaveBeenCalledWith({
+      workspaceId,
+      id: "trigger-1",
+    })
+  })
+})
+
+describe("listAITriggers", () => {
+  test("asserts chatbot access then delegates to aiTriggerService.list", async () => {
+    const input = {
+      workspaceId,
+      page: 1,
+      perPage: 20,
+      sort: [],
+      name: "",
+    }
+    mocks.list.mockResolvedValue({ data: [], pageCount: 0 })
+
+    const result = await listAITriggers(input)
+
+    expect(mocks.assertCurrentUserCanAccessChatbot).toHaveBeenCalledWith(
+      workspaceId,
+    )
+    expect(mocks.list).toHaveBeenCalledWith(input)
+    expect(result).toEqual({ data: [], pageCount: 0 })
+  })
+})