@kelpie/server 0.7.0 → 0.9.0

package/src/modules/custom-fields/values.ts

@@ -0,0 +1,352 @@
+import type { CustomFieldValue, CustomFieldWireValue } from '@kelpie/schemas'
+
+import { AppError } from '../../lib/errors.ts'
+import type { ErrorDetail } from '../../lib/errors.ts'
+import type { Queryable } from '../../runtime/transaction.ts'
+import { definitionsForObject } from './repository.ts'
+import type { CustomFieldDefinitionRecord } from './repository.ts'
+import type { CustomFieldObjectType } from './schema.ts'
+
+/**
+ * The service half of custom-field values: definition-aware validation, merge
+ * semantics, and the per-key diff a `record.updated` event carries.
+ *
+ * The Zod layer on the record's route body only checks structure (that a value
+ * looks like text/number/boolean/list/money). Everything below reads the
+ * workspace's definitions and enforces the concrete type, the select-option
+ * membership, and the caps every type carries. Mismatches throw the same
+ * `AppError.validationFailed(msg, [{field: 'custom_fields.<key>', message}])`
+ * `readJsonBody` produces, so an unknown key and a wrong-type value read alike
+ * to a client.
+ */
+
+const MAX_TEXT_LENGTH = 4096
+const MAX_LONG_TEXT_LENGTH = 65536
+const MAX_URL_LENGTH = 2048
+const MAX_MULTI_SELECT_ENTRIES = 100
+
+/** The stored jsonb value for one custom field, as the record carries it. */
+export type StoredCustomFieldValue = CustomFieldValue
+
+/** The result of merging a `PATCH` into the stored `custom_fields` object. */
+export interface CustomFieldsMerge {
+  /** The whole custom_fields object to write, with keys sorted for stable diffs. */
+  readonly merged: Readonly<Record<string, StoredCustomFieldValue>>
+  /** Per-key change paths, `customFields.<key>`, for the `.updated` event's `changed`. */
+  readonly changedPaths: readonly string[]
+  /** Definition labels for the keys that changed, keyed by their `customFields.<key>` path. */
+  readonly labels: Readonly<Record<string, string>>
+  /** Flat before-values for `describeUpdate`, keyed by `customFields.<key>`. */
+  readonly flatBefore: Readonly<Record<string, StoredCustomFieldValue | undefined>>
+  /** Flat after-values for `describeUpdate`, keyed by `customFields.<key>`. */
+  readonly flatAfter: Readonly<Record<string, StoredCustomFieldValue | undefined>>
+}
+
+export interface CustomFieldValuesDependencies {
+  readonly db: Queryable
+}
+
+export interface CustomFieldValuesValidator {
+  /**
+   * Validates and normalises the `custom_fields` a record is being created with.
+   * `null` keys are ignored. Missing keys are simply absent from the result.
+   */
+  forCreate(
+    tx: Queryable,
+    workspaceId: string,
+    objectType: CustomFieldObjectType,
+    sent: Readonly<Record<string, CustomFieldWireValue | null>> | undefined,
+  ): Promise<Readonly<Record<string, StoredCustomFieldValue>>>
+
+  /**
+   * Merges a `PATCH` into the stored `custom_fields`, validating every sent
+   * key against the workspace's definitions. `null` clears a key. An unknown
+   * key is `422`.
+   */
+  forUpdate(
+    tx: Queryable,
+    workspaceId: string,
+    objectType: CustomFieldObjectType,
+    stored: Readonly<Record<string, StoredCustomFieldValue>>,
+    sent: Readonly<Record<string, CustomFieldWireValue | null>> | undefined,
+  ): Promise<CustomFieldsMerge | undefined>
+}
+
+export function createCustomFieldValues(
+  _dependencies: CustomFieldValuesDependencies,
+): CustomFieldValuesValidator {
+  return {
+    async forCreate(tx, workspaceId, objectType, sent) {
+      if (sent === undefined) {
+        return {}
+      }
+      const definitions = await definitionsForObject(tx, workspaceId, objectType)
+      const byKey = new Map(definitions.map((definition) => [definition.key, definition]))
+      const out: Record<string, StoredCustomFieldValue> = {}
+
+      for (const [key, value] of Object.entries(sent)) {
+        if (value === null) {
+          // A create with a `null` value has nothing to store; skip.
+          continue
+        }
+        const definition = byKey.get(key)
+        if (definition === undefined) {
+          throw unknownKey(key)
+        }
+        out[key] = validateValue(definition, value)
+      }
+
+      return normaliseCustomFields(out)
+    },
+
+    async forUpdate(tx, workspaceId, objectType, stored, sent) {
+      if (sent === undefined) {
+        return undefined
+      }
+      const definitions = await definitionsForObject(tx, workspaceId, objectType)
+      const byKey = new Map(definitions.map((definition) => [definition.key, definition]))
+      const next: Record<string, StoredCustomFieldValue> = { ...stored }
+      const changedPaths: string[] = []
+      const labels: Record<string, string> = {}
+      const flatBefore: Record<string, StoredCustomFieldValue | undefined> = {}
+      const flatAfter: Record<string, StoredCustomFieldValue | undefined> = {}
+
+      for (const [key, value] of Object.entries(sent)) {
+        const definition = byKey.get(key)
+        if (definition === undefined) {
+          throw unknownKey(key)
+        }
+        const path = `customFields.${key}`
+        const before = stored[key]
+
+        if (value === null) {
+          if (before === undefined) {
+            continue
+          }
+          delete next[key]
+          changedPaths.push(path)
+          labels[path] = definition.label
+          flatBefore[path] = before
+          flatAfter[path] = undefined
+          continue
+        }
+
+        const validated = validateValue(definition, value)
+        if (!sameValue(before, validated)) {
+          next[key] = validated
+          changedPaths.push(path)
+          labels[path] = definition.label
+          flatBefore[path] = before
+          flatAfter[path] = validated
+        } else {
+          // Sent again with the identical value: no change, no path, but keep
+          // the value in `next` (a shallow copy already did that).
+          next[key] = validated
+        }
+      }
+
+      return {
+        merged: normaliseCustomFields(next),
+        changedPaths,
+        labels,
+        flatBefore,
+        flatAfter,
+      }
+    },
+  }
+}
+
+/**
+ * Rebuilds the object with keys in sorted order.
+ *
+ * `changedKeys` in `lib/changes.ts` compares by `JSON.stringify`, so two
+ * objects with the same entries but different insertion order would look
+ * different. Every stored write and every diffed comparison passes through
+ * this so the two agree.
+ */
+export function normaliseCustomFields(
+  values: Readonly<Record<string, StoredCustomFieldValue>>,
+): Readonly<Record<string, StoredCustomFieldValue>> {
+  const sorted: Record<string, StoredCustomFieldValue> = {}
+  for (const key of Object.keys(values).sort()) {
+    sorted[key] = values[key] as StoredCustomFieldValue
+  }
+  return sorted
+}
+
+function unknownKey(key: string): AppError {
+  return AppError.validationFailed('That custom field is not defined for this record type', [
+    { field: `custom_fields.${key}`, message: 'Unknown field' },
+  ])
+}
+
+function typeError(key: string, message: string): AppError {
+  return AppError.validationFailed('That value does not match the custom field', [
+    { field: `custom_fields.${key}`, message },
+  ])
+}
+
+function validateValue(
+  definition: CustomFieldDefinitionRecord,
+  value: CustomFieldWireValue,
+): StoredCustomFieldValue {
+  switch (definition.type) {
+    case 'text':
+      return validateString(definition.key, value, MAX_TEXT_LENGTH)
+
+    case 'long_text':
+      return validateString(definition.key, value, MAX_LONG_TEXT_LENGTH)
+
+    case 'url':
+      return validateUrl(definition.key, value)
+
+    case 'date':
+      return validateDate(definition.key, value)
+
+    case 'number':
+      return validateNumber(definition.key, value)
+
+    case 'checkbox':
+      if (typeof value !== 'boolean') {
+        throw typeError(definition.key, 'Expected true or false')
+      }
+      return value
+
+    case 'select':
+      return validateSelect(definition, value)
+
+    case 'multi_select':
+      return validateMultiSelect(definition, value)
+
+    case 'currency':
+      return validateCurrency(definition.key, value)
+
+    default:
+      throw new Error(`custom-field type "${definition.type}" has no validator`)
+  }
+}
+
+function validateString(key: string, value: CustomFieldWireValue, max: number): string {
+  if (typeof value !== 'string') {
+    throw typeError(key, 'Expected a string')
+  }
+  if (value.length > max) {
+    throw typeError(key, `At most ${String(max)} characters`)
+  }
+  return value
+}
+
+function validateUrl(key: string, value: CustomFieldWireValue): string {
+  const raw = validateString(key, value, MAX_URL_LENGTH)
+  let parsed: URL
+  try {
+    parsed = new URL(raw)
+  } catch {
+    throw typeError(key, 'Expected an http or https URL')
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw typeError(key, 'Expected an http or https URL')
+  }
+  return raw
+}
+
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u
+
+function validateDate(key: string, value: CustomFieldWireValue): string {
+  if (typeof value !== 'string' || !DATE_PATTERN.test(value)) {
+    throw typeError(key, 'Expected a YYYY-MM-DD date')
+  }
+  const [year, month, day] = value.split('-').map((part) => Number(part))
+  const parsed = new Date(Date.UTC(year!, (month ?? 1) - 1, day ?? 1))
+  if (
+    parsed.getUTCFullYear() !== year ||
+    parsed.getUTCMonth() !== (month ?? 1) - 1 ||
+    parsed.getUTCDate() !== (day ?? 1)
+  ) {
+    throw typeError(key, 'That date does not exist')
+  }
+  return value
+}
+
+function validateNumber(key: string, value: CustomFieldWireValue): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw typeError(key, 'Expected a finite number')
+  }
+  if (Math.abs(value) > Number.MAX_SAFE_INTEGER) {
+    throw typeError(key, 'Number is out of range')
+  }
+  return value
+}
+
+function validateSelect(
+  definition: CustomFieldDefinitionRecord,
+  value: CustomFieldWireValue,
+): string {
+  if (typeof value !== 'string') {
+    throw typeError(definition.key, 'Expected a string')
+  }
+  if (!definition.options.includes(value)) {
+    throw typeError(definition.key, `Not one of the field's options`)
+  }
+  return value
+}
+
+function validateMultiSelect(
+  definition: CustomFieldDefinitionRecord,
+  value: CustomFieldWireValue,
+): readonly string[] {
+  if (!Array.isArray(value)) {
+    throw typeError(definition.key, 'Expected a list of option keys')
+  }
+  if (value.length > MAX_MULTI_SELECT_ENTRIES) {
+    throw typeError(definition.key, `At most ${String(MAX_MULTI_SELECT_ENTRIES)} entries`)
+  }
+  const seen = new Set<string>()
+  for (const entry of value) {
+    if (typeof entry !== 'string') {
+      throw typeError(definition.key, 'Each entry must be a string')
+    }
+    if (!definition.options.includes(entry)) {
+      throw typeError(definition.key, `"${entry}" is not one of the field's options`)
+    }
+    if (seen.has(entry)) {
+      throw typeError(definition.key, `"${entry}" appears more than once`)
+    }
+    seen.add(entry)
+  }
+  // A stored multi_select is a plain array; sort for stable JSON comparison.
+  return [...value].sort()
+}
+
+function validateCurrency(
+  key: string,
+  value: CustomFieldWireValue,
+): { readonly amountCents: number; readonly currency: string } {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    Array.isArray(value) ||
+    !('amount_cents' in value) ||
+    !('currency' in value)
+  ) {
+    throw typeError(key, 'Expected { amount_cents, currency }')
+  }
+  const cents = value.amount_cents
+  if (typeof cents !== 'number' || !Number.isInteger(cents)) {
+    throw typeError(key, 'amount_cents must be a whole number of cents')
+  }
+  const currency = value.currency
+  if (typeof currency !== 'string' || !/^[A-Z]{3}$/u.test(currency)) {
+    throw typeError(key, 'currency must be a 3-letter uppercase code')
+  }
+  return { amountCents: cents, currency }
+}
+
+function sameValue(before: unknown, after: unknown): boolean {
+  return JSON.stringify(before) === JSON.stringify(after)
+}
+
+/** Collects one detail-list from several field-level rejections. Unused today; kept for future bulk validators. */
+export function collectDetails(errors: readonly AppError[]): readonly ErrorDetail[] {
+  return errors.flatMap((error) => error.details ?? [])
+}

