feat(bot-fields): add bot fields with typed value normalization (#1052)

Author: viethung0o0

apps/builder/__tests__/contact-filter-condition-draft.test.ts

@@ -81,6 +81,14 @@ const booleanCustomFieldConfig: FieldConfig = {
   group: "customFields",
 }
 
+const numberBotFieldConfig: FieldConfig = {
+  name: "botField:bf-1",
+  botFieldId: "bf-1",
+  customFieldType: "number",
+  formField: formFieldTypes.enum.number,
+  group: "botFields",
+}
+
 const couponTopicConfig: FieldConfig = {
   name: "couponTopic:topic-1",
   topicId: "topic-1",
@@ -145,6 +153,26 @@ describe("buildConditionDraft", () => {
     })
   })
 
+  test("maps bot field config to dynamic botField condition shape", () => {
+    expect(
+      buildConditionDraft(
+        {
+          field: "botField:bf-1",
+          operator: operatorTypes.enum.gt,
+          value: "10",
+        },
+        numberBotFieldConfig,
+      ),
+    ).toEqual({
+      field: "botField",
+      botFieldId: "bf-1",
+      botFieldType: "number",
+      valueType: formFieldTypes.enum.number,
+      operator: operatorTypes.enum.gt,
+      value: "10",
+    })
+  })
+
   test("omits empty value for coupon topic used conditions", () => {
     expect(
       buildConditionDraft(
@@ -345,6 +373,21 @@ describe("round-trip editing", () => {
       condition,
     )
   })
+
+  test("keeps a bot field comparison unchanged", () => {
+    const condition: ContactFilterCondition = {
+      field: "botField",
+      botFieldId: "bf-1",
+      botFieldType: "number",
+      valueType: formFieldTypes.enum.number,
+      operator: operatorTypes.enum.gt,
+      value: "10",
+    }
+
+    expect(roundTripCondition(condition, numberBotFieldConfig)).toEqual(
+      condition,
+    )
+  })
 })
 
 describe("getResetDraftForField", () => {
@@ -432,6 +475,21 @@ describe("getConditionOptionsForConfig", () => {
     )
   })
 
+  test("routes bot-field configs through the SAME custom-field condition options helper (reused, not forked)", () => {
+    expect(
+      getConditionOptionsForConfig(numberBotFieldConfig, conditionOptions),
+    ).toEqual(
+      getCustomFieldConditionOptions(numberBotFieldConfig, conditionOptions),
+    )
+    // Bot field and custom field of the same underlying type produce
+    // identical operator availability.
+    expect(
+      getConditionOptionsForConfig(numberBotFieldConfig, conditionOptions),
+    ).toEqual(
+      getConditionOptionsForConfig(numberCustomFieldConfig, conditionOptions),
+    )
+  })
+
   test("returns no operator options without a selected field", () => {
     expect(getConditionOptionsForConfig(undefined, conditionOptions)).toEqual(
       [],
@@ -465,4 +523,12 @@ describe("getDefaultConditionValue", () => {
       ),
     )
   })
+
+  test("routes bot-field default values through the SAME custom-field defaults helper (reused, not forked)", () => {
+    expect(
+      getDefaultConditionValue(numberBotFieldConfig, operatorTypes.enum.gt),
+    ).toEqual(
+      getDefaultCustomFieldValue(numberBotFieldConfig, operatorTypes.enum.gt),
+    )
+  })
 })

apps/builder/__tests__/contact-filter-config.test.ts

@@ -184,6 +184,53 @@ describe("contact filter field config helpers", () => {
     )
   })
 
