@kelpie/server 0.8.0 → 0.10.0

package/src/modules/forms/schema.ts

@@ -1,14 +1,23 @@
-import { FORM_FIELD_MAP_TARGETS, FORM_FIELD_TYPES, FORM_STATUSES } from '@kelpie/schemas'
-import type { FormOptionValueType } from '@kelpie/schemas'
-import { boolean, index, integer, jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import {
+  FORM_FIELD_MAP_TARGETS,
+  FORM_FIELD_TYPES,
+  FORM_STATUSES,
+  PIPELINE_KINDS,
+} from '@kelpie/schemas'
+import type { FormOptionValueType, FormSubmissionActionEntry } from '@kelpie/schemas'
+import { boolean, index, integer, jsonb, pgTable, primaryKey, text } from 'drizzle-orm/pg-core'
 
 import { checkOneOf, createdAt, moment, primaryId, updatedAt } from '../../lib/columns.ts'
 import { companies } from '../companies/schema.ts'
 import { deals } from '../deals/schema.ts'
+import { enquiries } from '../enquiries/schema.ts'
+import { lists } from '../lists/schema.ts'
+import { opportunities } from '../opportunities/schema.ts'
+import { partnerships } from '../partnerships/schema.ts'
 import { people } from '../people/schema.ts'
 import { pipelineStages } from '../pipelines/schema.ts'
 import { positions } from '../positions/schema.ts'
-import { workspaces } from '../workspace/schema.ts'
+import { workspaceMembers, workspaces } from '../workspace/schema.ts'
 
 /**
  * The fixed value sets come from `@kelpie/schemas`, so these tables' check
@@ -52,6 +61,14 @@ export interface StoredFormFieldOption {
 /**
  * Embeddable inbound forms. `public_key` is globally unique because the public
  * submit endpoint resolves the workspace from it, with no credentials.
+ *
+ * The opportunity/partnership trigger columns mirror the deal trigger: a
+ * toggle, an optional stage (null → first open at submit), a required kind
+ * while the toggle is on (enforced in the service, so a stage id from the
+ * wrong pipeline can be rejected in the same 422 the deal path uses), a
+ * template that expands `{{company.name}}` / `{{person.name}}`, and an owner
+ * (null → workspace default member). Owner fks are `set null` on member
+ * removal so the workspace can still delete a member who owns a form action.
  */
 export const forms = pgTable(
   'forms',
@@ -61,12 +78,51 @@ export const forms = pgTable(
       .notNull()
       .references(() => workspaces.id, { onDelete: 'cascade' }),
     name: text('name').notNull(),
+    /**
+     * Heading shown on the hosted/embed page. Independent of `name` (the CRM
+     * label); defaults to `name` at create time.
+     */
+    title: text('title').notNull(),
     description: text('description'),
     status: text('status').notNull().default('active'),
     thankYouMessage: text('thank_you_message').notNull().default(''),
     createDeal: boolean('create_deal').notNull().default(false),
     dealStageId: text('deal_stage_id').references(() => pipelineStages.id, { onDelete: 'restrict' }),
     dealNameTemplate: text('deal_name_template'),
+    createOpportunity: boolean('create_opportunity').notNull().default(false),
+    opportunityKind: text('opportunity_kind'),
+    opportunityStageId: text('opportunity_stage_id').references(() => pipelineStages.id, {
+      onDelete: 'restrict',
+    }),
+    opportunityNameTemplate: text('opportunity_name_template'),
+    opportunityOwnerId: text('opportunity_owner_id').references(() => workspaceMembers.id, {
+      onDelete: 'set null',
+    }),
+    createPartnership: boolean('create_partnership').notNull().default(false),
+    partnershipKind: text('partnership_kind'),
+    partnershipStageId: text('partnership_stage_id').references(() => pipelineStages.id, {
+      onDelete: 'restrict',
+    }),
+    partnershipNameTemplate: text('partnership_name_template'),
+    partnershipOwnerId: text('partnership_owner_id').references(() => workspaceMembers.id, {
+      onDelete: 'set null',
+    }),
+    createEnquiry: boolean('create_enquiry').notNull().default(false),
+    /**
+     * Optional free-text `source` written onto every enquiry the form creates
+     * (e.g. "Website contact"). Enquiries have no `kind` so there is no
+     * required-kind rule — an unset source stores empty on the enquiry.
+     */
+    enquirySource: text('enquiry_source'),
+    enquiryStageId: text('enquiry_stage_id').references(() => pipelineStages.id, {
+      onDelete: 'restrict',
+    }),
+    enquiryNameTemplate: text('enquiry_name_template'),
+    enquiryOwnerId: text('enquiry_owner_id').references(() => workspaceMembers.id, {
+      onDelete: 'set null',
+    }),
+    personTags: text('person_tags').array().notNull().default([]),
+    companyTags: text('company_tags').array().notNull().default([]),
     publicKey: text('public_key').notNull().unique(),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
@@ -77,6 +133,65 @@ export const forms = pgTable(
   ],
 )
 
+/**
+ * Lists (person or company) every matching record from a submit is added to.
+ *
+ * The pair `(form_id, list_id)` is the natural key. No `id`, because the row
+ * never crosses the wire — the form body carries a `list_ids: [...]` array
+ * and the service reconciles it by set-diff. Both fks cascade: deleting a
+ * list drops the action from every form naming it, keeping the promise in
+ * `lists.md` that a list delete is never blocked.
+ */
+export const formLists = pgTable(
+  'form_lists',
+  {
+    workspaceId: text('workspace_id')
+      .notNull()
+      .references(() => workspaces.id, { onDelete: 'cascade' }),
+    formId: text('form_id')
+      .notNull()
+      .references(() => forms.id, { onDelete: 'cascade' }),
+    listId: text('list_id')
+      .notNull()
+      .references(() => lists.id, { onDelete: 'cascade' }),
+  },
+  (table) => [
+    primaryKey({ columns: [table.formId, table.listId] }),
+    index('form_lists_workspace_idx').on(table.workspaceId),
+  ],
+)
+
+/**
+ * Pre-existing pipeline records every submitter is linked to via
+ * `person_links`. Polymorphic per the convention notes/lists/plans/person_links
+ * use: no fk to the target, existence checked by the service, rows removed in
+ * the target's own delete transaction (`attachedRecords.ts`). No `id` — the
+ * triple already identifies a row and the wire carries `attach_targets`
+ * nested in the form body.
+ */
+export const formAttachTargets = pgTable(
+  'form_attach_targets',
+  {
+    workspaceId: text('workspace_id')
+      .notNull()
+      .references(() => workspaces.id, { onDelete: 'cascade' }),
+    formId: text('form_id')
+      .notNull()
+      .references(() => forms.id, { onDelete: 'cascade' }),
+    targetType: text('target_type').notNull(),
+    targetId: text('target_id').notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.formId, table.targetType, table.targetId] }),
+    index('form_attach_targets_target_idx').on(
+      table.workspaceId,
+      table.targetType,
+      table.targetId,
+    ),
+    checkOneOf('form_attach_targets_target_type_check', table.targetType, PIPELINE_KINDS),
+  ],
+)
+
 /**
  * `map_to` decides what a field writes on submit. At most one `person.email`
  * mapping per form, enforced in the service layer because that is a per-form
@@ -98,6 +213,36 @@ export const formFields = pgTable(
     mapTo: text('map_to').notNull(),
     options: jsonb('options').$type<readonly StoredFormFieldOption[]>().notNull().default([]),
     placeholder: text('placeholder'),
+    /**
+     * The checkbox statement for a `consent` field — the intro sentence that
+     * sits above the list of purpose checkboxes. `label` is the field's
+     * heading; `statement` is what the visitor reads before ticking. Null for
+     * every other type.
+     */
+    statement: text('statement'),
+    /**
+     * The workspace consent purposes a `consent` field offers, in the order
+     * the visitor sees them. Required (non-empty) when `type === 'consent'`.
+     * A `text[]` rather than a join table because the set is small (usually
+     * one to three), always read whole, and never queried into; the service
+     * validates each id against `consent_purposes` and refuses an unknown one
+     * at 422, and the purposes module refuses to delete a purpose still
+     * listed on any form field (`form_fields.consent_purpose_ids` scan).
+     */
+    consentPurposeIds: text('consent_purpose_ids')
+      .array()
+      .notNull()
+      .default([]),
+    /**
+     * Optional per-purpose override for the text shown next to each checkbox.
+     * Keyed by purpose id; absent keys fall back to the workspace purpose's
+     * own label. Bound to the same purpose the checkbox grants — the map
+     * changes wording, never which purpose is being consented to.
+     */
+    consentPurposeLabels: jsonb('consent_purpose_labels')
+      .$type<Readonly<Record<string, string>>>()
+      .notNull()
+      .default({}),
     sortOrder: integer('sort_order').notNull(),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