package/src/modules/custom-fields/wire.ts

@@ -0,0 +1,32 @@
+/**
+ * Renders the stored `custom_fields` for a record's wire body.
+ *
+ * Every value type serialises as itself with one exception: currency lives in
+ * the store as `{amountCents, currency}` (camelCase, from
+ * `customFieldValuesSchema`'s transform) and goes back over the wire as
+ * `{amount_cents, currency}` per the api.md snake_case rule. Every record
+ * module's response mapper calls this from one place so the two shapes cannot
+ * drift.
+ */
+export function renderCustomFieldsForWire(
+  values: Readonly<Record<string, unknown>>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(values)) {
+    if (
+      typeof value === 'object' &&
+      value !== null &&
+      !Array.isArray(value) &&
+      'amountCents' in value &&
+      'currency' in value
+    ) {
+      out[key] = {
+        amount_cents: (value as { amountCents: number }).amountCents,
+        currency: (value as { currency: string }).currency,
+      }
+    } else {
+      out[key] = value
+    }
+  }
+  return out
+}

package/src/modules/dashboard/repository.ts

@@ -8,6 +8,7 @@ import type { Queryable } from '../../runtime/transaction.ts'
 import { activities } from '../activities/schema.ts'
 import { decisions } from '../decisions/schema.ts'
 import { deals } from '../deals/schema.ts'
