@kelpie/server 0.7.0 → 0.9.0

package/src/modules/opportunities/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 {
   CreateOpportunityInput,
   OpportunitiesService,
@@ -23,8 +25,10 @@ const opportunityShape = {
   company_id: z.string().min(1).nullable(),
   owner_id: z.string().min(1).nullable(),
   expected_close: isoDateSchema.nullable(),
+  person_ids: z.array(z.string().min(1)),
   summary: z.string(),
   tags: z.array(z.string().min(1)),
+  custom_fields: customFieldsPatchShape,
 }
 
 /**
@@ -41,8 +45,10 @@ export const createBody = z.strictObject({
   company_id: opportunityShape.company_id.default(null),
   owner_id: opportunityShape.owner_id.optional(),
   expected_close: opportunityShape.expected_close.default(null),
+  person_ids: opportunityShape.person_ids.default([]),
   summary: opportunityShape.summary.default(''),
   tags: opportunityShape.tags.default([]),
+  custom_fields: opportunityShape.custom_fields.default({}),
 })
 
 export const updateBody = z.strictObject(opportunityShape).partial()
@@ -59,8 +65,10 @@ export function toCreateInput(body: z.infer<typeof createBody>): CreateOpportuni
     companyId: body.company_id,
     ownerId: body.owner_id,
     expectedClose: body.expected_close,
+    personIds: body.person_ids,
     summary: body.summary,
     tags: body.tags,
+    customFields: body.custom_fields,
   }
 }
 
@@ -72,8 +80,10 @@ export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateOpportuni
     ...(body.company_id === undefined ? {} : { companyId: body.company_id }),
     ...(body.owner_id === undefined ? {} : { ownerId: body.owner_id }),
     ...(body.expected_close === undefined ? {} : { expectedClose: body.expected_close }),
+    ...(body.person_ids === undefined ? {} : { personIds: body.person_ids }),
     ...(body.summary === undefined ? {} : { summary: body.summary }),
     ...(body.tags === undefined ? {} : { tags: body.tags }),
+    ...(body.custom_fields === undefined ? {} : { customFields: body.custom_fields }),
   }
 }
 
@@ -86,8 +96,10 @@ export function opportunityResponse(opportunity: OpportunityView): Record<string
     company_id: opportunity.companyId,
     owner_id: opportunity.ownerId,
     expected_close: opportunity.expectedClose,
+    person_ids: opportunity.personIds,
     summary: opportunity.summary,
     tags: opportunity.tags,
+    custom_fields: renderCustomFieldsForWire(opportunity.customFields),
     created_at: opportunity.createdAt.toISOString(),
     updated_at: opportunity.updatedAt.toISOString(),
   }
@@ -107,6 +119,7 @@ export function mountOpportunitiesRoutes(
         kinds: readIdFilter(context, 'kind'),
         companyIds: readIdFilter(context, 'company_id'),
         stageIds: readIdFilter(context, 'stage_id'),
+        personIds: readIdFilter(context, 'person_id'),
       },
       readListParameters(context),
     )

package/src/modules/opportunities/schema.ts

@@ -1,4 +1,5 @@
-import { date, index, pgTable, text } from 'drizzle-orm/pg-core'
+import type { CustomFieldValue } from '@kelpie/schemas'
+import { 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'
@@ -30,6 +31,11 @@ export const opportunities = pgTable(
     expectedClose: date('expected_close'),
     summary: text('summary').notNull().default(''),
     tags: text('tags').array().notNull().default([]),
+    // 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[] => [

package/src/modules/opportunities/service.ts

@@ -1,3 +1,5 @@
+import type { CustomFieldWireValue } from '@kelpie/schemas'
+
 import { changedKeys } from '../../lib/changes.ts'
 import type { Database } from '../../lib/database.ts'
 import { AppError } from '../../lib/errors.ts'
@@ -6,7 +8,13 @@ import { readListWindow, toPage } from '../../lib/pagination.ts'
 import type { ListQueryParameters, Page } from '../../lib/pagination.ts'
 import type { TransactionScope } from '../../runtime/transaction.ts'
 import type { ActivityRecorder } from '../activities/recorder.ts'
-import { describeCreation, describeStageChange, describeUpdate } from '../activities/wording.ts'
+import {
+  describeCreation,
+  describeLink,
+  describeStageChange,
+  describeUnlink,
+  describeUpdate,
+} from '../activities/wording.ts'
 import type { FieldLabels } from '../activities/wording.ts'
 import { toEventActor } from '../../lib/actor.ts'
 import type { Actor } from '../auth/actor.ts'
@@ -14,6 +22,8 @@ import { actorMemberId, requireWorkspaceId } from '../auth/actor.ts'
 import './events.ts'
 import { deleteRecordsAttachedTo } from '../attachedRecords.ts'
 import * as companyRepository from '../companies/repository.ts'
+import type { CustomFieldValuesValidator } from '../custom-fields/values.ts'
+import * as personLinks from '../personLinks.ts'
 import * as pipelineRepository from '../pipelines/repository.ts'
 import type { PipelineStageRecord } from '../pipelines/repository.ts'
 import * as repository from './repository.ts'
@@ -22,7 +32,9 @@ import type { OpportunityFilters, OpportunityRecord } from './repository.ts'
 
 /**
  * Opportunities: the non-sales pipeline. Grants, accelerators, tenders, press,
- * speaking — same stage mechanics as Deals, different lens, and no people links.
+ * speaking — same stage mechanics as Deals, different lens. People attach
+ * through `person_links` and appear as `person_ids` on the wire, the same
+ * shape deals/partnerships/raises use.
  *
  * A stage move is an ordinary PATCH of `stage_id`, and it is the one change that
  * files a `stage_changed` activity and a `stage.changed` event instead of the
@@ -35,6 +47,7 @@ export interface OpportunitiesDependencies {
   readonly createId: IdFactory
   readonly now: () => Date
   readonly recordActivity: ActivityRecorder
+  readonly customFields: CustomFieldValuesValidator
 }
 
 /** What a changed column is called on a timeline. The mockup says "Target date", not "Expected close". */
@@ -48,8 +61,10 @@ const OPPORTUNITY_FIELD_LABELS: FieldLabels = {
   tags: 'Tags',
 }
 
-/** An opportunity as the API returns one: the stored row minus tenancy. */
-export type OpportunityView = Omit<OpportunityRecord, 'workspaceId'>
+/** An opportunity as the API returns one: the stored row minus tenancy, plus its people. */
+export type OpportunityView = Omit<OpportunityRecord, 'workspaceId'> & {
+  readonly personIds: readonly string[]
+}
 
 export interface CreateOpportunityInput {
   readonly name: string
@@ -64,8 +79,11 @@ export interface CreateOpportunityInput {
   /** Absent means the caller: the member creating an opportunity starts as its owner. */
   readonly ownerId: string | null | undefined
   readonly expectedClose: string | null
+  readonly personIds: readonly string[]
   readonly summary: string
   readonly tags: readonly string[]
+  /** Wire shape for a create body: `null` values are ignored, non-null are validated. */
+  readonly customFields: Readonly<Record<string, CustomFieldWireValue | null>> | undefined
 }
 
 /** PATCH semantics: an absent field is left alone, and null clears a nullable one. */
@@ -76,8 +94,15 @@ export interface UpdateOpportunityInput {
   readonly companyId?: string | null | undefined
   readonly ownerId?: string | null | undefined
   readonly expectedClose?: string | null | undefined
+  /** Replaces the set. The service works out who was added and who left. */
+  readonly personIds?: readonly string[] | undefined
   readonly summary?: string | undefined
   readonly tags?: readonly string[] | undefined
+  /**
+   * Partial merge patch (wire shape): sent keys change, `null` clears a key,
+   * absent keys are left alone. Unknown keys are `422`.
+   */
+  readonly customFields?: Readonly<Record<string, CustomFieldWireValue | null>> | undefined
 }
 
 export interface OpportunitiesService {
@@ -92,10 +117,10 @@ export interface OpportunitiesService {
   remove(actor: Actor, id: string): Promise<void>
 }
 
-function toView(record: OpportunityRecord): OpportunityView {
+function toView(record: OpportunityRecord, personIds: readonly string[]): OpportunityView {
   const { workspaceId: _workspaceId, ...view } = record
 
-  return view
+  return { ...view, personIds }
 }
 
 function toStoredColumns(input: UpdateOpportunityInput): Partial<repository.OpportunityColumns> {
@@ -182,6 +207,40 @@ export function createOpportunitiesService(
     }
   }
 
+  /** @returns Each person's name, for the link activities. Any id missing here is a 404. */
+  async function requirePeople(
+    workspaceId: string,
+    personIds: readonly string[],
+  ): Promise<ReadonlyMap<string, string>> {
+    const named = await personLinks.findPeopleNamed(dependencies.db, workspaceId, personIds)
+    const missing = personIds.filter((id) => !named.has(id))
+
+    if (missing.length > 0) {
+      throw new AppError(
+        'not_found',
+        'Person not found',
+        missing.map((id) => ({ field: 'person_ids', message: `No person ${id} here` })),
+      )
+    }
+
+    return named
+  }
+
+  /** @returns The page's views, with every opportunity's people fetched in one query. */
+  async function toViews(
+    workspaceId: string,
+    records: readonly OpportunityRecord[],
+  ): Promise<OpportunityView[]> {
+    const peopleByOpportunity = await personLinks.listPersonIdsFor(
+      dependencies.db,
+      workspaceId,
+      'opportunity',
+      records.map((record) => record.id),
+    )
+
+    return records.map((record) => toView(record, peopleByOpportunity.get(record.id) ?? []))
+  }
+
   return {
     async list(actor, filters, query) {
       const workspaceId = requireWorkspaceId(actor)
@@ -189,13 +248,20 @@ export function createOpportunitiesService(
       const rows = await repository.listOpportunities(dependencies.db, workspaceId, filters, window)
       const page = toPage(rows, window, (opportunity) => opportunity.id)
 
-      return { items: page.items.map(toView), nextCursor: page.nextCursor }
+      return { items: await toViews(workspaceId, page.items), nextCursor: page.nextCursor }
     },
 
     async get(actor, id) {
       const workspaceId = requireWorkspaceId(actor)
+      const opportunity = await require(workspaceId, id)
 
-      return toView(await require(workspaceId, id))
+      return toView(
+        opportunity,
+        await personLinks.listPersonIds(dependencies.db, workspaceId, {
+          targetType: 'opportunity',
+          targetId: id,
+        }),
+      )
     },
 
     async create(actor, input) {
@@ -215,9 +281,17 @@ export function createOpportunitiesService(
         await requireOwner(workspaceId, ownerId)
       }
 
+      const personIds = [...new Set(input.personIds)]
+      const named = await requirePeople(workspaceId, personIds)
       const id = dependencies.createId('opportunity')
 
       return dependencies.transaction(async ({ tx, events }) => {
+        const customFields = await dependencies.customFields.forCreate(
+          tx,
+          workspaceId,
+          'opportunity',
+          input.customFields,
+        )
         const created = await repository.insertOpportunity(tx, {
           id,
           workspaceId,
@@ -229,8 +303,17 @@ export function createOpportunitiesService(
           expectedClose: input.expectedClose,
           summary: input.summary,
           tags: [...input.tags],
+          customFields,
         })
 
+        await personLinks.linkPeople(
+          tx,
+          dependencies.createId,
+          workspaceId,
+          { targetType: 'opportunity', targetId: id },
+          personIds,
+        )
+
         await dependencies.recordActivity(tx, workspaceId, actor, {
           targetType: 'opportunity',
           targetId: id,
@@ -238,9 +321,19 @@ export function createOpportunitiesService(
           ...describeCreation('Opportunity'),
         })
 
+        // One row per person, so the timeline names who was on it from day one.
+        for (const personId of personIds) {
+          await dependencies.recordActivity(tx, workspaceId, actor, {
+            targetType: 'opportunity',
+            targetId: id,
+            kind: 'linked',
+            ...describeLink('person', named.get(personId) ?? personId),
+          })
+        }
+
         events.emit('opportunities.opportunity.created', { type: 'opportunity', id }, {})
 
-        return toView(created)
+        return toView(created, personIds)
       }, { workspaceId, actor: toEventActor(actor) })
     },
 
@@ -267,16 +360,43 @@ export function createOpportunitiesService(
         await requireOwner(workspaceId, changes.ownerId)
       }
 
-      const columns = toStoredColumns(changes)
-      const changed = changedKeys(existing, columns)
+      const currentPeople = await personLinks.listPersonIds(dependencies.db, workspaceId, {
+        targetType: 'opportunity',
+        targetId: id,
+      })
+      const nextPeople =
+        changes.personIds === undefined ? undefined : [...new Set(changes.personIds)]
+      const added =
+        nextPeople === undefined
+          ? []
+          : nextPeople.filter((personId) => !currentPeople.includes(personId))
+      const removed =
+        nextPeople === undefined
+          ? []
+          : currentPeople.filter((personId) => !nextPeople.includes(personId))
+      const named = await requirePeople(workspaceId, [...added, ...removed])
 
-      if (changed.length === 0) {
-        return toView(existing)
-      }
+      const columns = toStoredColumns(changes)
+      const scalarChanged = changedKeys(existing, columns)
+      const linksChanged = added.length > 0 || removed.length > 0
 
       return dependencies.transaction(async ({ tx, events }) => {
+        const cf = await dependencies.customFields.forUpdate(
+          tx,
+          workspaceId,
+          'opportunity',
+          existing.customFields,
+          changes.customFields,
+        )
+        const customFieldsChanged = cf !== undefined && cf.changedPaths.length > 0
+
+        if (scalarChanged.length === 0 && !linksChanged && !customFieldsChanged) {
+          return toView(existing, currentPeople)
+        }
+
         const updated = await repository.updateOpportunity(tx, workspaceId, id, {
           ...columns,
+          ...(customFieldsChanged ? { customFields: cf.merged } : {}),
           updatedAt: dependencies.now(),
         })
 
@@ -284,6 +404,20 @@ export function createOpportunitiesService(
           throw AppError.notFound('Opportunity not found')
         }
 
+        await personLinks.linkPeople(
+          tx,
+          dependencies.createId,
+          workspaceId,
+          { targetType: 'opportunity', targetId: id },
+          added,
+        )
+        await personLinks.unlinkPeople(
+          tx,
+          workspaceId,
+          { targetType: 'opportunity', targetId: id },
+          removed,
+        )
+
         if (stageMove !== undefined) {
           await dependencies.recordActivity(tx, workspaceId, actor, {
             targetType: 'opportunity',
@@ -293,21 +427,53 @@ export function createOpportunitiesService(
           })
         }
 
-        const otherChanged = changed.filter((field) => field !== 'stageId')
+        const otherChanged = scalarChanged.filter((field) => field !== 'stageId')
+        const customFieldPaths = cf?.changedPaths ?? []
+        const activityChanged = [...otherChanged, ...customFieldPaths]
 
-        if (otherChanged.length > 0) {
+        if (activityChanged.length > 0) {
+          const labels: Record<string, string> = { ...OPPORTUNITY_FIELD_LABELS, ...cf?.labels }
+          const before: Record<string, unknown> = { ...existing, ...cf?.flatBefore }
+          const after: Record<string, unknown> = { ...columns, ...cf?.flatAfter }
           await dependencies.recordActivity(tx, workspaceId, actor, {
             targetType: 'opportunity',
             targetId: id,
             kind: 'updated',
-            ...describeUpdate(otherChanged, OPPORTUNITY_FIELD_LABELS, existing, columns),
+            ...describeUpdate(activityChanged, labels, before, after),
+          })
+        }
+
+        // Links land on the opportunity's timeline only: a person's page already
+        // rolls up the activity of every pipeline record they are on, so a
+        // second row targeted at the person would show them the same news twice.
+        for (const personId of added) {
+          await dependencies.recordActivity(tx, workspaceId, actor, {
+            targetType: 'opportunity',
+            targetId: id,
+            kind: 'linked',
+            ...describeLink('person', named.get(personId) ?? personId),
+          })
+        }
+
+        for (const personId of removed) {
+          await dependencies.recordActivity(tx, workspaceId, actor, {
+            targetType: 'opportunity',
+            targetId: id,
+            kind: 'unlinked',
+            ...describeUnlink('person', named.get(personId) ?? personId),
           })
         }
 
         events.emit(
           'opportunities.opportunity.updated',
           { type: 'opportunity', id },
-          { changed },
+          {
+            changed: [
+              ...scalarChanged,
+              ...(linksChanged ? ['personIds'] : []),
+              ...customFieldPaths,
+            ],
+          },
         )
 
         if (stageMove !== undefined) {
@@ -318,7 +484,7 @@ export function createOpportunitiesService(
           )
         }
 
-        return toView(updated)
+        return toView(updated, nextPeople ?? currentPeople)
       }, { workspaceId, actor: toEventActor(actor) })
     },
 
@@ -328,9 +494,9 @@ export function createOpportunitiesService(
       await dependencies.transaction(async ({ tx, events }) => {
         await require(workspaceId, id)
 
-        // Notes, activities, decisions and plan items have no foreign key to
-        // their target, so the deleting service removes them here, in the same
-        // transaction. Nothing else references an opportunity.
+        // Notes, activities, decisions, plan items, and person_links have no
+        // foreign key to their target, so the deleting service removes them
+        // here, in the same transaction. Nothing else references an opportunity.
         await deleteRecordsAttachedTo(tx, workspaceId, 'opportunity', id)
         await repository.deleteOpportunity(tx, workspaceId, id)
 

package/src/modules/opportunities/tools.ts

@@ -13,6 +13,7 @@ const listArgs = z.strictObject({
   kind: idSetArg.optional().describe('Kinds are free text, so a match here is exact.'),
   company_id: idSetArg.optional().describe('Only opportunities with these companies.'),
   stage_id: idSetArg.optional().describe('Only opportunities in these pipeline stages.'),
+  person_id: idSetArg.optional().describe('Only opportunities any of these people are on.'),
 })
 
 export function registerOpportunitiesTools(mcp: McpToolRegistry, service: OpportunitiesService): void {
@@ -30,6 +31,7 @@ export function registerOpportunitiesTools(mcp: McpToolRegistry, service: Opport
       kinds: toSet(args.kind),
       companyIds: toSet(args.company_id),
       stageIds: toSet(args.stage_id),
+      personIds: toSet(args.person_id),
     }),
     createArgs: createBody,
     toCreateInput,

package/src/modules/partnerships/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 { partnershipsEvents } from './events.ts'
 import { mountPartnershipsRoutes } from './routes.ts'
 import * as schema from './schema.ts'
@@ -17,7 +18,7 @@ import { registerPartnershipsTools } from './tools.ts'
 export function createPartnershipsModule(migrationsDirectory: string): KelpieModule {
   return {
     id: 'partnerships',
-    requires: ['companies', 'people', 'pipelines', 'activities'],
+    requires: ['companies', 'people', 'pipelines', 'activities', 'custom-fields'],
     events: partnershipsEvents,
 
     register(context) {
@@ -30,6 +31,7 @@ export function createPartnershipsModule(migrationsDirectory: string): KelpieMod
           createId: context.createId,
           now: context.now,
         }),
+        customFields: createCustomFieldValues({ db: context.db }),
       })
 
       context.schema(schema, migrationsDirectory)

package/src/modules/partnerships/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 { partnershipPeople, partnerships } from './schema.ts'
+import { partnerships } from './schema.ts'
 
 export type PartnershipRecord = typeof partnerships.$inferSelect
 
@@ -51,15 +51,6 @@ function companyNameMatches(pattern: string): SQL {
   )`
 }
 
-function hasAnyOfPeople(personIds: readonly string[]): SQL {
-  return sql`exists (
-    select 1
-    from ${partnershipPeople}
-    where ${partnershipPeople.partnershipId} = ${partnerships.id}
-      and ${inArray(partnershipPeople.personId, personIds)}
-  )`
-}
-
 function matchesTerm(term: string): SQL | undefined {
   const pattern = containsPattern(term)
 
@@ -81,7 +72,9 @@ function conditionsFor(workspaceId: string, filters: PartnershipFilters): (SQL |
       ? undefined
       : inArray(partnerships.companyId, filters.companyIds),
     filters.stageIds === undefined ? undefined : inArray(partnerships.stageId, filters.stageIds),
-    filters.personIds === undefined ? undefined : hasAnyOfPeople(filters.personIds),
+    filters.personIds === undefined
+      ? undefined
+      : anyPersonLinked('partnership', partnerships.id, partnerships.workspaceId, filters.personIds),
   ]
 }
 
@@ -155,110 +148,6 @@ export async function deletePartnership(
   return deleted.length
 }
 
-/** The key people on one partnership. Ordered by id so a response is stable across reads. */
-export async function listPersonIds(db: Queryable, partnershipId: string): Promise<string[]> {
-  const rows = await db
-    .select({ personId: partnershipPeople.personId })
-    .from(partnershipPeople)
-    .where(eq(partnershipPeople.partnershipId, partnershipId))
-    .orderBy(asc(partnershipPeople.personId))
-
-  return rows.map((row) => row.personId)
-}
-
-/**
- * The key people on each of a page of partnerships, in one query rather than one
- * per row.
- *
- * @returns Ids missing from the map have no people.
- */
-export async function listPersonIdsFor(
-  db: Queryable,
-  partnershipIds: readonly string[],
-): Promise<ReadonlyMap<string, readonly string[]>> {
-  if (partnershipIds.length === 0) {
-    return new Map()
-  }
-
-  const rows = await db
-    .select({
-      partnershipId: partnershipPeople.partnershipId,
-      personId: partnershipPeople.personId,
-    })
-    .from(partnershipPeople)
-    .where(inArray(partnershipPeople.partnershipId, partnershipIds))
-    .orderBy(asc(partnershipPeople.personId))
-
-  const byPartnership = new Map<string, string[]>()
-
-  for (const row of rows) {
-    const existing = byPartnership.get(row.partnershipId)
-
-    if (existing === undefined) {
-      byPartnership.set(row.partnershipId, [row.personId])
-    } else {
-      existing.push(row.personId)
-    }
-  }
-
-  return byPartnership
-}
-
-export async function insertPartnershipPeople(
-  db: Queryable,
-  partnershipId: string,
-  personIds: readonly string[],
-): Promise<void> {
-  if (personIds.length === 0) {
-    return
-  }
-
-  await db
-    .insert(partnershipPeople)
-    .values(personIds.map((personId) => ({ partnershipId, personId })))
-}
-
-export async function deletePartnershipPeople(
-  db: Queryable,
-  partnershipId: string,
-  personIds: readonly string[],
-): Promise<void> {
-  if (personIds.length === 0) {
-    return
-  }
-
-  await db
-    .delete(partnershipPeople)
-    .where(
-      and(
-        eq(partnershipPeople.partnershipId, partnershipId),
-        inArray(partnershipPeople.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,