@kelpie/server 0.7.0 → 0.9.0

package/src/modules/import-export/writes.ts

@@ -7,11 +7,14 @@ import type { ActivityRecorder } from '../activities/recorder.ts'
 import { describeCreationVia, describeLink, describeUpdateVia } from '../activities/wording.ts'
 import type { Actor } from '../auth/actor.ts'
 import * as companyRepository from '../companies/repository.ts'
+import * as consentPurposesRepository from '../consent-purposes/repository.ts'
 import * as dealRepository from '../deals/repository.ts'
 import * as peopleRepository from '../people/repository.ts'
+import { upsertPersonConsent } from '../people/personConsentWrites.ts'
+import * as personLinks from '../personLinks.ts'
 import * as positionRepository from '../positions/repository.ts'
 import { IMPORT_DEAL_CURRENCY, NEW_COMPANY_DEFAULTS, NEW_PERSON_DEFAULTS } from './drafts.ts'
-import type { ImportWrite, PlannedAffiliation, RowPlan } from './plan.ts'
+import type { ImportConsentGrant, ImportWrite, PlannedAffiliation, RowPlan } from './plan.ts'
 
 /**
  * Applying one planned row: the insert or update, and the timeline entry that
@@ -220,6 +223,9 @@ async function writePerson(
       tags: write.draft.tags === undefined ? undefined : [...write.draft.tags],
       id: dependencies.createId('person'),
       workspaceId,
+      // `name` is not a required column any more; the People row check is what
+      // guarantees one, from the row's own `name` or composed from its first and
+      // last name cells. A row reaching here without one never passed validation.
       name: write.draft.name ?? '',
     })
 
@@ -228,6 +234,10 @@ async function writePerson(
         ? []
         : await applyAffiliation(dependencies, created.id, write.affiliation)
 
+    if (write.consent !== undefined) {
+      await applyImportConsent(dependencies, created.id, write.consent)
+    }
+
     return { recordId: created.id, objectType: 'person', changedFields: [], sideRecords }
   }
 
@@ -257,9 +267,51 @@ async function writePerson(
       ? []
       : await applyAffiliation(dependencies, id, write.affiliation)
 
+  if (write.consent !== undefined) {
+    await applyImportConsent(dependencies, id, write.consent)
+  }
+
   return { recordId: id, objectType: 'person', changedFields, sideRecords }
 }
 
+/**
+ * Applies the row's consent grant against the job's purpose. The purpose is
+ * looked up once per call rather than cached across rows — a commit runs one
+ * transaction and one row at a time — so the round trip is small and stays
+ * consistent with the current transaction's view.
+ */
+async function applyImportConsent(
+  dependencies: WriteDependencies,
+  personId: string,
+  consent: ImportConsentGrant,
+): Promise<void> {
+  const [purpose] = await consentPurposesRepository.listPurposesByIds(
+    dependencies.tx,
+    dependencies.workspaceId,
+    [consent.purposeId],
+  )
+  if (purpose === undefined) return
+  const notedAt = consent.notedAt === null ? dependencies.now : new Date(`${consent.notedAt}T00:00:00Z`)
+  await upsertPersonConsent(
+    dependencies.tx,
+    dependencies.workspaceId,
+    personId,
+    consent.purposeId,
+    purpose.slug,
+    purpose.label,
+    consent.status,
+    'import',
+    notedAt,
+  )
+  await dependencies.recordActivity(dependencies.tx, dependencies.workspaceId, dependencies.actor, {
+    targetType: 'person',
+    targetId: personId,
+    kind: 'updated',
+    action: `${consent.status === 'granted' ? 'granted' : 'withdrew'} ${purpose.label} consent via ${dependencies.sourceName}`,
+    detail: null,
+  })
+}
+
 /**
  * A Position's only writable field is its title, so an update is a rename.
  *
@@ -318,12 +370,19 @@ async function reconcileDealPeople(
   dealId: string,
   personIds: readonly string[],
 ): Promise<boolean> {
-  const current = await dealRepository.listPersonIds(dependencies.tx, dealId)
+  const target = { targetType: 'deal' as const, targetId: dealId }
+  const current = await personLinks.listPersonIds(dependencies.tx, dependencies.workspaceId, target)
   const added = personIds.filter((personId) => !current.includes(personId))
   const removed = current.filter((personId) => !personIds.includes(personId))
 
-  await dealRepository.insertDealPeople(dependencies.tx, dealId, added)
-  await dealRepository.deleteDealPeople(dependencies.tx, dealId, removed)
+  await personLinks.linkPeople(
+    dependencies.tx,
+    dependencies.createId,
+    dependencies.workspaceId,
+    target,
+    added,
+  )
+  await personLinks.unlinkPeople(dependencies.tx, dependencies.workspaceId, target, removed)
 
   return added.length > 0 || removed.length > 0
 }
@@ -352,7 +411,13 @@ async function writeDeal(
       // the same way, and no CSV column carries one.
       currency: IMPORT_DEAL_CURRENCY,
     })
-    await dealRepository.insertDealPeople(tx, id, write.personIds)
+    await personLinks.linkPeople(
+      tx,
+      dependencies.createId,
+      workspaceId,
+      { targetType: 'deal', targetId: id },
+      write.personIds,
+    )
 
     return { recordId: id, objectType: 'deal', changedFields: [] }
   }

package/src/modules/lists/events.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod'
+
+import type { ModuleEventCatalog } from '../../runtime/module.ts'
+
+/**
+ * Domain events published by the lists module.
+ *
+ * `target` on a `lists.list.*` event is the list itself. `lists.member.*` events
+ * name the record that changed membership, so a consumer watching records hears
+ * about a list touching it without a second lookup.
+ */
+
+export const listsEvents = {
+  'lists.list.created': z.object({}).strict(),
+  'lists.list.updated': z.object({ changed: z.array(z.string()).readonly() }),
+  'lists.list.deleted': z.object({}).strict(),
+  'lists.member.added': z.object({ listId: z.string() }),
+  'lists.member.removed': z.object({ listId: z.string() }),
+} satisfies ModuleEventCatalog
+
+export type ListCreatedData = Record<string, never>
+export interface ListUpdatedData {
+  readonly changed: readonly string[]
+}
+export type ListDeletedData = Record<string, never>
+export interface ListMemberAddedData {
+  readonly listId: string
+}
+export interface ListMemberRemovedData {
+  readonly listId: string
+}
+
+declare module '../../runtime/events.ts' {
+  interface KelpieEventMap {
+    'lists.list.created': ListCreatedData
+    'lists.list.updated': ListUpdatedData
+    'lists.list.deleted': ListDeletedData
+    'lists.member.added': ListMemberAddedData
+    'lists.member.removed': ListMemberRemovedData
+  }
+}

