@kelpie/server 0.7.0 → 0.8.0

package/src/modules/companies/routes.ts

@@ -30,6 +30,7 @@ const companyShape = {
   tech_stack: z.array(z.string().min(1)),
   summary: z.string(),
   tags: z.array(z.string().min(1)),
+  is_own: z.boolean(),
 }
 
 /**
@@ -51,6 +52,7 @@ export const createBody = z.strictObject({
   tech_stack: companyShape.tech_stack.default([]),
   summary: companyShape.summary.default(''),
   tags: companyShape.tags.default([]),
+  is_own: companyShape.is_own.default(false),
 })
 
 export const updateBody = z.strictObject(companyShape).partial()
@@ -74,6 +76,7 @@ export function toCreateInput(body: z.infer<typeof createBody>): CreateCompanyIn
     techStack: body.tech_stack,
     summary: body.summary,
     tags: body.tags,
+    isOwn: body.is_own,
   }
 }
 
@@ -92,6 +95,7 @@ export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateCompanyIn
     ...(body.tech_stack === undefined ? {} : { techStack: body.tech_stack }),
     ...(body.summary === undefined ? {} : { summary: body.summary }),
     ...(body.tags === undefined ? {} : { tags: body.tags }),
+    ...(body.is_own === undefined ? {} : { isOwn: body.is_own }),
   }
 }
 
@@ -111,6 +115,7 @@ export function companyResponse(company: CompanyView): Record<string, unknown> {
     tech_stack: company.techStack,
     summary: company.summary,
     tags: company.tags,
+    is_own: company.isOwn,
     created_at: company.createdAt.toISOString(),
     updated_at: company.updatedAt.toISOString(),
   }
@@ -120,11 +125,19 @@ export function mountCompaniesRoutes(router: Hono, dependencies: CompaniesRoutes
   const requireActor = (context: Context): Promise<Actor> => resolveActorFrom(dependencies, context)
 
   router.get('/companies', async (context) => {
+    // `?is_own=true|false` narrows to the workspace's own companies (or the
+    // rest). Anything else is treated as absent, so an unknown value never
+    // returns an accidental "everything".
+    const isOwnParam = context.req.query('is_own')
+    const isOwn =
+      isOwnParam === 'true' ? true : isOwnParam === 'false' ? false : undefined
+
     const page = await dependencies.service.list(
       await requireActor(context),
       {
         term: context.req.query('q'),
         personIds: readIdFilter(context, 'person_id'),
+        isOwn,
       },
       readListParameters(context),
     )

package/src/modules/companies/schema.ts

@@ -1,5 +1,5 @@
 import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from '@kelpie/schemas'
-import { index, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import { boolean, index, pgTable, text, unique } from 'drizzle-orm/pg-core'
 
 import {
   checkOneOf,
@@ -42,6 +42,10 @@ export const companies = pgTable(
     techStack: text('tech_stack').array().notNull().default([]),
     summary: text('summary').notNull().default(''),
     tags: text('tags').array().notNull().default([]),
+    // "This is us": a workspace marks its own company (or several, e.g. parent
+    // and subsidiary) so downstream views can distinguish self from prospects.
+    // Loose semantics on purpose — zero or many rows may carry it.
+    isOwn: boolean('is_own').notNull().default(false),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
     searchVector: searchVector((): readonly SearchVectorPart[] => [

package/src/modules/companies/service.ts

@@ -1,6 +1,7 @@
 import { changedKeys } from '../../lib/changes.ts'
 import { UNIQUE_VIOLATION, isReferenceViolation, postgresErrorCode } from '../../lib/database.ts'
 import type { Database } from '../../lib/database.ts'
+import { autoLinkCompanyByDomain } from '../../lib/emailDomainAutoLink.ts'
 import { AppError } from '../../lib/errors.ts'
 import type { IdFactory } from '../../lib/ids.ts'
 import { normaliseDomain } from '../../lib/normalisation.ts'
@@ -51,6 +52,7 @@ const COMPANY_FIELD_LABELS: FieldLabels = {
   techStack: 'Tech stack',
   summary: 'Summary',
   tags: 'Tags',
+  isOwn: 'Own company',
 }
 
 /** A company as the API returns one: the stored row minus the tenancy column. */