+import { enquiries } from '../enquiries/schema.ts'
 import { notes } from '../notes/schema.ts'
 import { opportunities } from '../opportunities/schema.ts'
 import { partnerships } from '../partnerships/schema.ts'
@@ -88,11 +89,11 @@ function pipelineTable(table: PgTable, workspaceId: PgColumn, stageId: PgColumn)
 }
 
 /**
- * Which table each pipeline kind lives in. Partnership is a pipeline like the
- * other three: `pipeline_stages.kind` carries all four, and its board columns
- * are configured the same way.
+ * Which table each pipeline kind lives in. `pipeline_stages.kind` carries all
+ * five, and every pipeline's board columns are configured the same way.
  */
 const PIPELINE_TABLES: Readonly<Record<PipelineKind, PipelineTable>> = {
+  enquiry: pipelineTable(enquiries, enquiries.workspaceId, enquiries.stageId),
   deal: pipelineTable(deals, deals.workspaceId, deals.stageId),
   opportunity: pipelineTable(opportunities, opportunities.workspaceId, opportunities.stageId),
   raise: pipelineTable(raises, raises.workspaceId, raises.stageId),

package/src/modules/deals/index.ts

@@ -1,5 +1,6 @@
 import type { KelpieModule } from '../../runtime/module.ts'
 import { createActivityRecorder } from '../activities/index.ts'
+import { createCustomFieldValues } from '../custom-fields/index.ts'
 import { dealsEvents } from './events.ts'
 import { mountDealsRoutes } from './routes.ts'
 import * as schema from './schema.ts'
@@ -12,12 +13,13 @@ import { registerDealsTools } from './tools.ts'
  * Requires its relations because creating one checks that the company, stage,
  * owner, and people are all in the caller's workspace before linking them, and
  * `activities` because every write leaves its timeline entry in the same
- * transaction.
+ * transaction. Also requires `custom-fields` so the validator is present when
+ * this service constructs.
  */
 export function createDealsModule(migrationsDirectory: string): KelpieModule {
   return {
     id: 'deals',
-    requires: ['companies', 'people', 'pipelines', 'activities'],
+    requires: ['companies', 'people', 'pipelines', 'activities', 'custom-fields'],
     events: dealsEvents,
 
     register(context) {
@@ -30,6 +32,7 @@ export function createDealsModule(migrationsDirectory: string): KelpieModule {
           createId: context.createId,
           now: context.now,
         }),
+        customFields: createCustomFieldValues({ db: context.db }),
       })
 
       context.schema(schema, migrationsDirectory)

package/src/modules/deals/repository.ts

@@ -1,4 +1,4 @@
-import { and, asc, eq, ilike, inArray, or, sql } from 'drizzle-orm'
+import { and, eq, ilike, inArray, or, sql } from 'drizzle-orm'
 import type { SQL } from 'drizzle-orm'
 
 import { keysetCondition, orderByWindow, textSort, timestampSort } from '../../lib/pagination.ts'
@@ -6,9 +6,9 @@ import type { ListWindow, SortableFields } from '../../lib/pagination.ts'
 import { arrayContainsPattern, containsPattern } from '../../lib/search.ts'
 import type { Queryable } from '../../runtime/transaction.ts'
 import { companies } from '../companies/schema.ts'
-import { people } from '../people/schema.ts'
+import { anyPersonLinked } from '../personLinks.ts'
 import { workspaceMembers } from '../workspace/schema.ts'
-import { dealPeople, deals } from './schema.ts'
+import { deals } from './schema.ts'
 
 export type DealRecord = typeof deals.$inferSelect
 
@@ -49,15 +49,6 @@ function companyNameMatches(pattern: string): SQL {
   )`
 }
 
-function hasAnyOfPeople(personIds: readonly string[]): SQL {
-  return sql`exists (
-    select 1
-    from ${dealPeople}
-    where ${dealPeople.dealId} = ${deals.id}
-      and ${inArray(dealPeople.personId, personIds)}
-  )`
-}
-
 function matchesTerm(term: string): SQL | undefined {
   const pattern = containsPattern(term)
 
@@ -76,7 +67,9 @@ function conditionsFor(workspaceId: string, filters: DealFilters): (SQL | undefi
     filters.term === undefined ? undefined : matchesTerm(filters.term),
     filters.companyIds === undefined ? undefined : inArray(deals.companyId, filters.companyIds),
     filters.stageIds === undefined ? undefined : inArray(deals.stageId, filters.stageIds),
-    filters.personIds === undefined ? undefined : hasAnyOfPeople(filters.personIds),
+    filters.personIds === undefined
+      ? undefined
+      : anyPersonLinked('deal', deals.id, deals.workspaceId, filters.personIds),
   ]
 }
 
@@ -143,99 +136,6 @@ export async function deleteDeal(db: Queryable, workspaceId: string, id: string)
   return deleted.length
 }
 
-/** The people on one deal. Ordered by id so a response is stable across reads. */
-export async function listPersonIds(db: Queryable, dealId: string): Promise<string[]> {
-  const rows = await db
-    .select({ personId: dealPeople.personId })
-    .from(dealPeople)
-    .where(eq(dealPeople.dealId, dealId))
-    .orderBy(asc(dealPeople.personId))
-
-  return rows.map((row) => row.personId)
-}
-
-/**
- * The people on each of a page of deals, in one query rather than one per row.
- *
- * @returns Ids missing from the map have no people.
- */
-export async function listPersonIdsFor(
-  db: Queryable,
-  dealIds: readonly string[],
-): Promise<ReadonlyMap<string, readonly string[]>> {
-  if (dealIds.length === 0) {
-    return new Map()
-  }
-
-  const rows = await db
-    .select({ dealId: dealPeople.dealId, personId: dealPeople.personId })
-    .from(dealPeople)
-    .where(inArray(dealPeople.dealId, dealIds))
-    .orderBy(asc(dealPeople.personId))
-
-  const byDeal = new Map<string, string[]>()
-
-  for (const row of rows) {
-    const existing = byDeal.get(row.dealId)
-
-    if (existing === undefined) {
-      byDeal.set(row.dealId, [row.personId])
-    } else {
-      existing.push(row.personId)
-    }
-  }
-
-  return byDeal
-}
-
-export async function insertDealPeople(
-  db: Queryable,
-  dealId: string,
-  personIds: readonly string[],
-): Promise<void> {
-  if (personIds.length === 0) {
-    return
-  }
-
-  await db.insert(dealPeople).values(personIds.map((personId) => ({ dealId, personId })))
-}
-
-export async function deleteDealPeople(
-  db: Queryable,
-  dealId: string,
-  personIds: readonly string[],
-): Promise<void> {
-  if (personIds.length === 0) {
-    return
-  }
-
-  await db
-    .delete(dealPeople)
-    .where(and(eq(dealPeople.dealId, dealId), inArray(dealPeople.personId, personIds)))
-}
-
-/**
- * The names of these people in this workspace, keyed by id. An id missing from
- * the map does not exist here, which is how `person_ids` is validated. Reads the
- * `people` *table*, per the cross-relation rule in `architecture.md`.
- */
-export async function findPeopleNamed(
-  db: Queryable,
-  workspaceId: string,
-  personIds: readonly string[],
-): Promise<ReadonlyMap<string, string>> {
-  if (personIds.length === 0) {
-    return new Map()
-  }
-
-  const rows = await db
-    .select({ id: people.id, name: people.name })
-    .from(people)
-    .where(and(eq(people.workspaceId, workspaceId), inArray(people.id, personIds)))
-
-  return new Map(rows.map((row) => [row.id, row.name]))
-}
-
 /** Whether a member belongs to this workspace, for validating `owner_id`. */
 export async function memberExists(
   db: Queryable,

package/src/modules/deals/routes.ts

@@ -1,3 +1,4 @@
+import { customFieldsPatchShape } from '@kelpie/schemas'
 import type { Context, Hono } from 'hono'
 import { z } from 'zod'
 
@@ -6,6 +7,7 @@ import { pageBody, readIdFilter, readJsonBody, readListParameters } from '../../
 import type { Actor } from '../auth/actor.ts'
 import { resolveActorFrom } from '../auth/credentials.ts'
 import type { CredentialDependencies } from '../auth/credentials.ts'
+import { renderCustomFieldsForWire } from '../custom-fields/wire.ts'
 import type { CreateDealInput, DealView, DealsService, UpdateDealInput } from './service.ts'
 
 /** Wire shapes for `/v1/deals`. Bodies are strict; an unknown field is a 422, per `api.md`. */
@@ -26,6 +28,7 @@ const dealShape = {
   summary: z.string(),
   tags: z.array(z.string().min(1)),
   external_id: z.string().min(1).nullable(),
+  custom_fields: customFieldsPatchShape,
 }
 
 /**
@@ -48,6 +51,7 @@ export const createBody = z.strictObject({
   summary: dealShape.summary.default(''),
   tags: dealShape.tags.default([]),
   external_id: dealShape.external_id.default(null),
+  custom_fields: dealShape.custom_fields.default({}),
 })
 
 export const updateBody = z.strictObject(dealShape).partial()
@@ -72,6 +76,7 @@ export function toCreateInput(body: z.infer<typeof createBody>): CreateDealInput
     summary: body.summary,
     tags: body.tags,
     externalId: body.external_id,
+    customFields: body.custom_fields,
   }
 }
 
@@ -91,6 +96,7 @@ export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateDealInput
     ...(body.summary === undefined ? {} : { summary: body.summary }),
     ...(body.tags === undefined ? {} : { tags: body.tags }),
     ...(body.external_id === undefined ? {} : { externalId: body.external_id }),
+    ...(body.custom_fields === undefined ? {} : { customFields: body.custom_fields }),
   }
 }
 
@@ -111,6 +117,7 @@ export function dealResponse(deal: DealView): Record<string, unknown> {
     summary: deal.summary,
     tags: deal.tags,
     external_id: deal.externalId,
+    custom_fields: renderCustomFieldsForWire(deal.customFields),
     created_at: deal.createdAt.toISOString(),
     updated_at: deal.updatedAt.toISOString(),
   }

package/src/modules/deals/schema.ts

@@ -1,9 +1,9 @@
-import { bigint, date, index, pgTable, primaryKey, text } from 'drizzle-orm/pg-core'
+import type { CustomFieldValue } from '@kelpie/schemas'
+import { bigint, date, index, jsonb, pgTable, text } from 'drizzle-orm/pg-core'
 
 import { createdAt, primaryId, searchVector, updatedAt } from '../../lib/columns.ts'
 import type { SearchVectorPart } from '../../lib/columns.ts'
 import { companies } from '../companies/schema.ts'
-import { people } from '../people/schema.ts'
 import { pipelineStages } from '../pipelines/schema.ts'
 import { workspaceMembers, workspaces } from '../workspace/schema.ts'
 
@@ -38,6 +38,11 @@ export const deals = pgTable(
     summary: text('summary').notNull().default(''),
     tags: text('tags').array().notNull().default([]),
     externalId: text('external_id'),
+    // Workspace-defined fields, keyed by definition key. See people/schema.ts.
+    customFields: jsonb('custom_fields')
+      .$type<Readonly<Record<string, CustomFieldValue>>>()
+      .notNull()
+      .default({}),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
     searchVector: searchVector((): readonly SearchVectorPart[] => [
@@ -57,16 +62,3 @@ export const deals = pgTable(
   ],
 )
 
-/** People attached to a deal. Restrict on person: a deal contact cannot vanish. */
-export const dealPeople = pgTable(
-  'deal_people',
-  {
-    dealId: text('deal_id')
-      .notNull()
-      .references(() => deals.id, { onDelete: 'cascade' }),
-    personId: text('person_id')
-      .notNull()
-      .references(() => people.id, { onDelete: 'restrict' }),
-  },
-  (table) => [primaryKey({ columns: [table.dealId, table.personId] })],
-)