+  test("omits bot field configs by default (opt-in gating)", () => {
+    const configs = getFieldConfigs({
+      t,
+      tagOptions: [],
+      inboxOptions: [],
+      flowVersionOptions: [],
+      customFields: [],
+      botFields: [{ id: "bf-1", name: "Greeting", type: "shortText" }],
+    })
+
+    expect(
+      configs.find((config) => config.name === "botField:bf-1"),
+    ).toBeUndefined()
+  })
+
+  test("maps workspace bot fields to botField configs when includeBotFields is true", () => {
+    const configs = getFieldConfigs({
+      t,
+      tagOptions: [],
+      inboxOptions: [],
+      flowVersionOptions: [],
+      customFields: [],
+      botFields: [
+        { id: "bf-1", name: "Greeting", type: "shortText" },
+        { id: "bf-2", name: "Order Count", type: "number" },
+      ],
+      includeBotFields: true,
+    })
+
+    expect(configs).toContainEqual(
+      expect.objectContaining({
+        name: "botField:bf-1",
+        botFieldId: "bf-1",
+        customFieldType: "shortText",
+        label: "Greeting",
+        formField: formFieldTypes.enum.text,
+        group: "botFields",
+      }),
+    )
+    expect(configs).toContainEqual(
+      expect.objectContaining({
+        name: "botField:bf-2",
+        formField: formFieldTypes.enum.number,
+      }),
+    )
+  })
+
   test("assigns supported static fields to their configured option groups", () => {
     const configs = getFieldConfigs({
       t,
@@ -483,6 +530,39 @@ describe("contact filter field config helpers", () => {
     )
   })
 
+  test("renders the Bot Fields group immediately after Custom Fields", () => {
+    const configs = getFieldConfigs({
+      t,
+      tagOptions: [],
+      inboxOptions: [],
+      flowVersionOptions: [],
+      customFields: [{ id: "cf-1", name: "Plan", type: "shortText" }],
+      botFields: [{ id: "bf-1", name: "Greeting", type: "shortText" }],
+      includeBotFields: true,
+    })
+
+    const options = getFieldOptions(configs, t)
+    const groupOrder = options
+      .filter((opt) => opt.value.startsWith("group-"))
+      .map((opt) => opt.value)
+    const customFieldsIndex = groupOrder.indexOf("group-customFields")
+    const botFieldsIndex = groupOrder.indexOf("group-botFields")
+
+    expect(customFieldsIndex).toBeGreaterThanOrEqual(0)
+    expect(botFieldsIndex).toBe(customFieldsIndex + 1)
+    expect(options).toContainEqual(
+      expect.objectContaining({
+        value: "group-botFields",
+        children: [
+          {
+            label: "Greeting",
+            value: "botField:bf-1",
+          },
+        ],
+      }),
+    )
+  })
+
   test("preserves configured field order inside each group", () => {
     const configs: FieldConfig[] = [
       {

apps/builder/__tests__/contact-filter-schema.test.ts

@@ -7,6 +7,7 @@ import {
 } from "@chatbotx.io/database/partials"
 import { describe, expect, test } from "vitest"
 import {
+  botFieldConditionSchema,
   contactFilterCriteriaSchema,
   couponTopicConditionSchema,
   customFieldConditionSchema,
@@ -424,6 +425,89 @@ describe("customFieldConditionSchema", () => {
   })
 })
 
+describe("botFieldConditionSchema", () => {
+  test.each([
+    [
+      "short text search",
+      {
+        botFieldType: customFieldTypes.enum.shortText,
+        valueType: formFieldTypes.enum.text,
+        operator: operatorTypes.enum.contains,
+        value: "vip",
+      },
+      true,
+    ],
+    [
+      "number range",
+      {
+        botFieldType: customFieldTypes.enum.number,
+        valueType: formFieldTypes.enum.number,
+        operator: operatorTypes.enum.isBetween,
+        value: ["1", "10"],
+      },
+      true,
+    ],
+    [
+      "datetime range",
+      {
+        botFieldType: customFieldTypes.enum.datetime,
+        valueType: formFieldTypes.enum.datetime,
+        operator: operatorTypes.enum.isBetween,
+        value: ["2026-05-01T00:00:00Z", "2026-05-31T23:59:59Z"],
+      },
+      true,
+    ],
+    [
+      "boolean valueless",
+      {
+        botFieldType: customFieldTypes.enum.boolean,
+        valueType: formFieldTypes.enum.boolean,
+        operator: operatorTypes.enum.isNotEmpty,
+      },
+      true,
+    ],
+    [
+      "long text search disabled",
+      {
+        botFieldType: customFieldTypes.enum.longText,
+        valueType: formFieldTypes.enum.text,
+        operator: operatorTypes.enum.contains,
+        value: "vip",
+      },
+      false,
+    ],
+  ])("validates %s", (_name, values, expected) => {
+    const result = botFieldConditionSchema.safeParse({
+      field: "botField",
+      botFieldId: "bf-1",
+      ...values,
+    })
+
+    expect(result.success).toBe(expected)
+  })
+
+  test("requires botFieldId and two values for interval operators", () => {
+    expect(
+      botFieldConditionSchema.safeParse({
+        field: "botField",
+        valueType: formFieldTypes.enum.text,
+        operator: operatorTypes.enum.eq,
+        value: "vip",
+      }).success,
+    ).toBe(false)
+
+    expect(
+      botFieldConditionSchema.safeParse({
+        field: "botField",
+        botFieldId: "bf-1",
+        valueType: formFieldTypes.enum.number,
+        operator: operatorTypes.enum.isBetween,
+        value: ["1"],
+      }).success,
+    ).toBe(false)
+  })
+})
+
 describe("contact filter union schemas", () => {
   test("accepts static and custom field conditions", () => {
     expect(
@@ -445,6 +529,18 @@ describe("contact filter union schemas", () => {
     ).toBe(true)
   })
 
+  test("accepts bot field conditions", () => {
+    expect(
+      singleContactFilterConditionSchema.safeParse({
+        field: "botField",
+        botFieldId: "bf-1",
+        valueType: formFieldTypes.enum.text,
+        operator: operatorTypes.enum.eq,
+        value: "vip",
+      }).success,
+    ).toBe(true)
+  })
+
   test("rejects bogus public field names", () => {
     expect(
       contactFilterCriteriaSchema.safeParse({

apps/builder/__tests__/contact-filter-value-inputs.test.tsx

@@ -221,6 +221,13 @@ const configs = {
     formField: formFieldTypes.enum.text,
     group: "topicCoupon",
   },
+  customBoolean: {
+    name: "customField:cf-1",
+    customFieldId: "cf-1",
+    customFieldType: "boolean",
+    formField: formFieldTypes.enum.boolean,
+    group: "customFields",
+  },
 } as const satisfies Record<string, FieldConfig>
 
 let container: HTMLDivElement
@@ -312,13 +319,68 @@ describe("ContactFilterConditionDialog value inputs", () => {
     expect(container.querySelector('[data-testid="input-value"]')).toBeNull()
   })
 
+  // Custom/bot boolean fields mirror the Set Custom Field step: free text
+  // input (picker opens on click) instead of the static-field select.
+  test("renders a free text input for a custom boolean field", () => {
+    renderDialog({ config: configs.customBoolean, value: "true" })
+
+    expect(
+      container.querySelector('[data-testid="input-value"]'),
+    ).not.toBeNull()
+    expect(container.querySelector('[data-testid="select-value"]')).toBeNull()
+  })
+
+  test("canonicalizes a typed boolean literal to true/false on submit", async () => {
+    const { onSubmit } = renderDialog({
+      config: configs.customBoolean,
+      value: "Yes",
+    })
+
+    act(() => {
+      container
+        .querySelector("form")
+        ?.dispatchEvent(
+          new SubmitEvent("submit", { bubbles: true, cancelable: true }),
+        )
+    })
+
+    await vi.waitFor(() => {
+      expect(onSubmit).toHaveBeenCalledWith(
+        expect.objectContaining({ value: "true" }),
+      )
+    })
+  })
+
+  test("disables save for an unrecognized boolean value", () => {
+    const { onSubmit } = renderDialog({
+      config: configs.customBoolean,
+      value: "maybe",
+    })
+
+    expect(
+      (
+        container.querySelector(
+          'button[type="submit"]',
+        ) as HTMLButtonElement | null
+      )?.disabled,
+    ).toBe(true)
+    act(() => {
+      container
+        .querySelector("form")
+        ?.dispatchEvent(
+          new SubmitEvent("submit", { bubbles: true, cancelable: true }),
+        )
+    })
+    expect(onSubmit).not.toHaveBeenCalled()
+  })
+
   test("keeps boolean and option fields on select controls", () => {
     renderDialog({ config: configs.boolean, value: "true" })
     expect(
       container.querySelector('[data-testid="select-value"]'),
     ).not.toBeNull()
-    expect(container.textContent).toContain("Yes")
-    expect(container.textContent).toContain("No")
+    expect(container.textContent).toContain("fields.boolean.true")
+    expect(container.textContent).toContain("fields.boolean.false")
 
     renderDialog({ config: configs.select, value: "female" })
     expect(