@@ -70,6 +72,7 @@ export interface CreateCompanyInput {
   readonly techStack: readonly string[]
   readonly summary: string
   readonly tags: readonly string[]
+  readonly isOwn: boolean
 }
 
 /** PATCH semantics: an absent field is left alone, and null clears a nullable one. */
@@ -112,6 +115,7 @@ function toStoredColumns(input: UpdateCompanyInput): Partial<repository.CompanyC
     ...(input.techStack === undefined ? {} : { techStack: [...input.techStack] }),
     ...(input.summary === undefined ? {} : { summary: input.summary }),
     ...(input.tags === undefined ? {} : { tags: [...input.tags] }),
+    ...(input.isOwn === undefined ? {} : { isOwn: input.isOwn }),
   }
 }
 
@@ -171,6 +175,7 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
             techStack: [...input.techStack],
             summary: input.summary,
             tags: [...input.tags],
+            isOwn: input.isOwn,
           })
         } catch (error: unknown) {
           if (postgresErrorCode(error) === UNIQUE_VIOLATION) {
@@ -189,6 +194,15 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
 
         events.emit('companies.company.created', { type: 'company', id: created.id }, {})
 
+        // Sync sweep of the workspace's people: everyone whose email domain
+        // matches this Company gets a titleless Position where none exists yet.
+        // Inside the same transaction so a follow-up read sees the new links.
+        await autoLinkCompanyByDomain(tx, events, workspaceId, created, {
+          createId: dependencies.createId,
+          now: dependencies.now,
+          recordActivity: dependencies.recordActivity,
+        })
+
         return toView(created)
       }, { workspaceId, actor: toEventActor(actor) })
     },
@@ -232,6 +246,17 @@ export function createCompaniesService(dependencies: CompaniesDependencies): Com
 
         events.emit('companies.company.updated', { type: 'company', id }, { changed })
 
+        // Sync sweep when the domain moved. A newly-set domain gains matches;
+        // a changed domain gains new matches without touching the old links
+        // (never-remove — a person may still work at the previous domain).
+        if (changed.includes('domain')) {
+          await autoLinkCompanyByDomain(tx, events, workspaceId, updated, {
+            createId: dependencies.createId,
+            now: dependencies.now,
+            recordActivity: dependencies.recordActivity,
+          })
+        }
+
         return toView(updated)
       }, { workspaceId, actor: toEventActor(actor) })
     },

package/src/modules/core.ts

@@ -9,10 +9,12 @@ import { createCompaniesModule } from './companies/index.ts'
 import { createDashboardModule } from './dashboard/index.ts'
 import { createDealsModule } from './deals/index.ts'
 import { createDecisionsModule } from './decisions/index.ts'
+import { createEmailDomainLinkerModule } from './email-domain-linker/index.ts'
 import { createFormsModule } from './forms/index.ts'
 import { createHandbookModule } from './handbook/index.ts'
 import { createHiringModule } from './hiring/index.ts'
 import { createImportExportModule } from './import-export/index.ts'
+import { createListsModule } from './lists/index.ts'
 import { createNotesModule } from './notes/index.ts'
 import { createOpportunitiesModule } from './opportunities/index.ts'
 import { createPartnershipsModule } from './partnerships/index.ts'
@@ -21,6 +23,7 @@ import { createPipelinesModule } from './pipelines/index.ts'
 import { createPlansModule } from './plans/index.ts'
 import { createPositionsModule } from './positions/index.ts'
 import { createRaisesModule } from './raises/index.ts'
+import { createSampleDataModule } from './sample-data/index.ts'
 import { createSearchModule } from './search/index.ts'
 import { createSmtpEmailModule } from './smtp-email/index.ts'
 import { createWebhooksModule } from './webhooks/index.ts'