package/src/modules/lists/index.ts

@@ -0,0 +1,41 @@
+import type { KelpieModule } from '../../runtime/module.ts'
+import { listsEvents } from './events.ts'
+import { mountListsRoutes } from './routes.ts'
+import * as schema from './schema.ts'
+import { createListsService } from './service.ts'
+import { registerListsTools } from './tools.ts'
+
+/**
+ * Lists: named collections of records of one type.
+ *
+ * Requires `workspace` for the tenancy column. Every other record type is
+ * addressed polymorphically through `target_type` + `target_id`, so this module
+ * does not depend on the modules whose records it references.
+ */
+export function createListsModule(migrationsDirectory: string): KelpieModule {
+  return {
+    id: 'lists',
+    requires: ['workspace'],
+    structural: true,
+    events: listsEvents,
+
+    register(context) {
+      const service = createListsService({
+        db: context.db,
+        transaction: context.transaction,
+        createId: context.createId,
+        now: context.now,
+      })
+
+      context.schema(schema, migrationsDirectory)
+
+      context.routes((router) => {
+        mountListsRoutes(router, { db: context.db, now: context.now, service })
+      })
+
+      registerListsTools(context.mcp, service)
+
+      return Promise.resolve()
+    },
+  }
+}

package/src/modules/lists/repository.ts