@@ -112,6 +257,12 @@ export const formFields = pgTable(
 /**
  * Record links are set null rather than cascade: a submission stays as evidence
  * of what arrived even after the record it created is deleted.
+ *
+ * `action_log` is one entry per post-submit action attempted, in order. Empty
+ * for a form with no post-actions configured, and empty on a legacy row from
+ * before the column existed (the migration defaults it). Persisted so the
+ * Submissions UI and API readers see what ran, what was skipped, and what
+ * rolled back.
  */
 export const formSubmissions = pgTable(
   'form_submissions',
@@ -129,6 +280,17 @@ export const formSubmissions = pgTable(
     companyId: text('company_id').references(() => companies.id, { onDelete: 'set null' }),
     positionId: text('position_id').references(() => positions.id, { onDelete: 'set null' }),
     dealId: text('deal_id').references(() => deals.id, { onDelete: 'set null' }),
+    opportunityId: text('opportunity_id').references(() => opportunities.id, {
+      onDelete: 'set null',
+    }),
+    partnershipId: text('partnership_id').references(() => partnerships.id, {
+      onDelete: 'set null',
+    }),
+    enquiryId: text('enquiry_id').references(() => enquiries.id, { onDelete: 'set null' }),
+    actionLog: jsonb('action_log')
+      .$type<readonly FormSubmissionActionEntry[]>()
+      .notNull()
+      .default([]),
     createdAt: createdAt(),
   },
   (table) => [index('form_submissions_form_idx').on(table.formId)],