@@ -57,6 +60,7 @@ export const coreModules: readonly KelpieModule[] = [
   createHiringModule(coreMigrationsDirectory),
   createPlansModule(coreMigrationsDirectory),
   createDecisionsModule(coreMigrationsDirectory),
+  createListsModule(coreMigrationsDirectory),
   createHandbookModule(coreMigrationsDirectory),
   // Neither of these takes a migrations directory: they own no tables and read
   // other modules'.
@@ -66,6 +70,13 @@ export const coreModules: readonly KelpieModule[] = [
   createImportExportModule(coreMigrationsDirectory),
   createAgentTasksModule(coreMigrationsDirectory),
   createWebhooksModule(coreMigrationsDirectory),
+  // Owns no tables. One-shot fixture install for a new workspace, called from
+  // the setup wizard's checkbox and the admin data page.
+  createSampleDataModule(),
+  // Owns no tables. Admin action that reruns the email-domain sweep across
+  // every workspace Company — backfills links for data that predates the
+  // auto-linker, or after a bulk import.
+  createEmailDomainLinkerModule(),
   // Owns no tables. Registers a `'smtp'` provider with core's email runtime;
   // the factory only runs if the assembly's `email.provider` picks it.
   createSmtpEmailModule(),

package/src/modules/email-domain-linker/index.ts

@@ -0,0 +1,40 @@
+import type { KelpieModule } from '../../runtime/module.ts'
+import { createActivityRecorder } from '../activities/index.ts'
+import { mountEmailDomainLinkerRoutes } from './routes.ts'
+import { createEmailDomainLinkerService } from './service.ts'
+
+/**
+ * Rebuild every email-domain link across the workspace.
+ *
+ * Owns no tables. Requires the modules whose data the sweep reads and writes.
+ * The sweep is the same one the companies service runs on a domain change,
+ * applied to every workspace Company at once — used to backfill links for
+ * data that predates the auto-linker, or after a bulk import.
+ */
+export function createEmailDomainLinkerModule(): KelpieModule {
+  return {
+    id: 'email-domain-linker',
+    requires: ['workspace', 'companies', 'people', 'positions', 'activities'],
+
+    register(context) {
+      const service = createEmailDomainLinkerService({
+        db: context.db,
+        transaction: context.transaction,
+        createId: context.createId,
+        now: context.now,
+        recordActivity: createActivityRecorder({
+          createId: context.createId,
+          now: context.now,
+        }),
+      })
+
+      context.routes((router) => {
+        mountEmailDomainLinkerRoutes(router, { db: context.db, now: context.now, service })
+      })
+
+      return Promise.resolve()
+    },
+  }
+}
+
+export type { EmailDomainLinkerService, RelinkCounts } from './service.ts'

package/src/modules/email-domain-linker/routes.ts

@@ -0,0 +1,40 @@
+import type { Context, Hono } from 'hono'
+
+import type { Actor } from '../auth/actor.ts'
+import { resolveActorFrom } from '../auth/credentials.ts'
+import type { CredentialDependencies } from '../auth/credentials.ts'
+import type { EmailDomainLinkerService, RelinkCounts } from './service.ts'
+
+/**
+ * Wire shape for `POST /v1/workspaces/:id/relink-email-domains`.
+ *
+ * No request body. The response counts what the sweep did.
+ */
+
+export interface EmailDomainLinkerRoutesDependencies extends CredentialDependencies {
+  readonly service: EmailDomainLinkerService
+}
+
+export function relinkResponse(counts: RelinkCounts): Record<string, unknown> {
+  return {
+    companies_scanned: counts.companiesScanned,
+    positions_created: counts.positionsCreated,
+  }
+}
+
+export function mountEmailDomainLinkerRoutes(
+  router: Hono,
+  dependencies: EmailDomainLinkerRoutesDependencies,
+): void {
+  const requireActor = (context: Context): Promise<Actor> =>
+    resolveActorFrom(dependencies, context)
+
+  router.post('/workspaces/:id/relink-email-domains', async (context) => {
+    const counts = await dependencies.service.relink(
+      await requireActor(context),
+      context.req.param('id'),
+    )
+
+    return context.json(relinkResponse(counts))
+  })
+}

package/src/modules/email-domain-linker/service.ts

@@ -0,0 +1,122 @@
+import { and, eq, isNotNull } from 'drizzle-orm'
+
+import { toEventActor } from '../../lib/actor.ts'
+import type { Database } from '../../lib/database.ts'
+import { autoLinkCompanyByDomain } from '../../lib/emailDomainAutoLink.ts'
+import { AppError } from '../../lib/errors.ts'
+import type { IdFactory } from '../../lib/ids.ts'
+import type { TransactionScope } from '../../runtime/transaction.ts'
+import type { ActivityRecorder } from '../activities/recorder.ts'
+import type { Actor } from '../auth/actor.ts'
+import { requireWorkspaceId } from '../auth/actor.ts'
+import * as authRepository from '../auth/repository.ts'
+import { companies } from '../companies/schema.ts'
+import { parseMemberRole, roleAllows } from '../workspace/roles.ts'
+
+/**
+ * Rebuild every email-domain link across the workspace.
+ *
+ * Iterates each Company that carries a domain and runs the same sweep the
+ * companies service runs on a domain change — every workspace Person whose
+ * email is at that domain gets a titleless Position where none exists yet.
+ *
+ * Idempotent: a follow-up run adds nothing. Add-only, consumer-host-skipping,
+ * and workspace-scoped, same as the inline auto-linker.
+ *
+ * One transaction per Company, not one for the whole sweep. A workspace can
+ * carry thousands of Companies, and a single transaction that long would
+ * hold row-share locks against every write elsewhere for the whole run.
+ */
+
+export interface EmailDomainLinkerDependencies {
+  readonly db: Database
+  readonly transaction: TransactionScope
+  readonly createId: IdFactory
+  readonly now: () => Date
+  readonly recordActivity: ActivityRecorder
+}
+
+export interface RelinkCounts {
+  /** Companies with a non-null domain that were considered. Consumer hosts are counted but skipped. */
+  readonly companiesScanned: number
+  /** New Positions the sweep inserted this run. */
+  readonly positionsCreated: number
+}
+
+export interface EmailDomainLinkerService {
+  relink(actor: Actor, workspaceId: string): Promise<RelinkCounts>
+}
+
+export function createEmailDomainLinkerService(
+  dependencies: EmailDomainLinkerDependencies,
+): EmailDomainLinkerService {
+  async function requireAdmin(actor: Actor, workspaceId: string): Promise<void> {
+    if (actor.workspaceId !== workspaceId) {
+      throw AppError.notFound('Workspace not found')
+    }
+
+    if (actor.kind === 'api_key' && actor.userId === null) {
+      if (!roleAllows(actor.role, 'admin')) {
+        throw new AppError('forbidden', 'This action needs the admin role')
+      }
+      return
+    }
+
+    const userId = actor.userId
+
+    if (userId === null) {
+      throw AppError.notFound('Workspace not found')
+    }
+
+    const membership = await authRepository.findMembership(dependencies.db, workspaceId, userId)
+
+    if (membership === undefined) {
+      throw AppError.notFound('Workspace not found')
+    }
+
+    const role = parseMemberRole(membership.role)
+
+    if (role === undefined) {
+      throw new Error(`workspace_members.role holds "${membership.role}", which its check forbids`)
+    }
+
+    if (!roleAllows(role, 'admin')) {
+      throw new AppError('forbidden', 'This action needs the admin role')
+    }
+  }
+
+  return {
+    async relink(actor, workspaceId) {
+      requireWorkspaceId(actor)
+      await requireAdmin(actor, workspaceId)
+
+      // Every workspace Company that carries a domain — the ones the sweep
+      // can match against. Pooled read outside the per-company transactions:
+      // the work-list is one query, each write opens its own scope.
+      const rows = await dependencies.db
+        .select()
+        .from(companies)
+        .where(and(eq(companies.workspaceId, workspaceId), isNotNull(companies.domain)))
+
+      let created = 0
+
+      // One transaction per Company, not one for the whole sweep. A workspace
+      // can carry thousands of Companies; a single transaction that long would
+      // hold row-share locks against every write elsewhere for the whole run.
+      for (const company of rows) {
+        const inserted = await dependencies.transaction(
+          async ({ tx, events }) =>
+            autoLinkCompanyByDomain(tx, events, workspaceId, company, {
+              createId: dependencies.createId,
+              now: dependencies.now,
+              recordActivity: dependencies.recordActivity,
+            }),
+          { workspaceId, actor: toEventActor(actor) },
+        )
+        created += inserted.length
+      }
+
+      return { companiesScanned: rows.length, positionsCreated: created }
+    },
+  }
+}

package/src/modules/eventCatalogs.ts

@@ -23,6 +23,7 @@ import './people/events.ts'
 import './companies/events.ts'
 import './positions/events.ts'
 import './notes/events.ts'
+import './lists/events.ts'
 import './deals/events.ts'
 import './opportunities/events.ts'
 import './partnerships/events.ts'

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