@kelpie/server 0.6.0 → 0.8.0

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

@@ -11,7 +11,7 @@ import * as dealRepository from '../deals/repository.ts'
 import * as peopleRepository from '../people/repository.ts'
 import * as positionRepository from '../positions/repository.ts'
 import { IMPORT_DEAL_CURRENCY, NEW_COMPANY_DEFAULTS, NEW_PERSON_DEFAULTS } from './drafts.ts'
-import type { ImportWrite, RowPlan } from './plan.ts'
+import type { ImportWrite, PlannedAffiliation, RowPlan } from './plan.ts'
 
 /**
  * Applying one planned row: the insert or update, and the timeline entry that
@@ -34,6 +34,21 @@ export interface WriteDependencies {
   readonly sourceName: string
 }
 
+/**
+ * A record a row wrote besides its primary one.
+ *
+ * A People row with an affiliation makes a Position, and under
+ * `on_missing_company: create` a Company as well. Each needs its own module
+ * event, which the service emits from these.
+ */
+export interface SideRecord {
+  readonly objectType: RecordObjectType
+  readonly recordId: string
+  readonly created: boolean
+  /** The columns an update moved. Empty on a create. */
+  readonly changedFields: readonly string[]
+}
+
 export interface WriteOutcome {
   readonly recordId: string
   readonly objectType: RecordObjectType
@@ -43,6 +58,8 @@ export interface WriteOutcome {
    * nothing at all.
    */
   readonly changedFields: readonly string[]
+  /** Records the row wrote besides its primary one: a People affiliation's company and position. */
+  readonly sideRecords?: readonly SideRecord[]
 }
 
 /** A create or update plan. `skip` and `error` never reach here. */
@@ -102,6 +119,92 @@ async function writeCompany(
   return { recordId: id, objectType: 'company', changedFields }
 }
 
+/**
+ * Writes the position a People row named, and the company it belongs to when the
+ * job was told to create one.
+ *
+ * The company is created before the position so the link has something to point
+ * at. The position is renamed in place when the person already holds one at that
+ * company, and created otherwise, which is the two-column-key behaviour the
+ * People affiliation chose. Files the `created Company` and `linked to company`
+ * activities as it goes, the same sentences the Companies and Positions imports
+ * write.
+ */
+async function applyAffiliation(
+  dependencies: WriteDependencies,
+  personId: string,
+  affiliation: PlannedAffiliation,
+): Promise<readonly SideRecord[]> {
+  const { tx, workspaceId, actor, sourceName } = dependencies
+  const sideRecords: SideRecord[] = []
+
+  const companyId = await (async (): Promise<string> => {
+    if (affiliation.kind === 'link') {
+      return affiliation.companyId
+    }
+
+    const created = await companyRepository.insertCompany(tx, {
+      ...NEW_COMPANY_DEFAULTS,
+      ...affiliation.company,
+      tags: affiliation.company.tags === undefined ? undefined : [...affiliation.company.tags],
+      id: dependencies.createId('company'),
+      workspaceId,
+      name: affiliation.company.name ?? '',
+    })
+
+    sideRecords.push({ objectType: 'company', recordId: created.id, created: true, changedFields: [] })
+    await dependencies.recordActivity(tx, workspaceId, actor, {
+      targetType: 'company',
+      targetId: created.id,
+      kind: 'created',
+      ...describeCreationVia('Company', sourceName),
+    })
+
+    return created.id
+  })()
+
+  const held = await positionRepository.listPositionsAt(tx, workspaceId, personId, companyId)
+  const current = held[0]
+
+  if (current === undefined) {
+    const created = await positionRepository.insertPosition(tx, {
+      id: dependencies.createId('position'),
+      workspaceId,
+      personId,
+      companyId,
+      title: affiliation.title,
+    })
+
+    sideRecords.push({ objectType: 'position', recordId: created.id, created: true, changedFields: [] })
+
+    for (const end of [
+      { targetType: 'person', targetId: personId, related: 'company' },
+      { targetType: 'company', targetId: companyId, related: 'person' },
+    ] as const) {
+      await dependencies.recordActivity(tx, workspaceId, actor, {
+        targetType: end.targetType,
+        targetId: end.targetId,
+        kind: 'linked',
+        ...describeLink(end.related, sourceName),
+      })
+    }
+
+    return sideRecords
+  }
+
+  const changedFields = changedKeys(current, { title: affiliation.title })
+
+  if (changedFields.length > 0) {
+    await positionRepository.updatePosition(tx, workspaceId, current.id, {
+      title: affiliation.title,
+      updatedAt: dependencies.now,
+    })
+    sideRecords.push({ objectType: 'position', recordId: current.id, created: false, changedFields })
+  }
+
+  return sideRecords
+}
+
 async function writePerson(
   dependencies: WriteDependencies,
   plan: WritablePlan,
@@ -120,7 +223,12 @@ async function writePerson(
       name: write.draft.name ?? '',
     })
 
-    return { recordId: created.id, objectType: 'person', changedFields: [] }
+    const sideRecords =
+      write.affiliation === undefined
+        ? []
+        : await applyAffiliation(dependencies, created.id, write.affiliation)
+
+    return { recordId: created.id, objectType: 'person', changedFields: [], sideRecords }
   }
 
   const id = requireTarget(plan)
@@ -144,7 +252,12 @@ async function writePerson(
     })
   }
 
-  return { recordId: id, objectType: 'person', changedFields }
+  const sideRecords =
+    write.affiliation === undefined
+      ? []
+      : await applyAffiliation(dependencies, id, write.affiliation)
+
+  return { recordId: id, objectType: 'person', changedFields, sideRecords }
 }
 
 /**

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,313 @@
+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) }
+}
+
+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
+}