feat: Update APIs

Author: Deathgiver

apps/builder/src/app/api/[[...rest]]/route.ts

@@ -20,7 +20,11 @@ const openAPIHandler = new OpenAPIHandler(router, {
         commonSchemas: {
           UndefinedError: { error: "UndefinedError" },
         },
-        security: [{ bearerAuth: [] }, { developerAccessToken: [] }],
+        security: [
+          { bearerAuth: [] },
+          { developerAccessToken: [] },
+          { apiKeyInUrl: [] },
+        ],
         components: {
           securitySchemes: {
             bearerAuth: {
@@ -31,6 +35,11 @@ const openAPIHandler = new OpenAPIHandler(router, {
               type: "http",
               scheme: "bearer",
             },
+            apiKeyInUrl: {
+              type: "apiKey",
+              in: "query",
+              name: "api_key",
+            },
           },
         },
       },
@@ -53,7 +62,7 @@ const openAPIHandler = new OpenAPIHandler(router, {
 export async function handleRequest(request: Request) {
   const { response } = await openAPIHandler.handle(request, {
     prefix: "/api",
-    context: { headers: request.headers },
+    context: { headers: request.headers, url: request.url },
   })
 
   return response ?? new Response("Not found", { status: 404 })

apps/builder/src/app/api/public-spec.json/route.ts

@@ -18,13 +18,18 @@ async function handleRequest(request: Request) {
     commonSchemas: {
       UndefinedError: { error: "UndefinedError" },
     },
-    security: [{ developerAccessToken: [] }],
+    security: [{ developerAccessToken: [] }, { apiKeyInUrl: [] }],
     components: {
       securitySchemes: {
         developerAccessToken: {
           type: "http",
           scheme: "bearer",
         },
+        apiKeyInUrl: {
+          type: "apiKey",
+          in: "query",
+          name: "api_key",
+        },
       },
     },
     servers: [

apps/builder/src/app/api/scalar-ui/route.ts

@@ -15,16 +15,6 @@ export async function GET() {
         <script>
           Scalar.createApiReference('#app', {
             url: '/api/public-spec.json',
-            authentication: {
-              securitySchemes: {
-                bearerAuth: {
-                  token: 'default-token',
-                },
-                developerAccessToken: {
-                  token: 'default-workspace-token',
-                },
-              },
-            },
           })
         </script>
       </body>

apps/builder/src/app/rpc/[[...rest]]/route.ts

@@ -16,7 +16,7 @@ const rpcHandler = new RPCHandler(router, {
 async function handleRequest(request: Request) {
   const { response } = await rpcHandler.handle(request, {
     prefix: "/rpc",
-    context: { headers: request.headers },
+    context: { headers: request.headers, url: request.url },
   })
 
   return response ?? new Response("Not found", { status: 404 })

apps/builder/src/app/space/[workspaceId]/contacts/page.tsx

@@ -4,7 +4,7 @@ import { getTranslations } from "next-intl/server"
 import type { SearchParams } from "nuqs/server"
 import { Suspense } from "react"
 import { ContactsTable } from "@/features/contacts/contacts-table"
-import { listContacts } from "@/features/contacts/queries/list-contacts.queries"
+import { listContactsRSC } from "@/features/contacts/queries/list-contacts.queries"
 import { listContactsRequest } from "@/features/contacts/schemas/query"
 import { CustomFieldStoreProvider } from "@/features/custom-fields/provider/custom-field-store-context"
 import { InboxStoreProvider } from "@/features/inboxes/provider/inbox-store-context"
@@ -25,7 +25,7 @@ export default async function ContactsPage(props: {
   const { data: search } = listContactsRequest.safeParse(searchParams)
 
   const promises = Promise.all([
-    listContacts({
+    listContactsRSC({
       ...search,
       workspaceId,
     }),

apps/builder/src/features/bot-fields/api/workspace-token.ts

@@ -1,9 +1,9 @@
 import { botFieldService } from "@chatbotx.io/business"
 import z from "zod"
 import {
-  posibleErrorsOnCreatingResource,
-  posibleErrorsOnDeletingResource,
-  posibleErrorsOnFindingResource,
+  possibleErrorsOnCreatingResource,
+  possibleErrorsOnDeletingResource,
+  possibleErrorsOnFindingResource,
 } from "@/lib/orpc/orpc-error-helper"
 import { maxPerPage } from "@/lib/shared-request"
 import { workspaceTokenAuthAPI } from "@/orpc"
@@ -21,7 +21,7 @@ const botFieldWorkspaceTokenAPIs = {
     })
     .input(z.object({}))
     .output(publicListBotFieldsResponse)
-    .errors(posibleErrorsOnFindingResource)
+    .errors(possibleErrorsOnFindingResource)
     .handler(async ({ context }) => {
       const result = await botFieldService.list({
         workspaceId: context.workspace.id,
@@ -44,7 +44,7 @@ const botFieldWorkspaceTokenAPIs = {
     })
     .input(createBotFieldRequest)
     .output(publicBotFieldResource)
-    .errors(posibleErrorsOnCreatingResource)
+    .errors(possibleErrorsOnCreatingResource)
     .handler(
       async ({ context, input }) =>
         await botFieldService.create({
@@ -62,7 +62,7 @@ const botFieldWorkspaceTokenAPIs = {
     })
     .input(z.object({ key: z.string().max(255) }))
     .output(publicBotFieldResource)
-    .errors(posibleErrorsOnFindingResource)
+    .errors(possibleErrorsOnFindingResource)
     .handler(
       async ({ context, input }) =>
         await botFieldService.findByKeyOrFail({
@@ -80,7 +80,7 @@ const botFieldWorkspaceTokenAPIs = {
     })
     .input(z.object({ key: z.string().max(255), value: z.string().max(255) }))
     .output(publicBotFieldResource)
-    .errors(posibleErrorsOnCreatingResource)
+    .errors(possibleErrorsOnCreatingResource)
     .handler(async ({ context, input }) => {
       const { key, ...rest } = input
       return await botFieldService.updateByKey({
@@ -99,7 +99,7 @@ const botFieldWorkspaceTokenAPIs = {
       tags: ["Bot Fields"],
     })
     .input(z.object({ key: z.string().max(255) }))
-    .errors(posibleErrorsOnDeletingResource)
+    .errors(possibleErrorsOnDeletingResource)
     .handler(
       async ({ context, input }) =>
         await botFieldService.deleteByKey({

apps/builder/src/features/bot-fields/queries/index.ts

@@ -0,0 +1,71 @@
+import { db, relationsFilterToSQL } from "@chatbotx.io/database/client"
+import { rootFolderId } from "@chatbotx.io/database/partials"
+import { customFieldModel } from "@chatbotx.io/database/schema"
+import {
+  parseOrderByAsObject,
+  parsePagination,
+} from "@chatbotx.io/database/utils"
+import type { PaginatedResponse } from "@/features/common/schemas/pagination"
+import { assertCurrentUserCanAccessChatbot } from "@/lib/auth/utils"
+import type {
+  FindBotFieldByKeyRequest,
+  FindBotFieldRequest,
+  ListBotFieldsSearchParams,
+} from "../schemas/query"
+import type { BotFieldResource } from "../schemas/resource"
+
+const REGEX_BOT_FIELD_ID = /^\d+$/
+
+export async function listBotFields(
+  input: ListBotFieldsSearchParams,
+): Promise<PaginatedResponse<BotFieldResource>> {
+  await assertCurrentUserCanAccessChatbot(input.workspaceId)
+
+  const where = {
+    workspaceId: input.workspaceId,
+    folderId: input.folderId
+      ? // biome-ignore lint/style/noNestedTernary: allow nested ternary
+        input.folderId === rootFolderId
+        ? { isNull: true as const }
+        : input.folderId
+      : undefined,
+    name: input.name
+      ? {
+          ilike: `%${input.name.toLowerCase()}%`,
+        }
+      : undefined,
+  }
+
+  const orderBy = parseOrderByAsObject(customFieldModel, input)
+
+  const pagination = parsePagination(input)
+  const [data, total] = await Promise.all([
+    db.query.botFieldModel.findMany({
+      where,
+      orderBy,
+      ...pagination,
+    }),
+    db.$count(customFieldModel, relationsFilterToSQL(customFieldModel, where)),
+  ])
+
+  const pageCount = pagination?.limit ? Math.ceil(total / pagination.limit) : 1
+
+  return { data, pageCount }
+}
+
+export const findBotField = async (
+  input: FindBotFieldRequest,
+): Promise<BotFieldResource | undefined> =>
+  await db.query.botFieldModel.findFirst({
+    where: input,
+  })
+
+export const findBotFieldByKey = async (
+  input: FindBotFieldByKeyRequest,
+): Promise<BotFieldResource | undefined> =>
+  await db.query.botFieldModel.findFirst({
+    where: {
+      [REGEX_BOT_FIELD_ID.test(input.key) ? "id" : "name"]: input.key,
+      workspaceId: input.workspaceId,
+    },
+  })

apps/builder/src/features/bot-fields/schemas/query.ts

@@ -6,7 +6,7 @@ import {
 } from "nuqs/server"
 import z from "zod"
 import { parseAsBigInt } from "@/lib/nuqs"
-import { type BotFieldResource, publicBotFieldResource } from "./resource"
+import { type BotFieldResource, botFieldResource, publicBotFieldResource } from "./resource"
 
 export const listBotFieldsSearchParams = createSearchParamsCache({
   page: parseAsInteger.withDefault(1),
@@ -27,3 +27,14 @@ export type ListBotFieldsSearchParams = Awaited<
 export const publicListBotFieldsResponse = z.object({
   data: z.array(publicBotFieldResource),
 })
+
+export const findBotFieldRequest = botFieldResource
+  .pick({ id: true, workspaceId: true, name: true })
+  .partial()
+export type FindBotFieldRequest = z.infer<typeof findBotFieldRequest>
+
+export const findBotFieldByKeyRequest = z.object({
+  key: z.string(),
+  workspaceId: z.string(),
+})
+export type FindBotFieldByKeyRequest = z.infer<typeof findBotFieldByKeyRequest>

apps/builder/src/features/contacts/actions/add-contact-custom-field.action.ts

@@ -202,3 +202,85 @@ export const setContactCustomFieldValue = async ({
 
   revalidateCacheTags(`workspaces:${workspaceId}#contacts`)
 }
+
+export const setContactCustomFieldValues = async ({
+  workspaceId,
+  contactId,
+  fields,
+}: {
+  workspaceId: string
+  contactId: string
+  fields: Array<{ customFieldId: string; value: string }>
+}) => {
+  try {
+    const customFieldIds = fields.map((f) => f.customFieldId)
+
+    const customFields = await db.query.customFieldModel.findMany({
+      where: { workspaceId, id: { in: customFieldIds } },
+      columns: { id: true, name: true },
+    })
+
+    if (customFields.length === 0) {
+      return
+    }
+
+    const existingValues = await db.query.contactCustomFieldModel.findMany({
+      where: {
+        contactId,
+        customFieldId: { in: customFieldIds },
+      },
+    })
+
+    await db.transaction(async (tx) => {
+      const matchedFields = customFields.flatMap((customField) => {
+        const field = fields.find((f) => f.customFieldId === customField.id)
+        return field ? [{ customField, field }] : []
+      })
+
+      await Promise.all(
+        matchedFields.map(({ customField, field }) => {
+          const existing = existingValues.find(
+            (v) => v.customFieldId === customField.id,
+          )
+
+          if (existing) {
+            return tx
+              .update(contactCustomFieldModel)
+              .set({ value: field.value })
+              .where(eq(contactCustomFieldModel.id, existing.id))
+          }
+
+          return tx.insert(contactCustomFieldModel).values({
+            id: createId(),
+            contactId,
+            customFieldId: customField.id,
+            value: field.value,
+          })
+        }),
+      )
+    })
+
+    for (const customField of customFields) {
+      const field = fields.find((f) => f.customFieldId === customField.id)
+      if (!field) {
+        continue
+      }
+      try {
+        await emitCustomFieldChanged(
+          workspaceId,
+          contactId,
+          customField.id,
+          customField.name,
+          null,
+          field.value,
+        )
+      } catch (error) {
+        console.error("Failed to emit customFieldChanged event:", error)
+      }
+    }
+
+    revalidateCacheTags(`workspaces:${workspaceId}#contacts`)
+  } catch (error) {
+    console.error("[setContactCustomFieldValues] Error:", error)
+  }
+}