@@ -0,0 +1,343 @@
+import { and, eq, ilike, inArray, sql } from 'drizzle-orm'
+import type { SQL } from 'drizzle-orm'
+
+import { keysetCondition, orderByWindow, textSort, timestampSort } from '../../lib/pagination.ts'
+import type { ListWindow, SortableFields } from '../../lib/pagination.ts'
+import { containsPattern } from '../../lib/search.ts'
+import type { Queryable } from '../../runtime/transaction.ts'
+import type { RecordTargetType } from '../recordTargets.ts'
+import { listMembers, lists } from './schema.ts'
+
+export type ListRecord = typeof lists.$inferSelect
+export type ListColumns = typeof lists.$inferInsert
+
+export type ListMemberRecord = typeof listMembers.$inferSelect
+export type ListMemberColumns = typeof listMembers.$inferInsert
+
+/**
+ * The stored row with the rollup a UI index page needs. `member_count` is
+ * computed at read time rather than maintained on write so an unrelated bug
+ * cannot leave the count out of step with the actual rows.
+ */
+export type ListWithCount = ListRecord & { readonly memberCount: number }
+
+export const LIST_SORTS: SortableFields<ListWithCount> = {
+  name: textSort(lists.name, (list) => list.name),
+  created_at: timestampSort(lists.createdAt, (list) => list.createdAt),
+  updated_at: timestampSort(lists.updatedAt, (list) => list.updatedAt),
+}
+
+export const DEFAULT_LIST_SORT = '-updated_at'
+
+export interface ListFilters {
+  readonly term?: string | undefined
+  readonly targetType?: RecordTargetType | undefined
+}
+
+function conditionsFor(workspaceId: string, filters: ListFilters): (SQL | undefined)[] {
+  const term = filters.term
+  const targetType = filters.targetType
+
+  return [
+    eq(lists.workspaceId, workspaceId),
+    term === undefined ? undefined : ilike(lists.name, containsPattern(term)),
+    targetType === undefined ? undefined : eq(lists.targetType, targetType),
+  ]
+}
+
+/**
+ * @returns Up to `window.fetchLimit` rows: one more than the page, so the
+ *   caller can tell there is a next one. Each row carries the count of members
+ *   attached to it.
+ */
+export async function listLists(
+  db: Queryable,
+  workspaceId: string,
+  filters: ListFilters,
+  window: ListWindow<ListWithCount>,
+): Promise<ListWithCount[]> {
+  const rows = await db
+    .select()
+    .from(lists)
+    .where(and(...conditionsFor(workspaceId, filters), keysetCondition(window, lists.id)))
+    .orderBy(...orderByWindow(window, lists.id))
+    .limit(window.fetchLimit)
+
+  const counts = await countMembersFor(db, rows.map((row) => row.id))
+
+  return rows.map((row) => ({ ...row, memberCount: counts.get(row.id) ?? 0 }))
+}
+
+async function countMembersFor(
+  db: Queryable,
+  listIds: readonly string[],
+): Promise<ReadonlyMap<string, number>> {
+  if (listIds.length === 0) {
+    return new Map()
+  }
+
+  const rows = await db
+    .select({ listId: listMembers.listId, count: sql<number>`count(*)::int` })
+    .from(listMembers)
+    .where(inArray(listMembers.listId, [...listIds]))
+    .groupBy(listMembers.listId)
+
+  return new Map(rows.map((row) => [row.listId, Number(row.count)]))
+}
+
+export async function findList(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+): Promise<ListWithCount | undefined> {
+  const [found] = await db
+    .select()
+    .from(lists)
+    .where(and(eq(lists.workspaceId, workspaceId), eq(lists.id, id)))
+    .limit(1)
+
+  if (found === undefined) {
+    return undefined
+  }
+
+  return { ...found, memberCount: await countMembers(db, id) }
+}
+
+/**
+ * Bare list rows for a bulk existence + target-type check, without the
+ * member-count round trip `findList` pays for. Used by the forms service to
+ * validate `list_ids` at write time in one query rather than N.
+ */
+export interface ListIdRow {
+  readonly id: string
+  readonly targetType: string
+  readonly consentPurposeId: string | null
+}
+
+export async function listListsById(
+  db: Queryable,
+  workspaceId: string,
+  ids: readonly string[],
+): Promise<ListIdRow[]> {
+  if (ids.length === 0) {
+    return []
+  }
+
+  return db
+    .select({
+      id: lists.id,
+      targetType: lists.targetType,
+      consentPurposeId: lists.consentPurposeId,
+    })
+    .from(lists)
+    .where(and(eq(lists.workspaceId, workspaceId), inArray(lists.id, ids)))
+}
+
+async function countMembers(db: Queryable, listId: string): Promise<number> {
+  const [row] = await db
+    .select({ count: sql<number>`count(*)::int` })
+    .from(listMembers)
+    .where(eq(listMembers.listId, listId))
+
+  return Number(row?.count ?? 0)
+}
+
+export async function insertList(db: Queryable, values: ListColumns): Promise<ListRecord> {
+  const [created] = await db.insert(lists).values(values).returning()
+
+  if (created === undefined) {
+    throw new Error(`Inserting list ${values.id} returned no row`)
+  }
+
+  return created
+}
+
+export async function updateList(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+  changes: Partial<ListColumns>,
+): Promise<ListRecord | undefined> {
+  const [updated] = await db
+    .update(lists)
+    .set(changes)
+    .where(and(eq(lists.workspaceId, workspaceId), eq(lists.id, id)))
+    .returning()
+
+  return updated
+}
+
+export async function deleteList(db: Queryable, workspaceId: string, id: string): Promise<number> {
+  const deleted = await db
+    .delete(lists)
+    .where(and(eq(lists.workspaceId, workspaceId), eq(lists.id, id)))
+    .returning({ id: lists.id })
+
+  return deleted.length
+}
+
+/** Members: no cursor pagination yet. A list's members render on one page today. */
+
+export const LIST_MEMBER_SORTS: SortableFields<ListMemberRecord> = {
+  added_at: timestampSort(listMembers.addedAt, (row) => row.addedAt),
+}
+
+export const DEFAULT_LIST_MEMBER_SORT = '-added_at'
+
+export interface ListMemberFilters {
+  readonly listId: string
+  readonly targetType?: RecordTargetType | undefined
+}
+
+function memberConditionsFor(
+  workspaceId: string,
+  filters: ListMemberFilters,
+): (SQL | undefined)[] {
+  const targetType = filters.targetType
+
+  return [
+    eq(listMembers.workspaceId, workspaceId),
+    eq(listMembers.listId, filters.listId),
+    targetType === undefined ? undefined : eq(listMembers.targetType, targetType),
+  ]
+}
+
+export function listListMembers(
+  db: Queryable,
+  workspaceId: string,
+  filters: ListMemberFilters,
+  window: ListWindow<ListMemberRecord>,
+): Promise<ListMemberRecord[]> {
+  return db
+    .select()
+    .from(listMembers)
+    .where(and(...memberConditionsFor(workspaceId, filters), keysetCondition(window, listMembers.id)))
+    .orderBy(...orderByWindow(window, listMembers.id))
+    .limit(window.fetchLimit)
+}
+
+export async function findListMember(
+  db: Queryable,
+  workspaceId: string,
+  listId: string,
+  id: string,
+): Promise<ListMemberRecord | undefined> {
+  const [found] = await db
+    .select()
+    .from(listMembers)
+    .where(
+      and(
+        eq(listMembers.workspaceId, workspaceId),
+        eq(listMembers.listId, listId),
+        eq(listMembers.id, id),
+      ),
+    )
+    .limit(1)
+
+  return found
+}
+
+export async function insertListMember(
+  db: Queryable,
+  values: ListMemberColumns,
+): Promise<ListMemberRecord> {
+  const [created] = await db.insert(listMembers).values(values).returning()
+
+  if (created === undefined) {
+    throw new Error(`Inserting list_member ${values.id} returned no row`)
+  }
+
+  return created
+}
+
+export async function deleteListMember(
+  db: Queryable,
+  workspaceId: string,
+  listId: string,
+  id: string,
+): Promise<number> {
+  const deleted = await db
+    .delete(listMembers)
+    .where(
+      and(
+        eq(listMembers.workspaceId, workspaceId),
+        eq(listMembers.listId, listId),
+        eq(listMembers.id, id),
+      ),
+    )
+    .returning({ id: listMembers.id })
+
+  return deleted.length
+}
+
+/** A membership row enriched with the list it points at. */
+export interface MembershipWithList {
+  readonly id: string
+  readonly listId: string
+  readonly listName: string
+  readonly listTargetType: string
+  readonly targetType: string
+  readonly targetId: string
+  readonly addedAt: Date
+}
+
+/**
+ * "Which lists is this record on?"
+ *
+ * Ordered by list name so a record's Lists tab reads alphabetically and the
+ * order does not shift as memberships are added.
+ */
+export async function listMembershipsForTarget(
+  db: Queryable,
+  workspaceId: string,
+  targetType: string,
+  targetId: string,
+): Promise<MembershipWithList[]> {
+  return db
+    .select({
+      id: listMembers.id,
+      listId: listMembers.listId,
+      listName: lists.name,
+      listTargetType: lists.targetType,
+      targetType: listMembers.targetType,
+      targetId: listMembers.targetId,
+      addedAt: listMembers.addedAt,
+    })
+    .from(listMembers)
+    .innerJoin(lists, eq(listMembers.listId, lists.id))
+    .where(
+      and(
+        eq(listMembers.workspaceId, workspaceId),
+        eq(listMembers.targetType, targetType),
+        eq(listMembers.targetId, targetId),
+      ),
+    )
+    .orderBy(lists.name)
+}
+
+/**
+ * Removes every list membership for one target.
+ *
+ * The target is polymorphic and carries no foreign key of its own, so nothing
+ * in the database deletes these when the target goes. The service that deletes
+ * the target calls this inside the same transaction.
+ */
+export async function deleteMembershipsForTarget(
+  db: Queryable,
+  workspaceId: string,
+  targetType: string,
+  targetId: string,
+): Promise<number> {
+  const deleted = await db
+    .delete(listMembers)
+    .where(
+      and(
+        eq(listMembers.workspaceId, workspaceId),
+        eq(listMembers.targetType, targetType),
+        eq(listMembers.targetId, targetId),
+      ),
+    )
+    .returning({ id: listMembers.id })
+
+  return deleted.length
+}