@kelpie/server 0.7.0 → 0.9.0

package/src/modules/search/index.ts

@@ -4,7 +4,7 @@ import { createSearchService } from './service.ts'
 import { registerSearchTools } from './tools.ts'
 
 /**
- * One box across nine collections.
+ * One box across ten collections.
  *
  * It contributes no tables and calls no `context.schema`. The `search_vector`
  * column each searchable table carries belongs to that table's own module, which
@@ -30,6 +30,7 @@ export function createSearchModule(): KelpieModule {
       'positions',
       'companies',
       'deals',
+      'enquiries',
       'opportunities',
       'partnerships',
       'raises',

package/src/modules/search/repository.ts

@@ -8,6 +8,7 @@ import type { Queryable } from '../../runtime/transaction.ts'
 import { companies } from '../companies/schema.ts'
 import { deals } from '../deals/schema.ts'
 import { decisions } from '../decisions/schema.ts'
+import { enquiries } from '../enquiries/schema.ts'
 import { handbookPages } from '../handbook/schema.ts'
 import { roles } from '../hiring/schema.ts'
 import { opportunities } from '../opportunities/schema.ts'
@@ -210,7 +211,7 @@ function byPlanItem(
   db: Queryable,
   workspaceId: string,
   query: SQL,
-  targetType: 'deal' | 'opportunity' | 'raise',
+  targetType: 'deal' | 'opportunity' | 'raise' | 'enquiry',
 ) {
   return db
     .select({ id: planItems.targetId, rank: relatedRank(planItems.searchVector, query).as('rank') })
@@ -224,6 +225,37 @@ function byPlanItem(
     )
 }
 
+export async function searchEnquiries(
+  db: Queryable,
+  workspaceId: string,
+  query: SQL,
+  limit: number,
+): Promise<CollectionHits> {
+  const own = db
+    .select({ id: enquiries.id, rank: rank(enquiries.searchVector, query).as('rank') })
+    .from(enquiries)
+    .where(and(eq(enquiries.workspaceId, workspaceId), matches(enquiries.searchVector, query)))
+
+  const hits = unionAll(own, byPlanItem(db, workspaceId, query, 'enquiry')).as('hits')
+
+  const rows = await db
+    .select({
+      id: enquiries.id,
+      title: enquiries.name,
+      subtitle: pipelineStages.label,
+      snippetSource: enquiries.summary,
+      total,
+    })
+    .from(hits)
+    .innerJoin(enquiries, eq(enquiries.id, hits.id))
+    .innerJoin(pipelineStages, eq(pipelineStages.id, enquiries.stageId))
+    .groupBy(enquiries.id, pipelineStages.label)
+    .orderBy(desc(bestRank(hits.rank)), asc(enquiries.id))
+    .limit(limit)
+
+  return collect('enquiry', rows)
+}
+
 export async function searchDeals(
   db: Queryable,
   workspaceId: string,

package/src/modules/search/service.ts

@@ -10,6 +10,7 @@ import {
   searchCompanies,
   searchDeals,
   searchDecisions,
+  searchEnquiries,
   searchHandbookPages,
   searchOpportunities,
   searchPartnerships,
@@ -20,7 +21,7 @@ import {
 import type { CollectionHits } from './repository.ts'
 
 /**
- * One box across nine collections, ranked per collection rather than merged.
+ * One box across ten collections, ranked per collection rather than merged.
  *
  * A single merged ranking would need `ts_rank` values from different tables to
  * mean the same thing, and they do not: a handbook page is a thousand words and a
@@ -49,7 +50,7 @@ export interface SearchResults {
   readonly limit: number
   /** Across every group. The number a "12 results" heading is built from. */
   readonly total: number
-  /** Always all nine, in `SEARCH_COLLECTIONS` order, empty ones included. */
+  /** Always all ten, in `SEARCH_COLLECTIONS` order, empty ones included. */
   readonly groups: readonly SearchGroup[]
 }
 
@@ -71,7 +72,7 @@ export interface SearchServiceDependencies {
 /**
  * How many rows a group carries when the caller does not say.
  *
- * Small on purpose: nine groups on one page, and a reader scanning them wants the
+ * Small on purpose: ten groups on one page, and a reader scanning them wants the
  * best few of each rather than a page of People they have to scroll past to reach
  * the handbook. The exact total sits beside each group regardless.
  */
@@ -89,6 +90,7 @@ const SEARCHES: Readonly<Record<SearchCollection, CollectionSearch>> = {
   person: searchPeople,
   role: searchRoles,
   company: searchCompanies,
+  enquiry: searchEnquiries,
   deal: searchDeals,
   opportunity: searchOpportunities,
   raise: searchRaises,
@@ -134,8 +136,8 @@ export function createSearchService(dependencies: SearchServiceDependencies): Se
       const query = compileQuery(tsQuery)
       const words = searchWords(request.term)
 
-      // Nine independent reads with nothing to share but the compiled query. Run
-      // in sequence they would be nine round trips deep rather than wide.
+      // Ten independent reads with nothing to share but the compiled query. Run
+      // in sequence they would be ten round trips deep rather than wide.
       const groups = await Promise.all(
         wanted.map(async (collection) =>
           toGroup(await SEARCHES[collection](dependencies.db, workspaceId, query, limit), words),

package/src/modules/smtp-email/index.ts

@@ -44,7 +44,13 @@ export type SmtpEmailConfig = z.infer<typeof smtpEmailConfigSchema>
  * sender is verifiable without a container running a real SMTP conversation.
  */
 export interface SmtpTransport {
-  sendMail(message: { from: string; to: string; subject: string; text: string }): Promise<unknown>
+  sendMail(message: {
+    from: string
+    to: string
+    subject: string
+    text: string
+    html?: string
+  }): Promise<unknown>
 }
 
 function createNodemailerTransport(config: SmtpEmailConfig): SmtpTransport {
@@ -70,6 +76,7 @@ export function createSmtpEmailSender(
           to: message.to,
           subject: message.subject,
           text: message.body,
+          ...(message.html === undefined ? {} : { html: message.html }),
         })
       } catch (cause) {
         const reason = describeThrown(cause)

package/src/modules/stagedRecords.ts

@@ -2,20 +2,21 @@ import { and, eq } from 'drizzle-orm'
 
 import type { Queryable } from '../runtime/transaction.ts'
 import { deals } from './deals/schema.ts'
+import { enquiries } from './enquiries/schema.ts'
 import { opportunities } from './opportunities/schema.ts'
 import { partnerships } from './partnerships/schema.ts'
 import type { PipelineKind } from './pipelines/schema.ts'
 import { raises } from './raises/schema.ts'
 
 /**
- * The four tables whose rows sit in a pipeline stage, for the one operation that
+ * The five tables whose rows sit in a pipeline stage, for the one operation that
  * spans them all: removing a stage moves whatever still references it.
  *
- * Touching four modules' tables here rather than composing four services follows
+ * Touching five modules' tables here rather than composing five services follows
  * `attachedRecords.ts`: the alternative is a stage removal that imports every
  * staged service to ask each for a bulk move it exists for nowhere else.
  *
- * Four written-out branches rather than a table-of-tables, because Drizzle's
+ * Five written-out branches rather than a table-of-tables, because Drizzle's
  * `update().set()` needs the concrete table type to check the column names.
  */
 
@@ -87,5 +88,19 @@ export async function reassignStagedRecords(
 
       return moved.map((row) => row.id)
     }
+    case 'enquiry': {
+      const moved = await db
+        .update(enquiries)
+        .set(changes)
+        .where(
+          and(
+            eq(enquiries.workspaceId, move.workspaceId),
+            eq(enquiries.stageId, move.fromStageId),
+          ),
+        )
+        .returning({ id: enquiries.id })
+
+      return moved.map((row) => row.id)
+    }
   }
 }

package/src/modules/webhooks/payloads.ts

@@ -41,6 +41,10 @@ interface RecordUpdatedData {
 interface FormSubmittedData {
   readonly formId?: string
   readonly submissionId?: string
+  readonly opportunityId?: string | null
+  readonly partnershipId?: string | null
+  readonly enquiryId?: string | null
+  readonly actions?: readonly { readonly action: string; readonly status: string }[]
 }
 
 /**
@@ -90,7 +94,11 @@ export function translateEnvelopeEvent(
 
   if (suffix === 'submitted') {
     // Form submission is the only `.submitted` wire event today. The forms
-    // module emits its envelope with `formId` and `submissionId` in `data`.
+    // module emits its envelope with `formId` and `submissionId` in `data`,
+    // plus (per forms.md §Webhooks) the opportunity/partnership ids the
+    // post-submit runner created and one status per configured action. The
+    // per-action `detail` string is deliberately omitted — the authenticated
+    // Submissions read carries it in full, the webhook only says what ran.
     const data = event.data as FormSubmittedData
     if (data.formId === undefined || data.submissionId === undefined) {
       return undefined
@@ -99,7 +107,17 @@ export function translateEnvelopeEvent(
     return {
       workspaceId: event.workspaceId,
       event: 'form.submitted',
-      data: { form_id: data.formId, submission_id: data.submissionId },
+      data: {
+        form_id: data.formId,
+        submission_id: data.submissionId,
+        opportunity_id: data.opportunityId ?? null,
+        partnership_id: data.partnershipId ?? null,
+        enquiry_id: data.enquiryId ?? null,
+        actions:
+          data.actions === undefined
+            ? []
+            : data.actions.map((entry) => ({ action: entry.action, status: entry.status })),
+      },
     }
   }
 

package/src/modules/workspace/repository.ts

@@ -3,6 +3,7 @@ import { and, asc, count, eq, gt } from 'drizzle-orm'
 import type { Database } from '../../lib/database.ts'
 import type { Transaction } from '../../runtime/transaction.ts'
 import { users } from '../auth/schema.ts'
+import { consentPurposes } from '../consent-purposes/schema.ts'
 import { deals } from '../deals/schema.ts'
 import { decisions } from '../decisions/schema.ts'
 import { handbookPages } from '../handbook/schema.ts'
@@ -387,6 +388,17 @@ export async function insertPipelineStages(
   await db.insert(pipelineStages).values([...values])
 }
 
+export async function insertConsentPurposes(
+  db: Queryable,
+  values: readonly (typeof consentPurposes.$inferInsert)[],
+): Promise<void> {
+  if (values.length === 0) {
+    return
+  }
+
+  await db.insert(consentPurposes).values([...values])
+}
+
 export type ModuleSettingRecord = typeof workspaceModuleSettings.$inferSelect
 
 export async function listModuleSettings(db: Queryable, workspaceId: string): Promise<ModuleSettingRecord[]> {

package/src/modules/workspace/service.ts

@@ -2,6 +2,7 @@ import { APP_LINK_PATHS, buildAppLink } from '../../lib/appUrl.ts'
 import { UNIQUE_VIOLATION, isReferenceViolation, postgresErrorCode } from '../../lib/database.ts'
 import type { Database } from '../../lib/database.ts'
 import type { EmailSender } from '../../lib/email.ts'
+import { renderEmail } from '../../lib/emailContent.ts'
 import { AppError } from '../../lib/errors.ts'
 import type { IdFactory } from '../../lib/ids.ts'
 import { generateToken, hashToken } from '../../lib/tokens.ts'
@@ -14,6 +15,7 @@ import type { Actor, SessionActor } from '../auth/actor.ts'
 import './events.ts'
 import * as authRepository from '../auth/repository.ts'
 import { SEATS_LIMIT } from './capabilities.ts'
+import { STARTER_CONSENT_PURPOSES } from '../consent-purposes/starters.ts'
 import * as repository from './repository.ts'
 import { parseInvitableRole, parseMemberRole, roleAllows } from './roles.ts'
 import type { InvitableRole, InviteStatus, MemberRole } from './roles.ts'
@@ -336,11 +338,22 @@ export function createWorkspaceService(dependencies: WorkspaceDependencies): Wor
 
   function sendInviteEmail(to: string, token: string): Promise<void> {
     const link = buildAppLink(dependencies.appBaseUrl, APP_LINK_PATHS.inviteAccept, token)
+    const { text, html } = renderEmail(
+      {
+        action: {
+          instructions: 'Accept the invitation within seven days:',
+          buttonText: 'Accept invitation',
+          link,
+        },
+      },
+      dependencies.appBaseUrl,
+    )
 
     return dependencies.email.send({
       to,
       subject: 'You have been invited to a Kelpie workspace',
-      body: `Accept the invitation within seven days:\n\n${link}`,
+      body: text,
+      html,
     })
   }
 
@@ -459,6 +472,19 @@ export function createWorkspaceService(dependencies: WorkspaceDependencies): Wor
           ),
         )
 
+        await repository.insertConsentPurposes(
+          tx,
+          STARTER_CONSENT_PURPOSES.map((purpose, index) => ({
+            id: dependencies.createId('consentPurpose'),
+            workspaceId,
+            slug: purpose.slug,
+            label: purpose.label,
+            description: purpose.description,
+            defaultStatus: purpose.defaultStatus,
+            sortOrder: index,
+          })),
+        )
+
         // The session that created the workspace should land in it.
         await authRepository.setActiveWorkspace(tx, actor.sessionId, workspaceId)
 

package/src/modules/workspace/starters.ts

@@ -37,6 +37,11 @@ export interface StarterStage {
 
 /** `open: false` hides a stage from the Open scope filter; it is not a delete. */
 export const STARTER_PIPELINE_STAGES: Readonly<Record<string, readonly StarterStage[]>> = {
+  enquiry: [
+    { slug: 'new', label: 'New', open: true },
+    { slug: 'in_progress', label: 'In progress', open: true },
+    { slug: 'closed', label: 'Closed', open: false },
+  ],
   deal: [
     { slug: 'qualifying', label: 'Qualifying', open: true },
     { slug: 'proposal', label: 'Proposal', open: true },

package/src/runtime/events.ts

@@ -29,6 +29,7 @@ export const RECORD_OBJECT_TYPES = [
   'company',
   'position',
   'deal',
+  'enquiry',
   'opportunity',
   'partnership',
   'raise',

package/src/schema/index.ts

@@ -9,11 +9,13 @@
 export * from '../modules/auth/schema.ts'
 export * from '../modules/workspace/schema.ts'
 export * from '../modules/api-keys/schema.ts'
+export * from '../modules/consent-purposes/schema.ts'
 export * from '../modules/people/schema.ts'
 export * from '../modules/companies/schema.ts'
 export * from '../modules/positions/schema.ts'
 export * from '../modules/pipelines/schema.ts'
 export * from '../modules/deals/schema.ts'
+export * from '../modules/enquiries/schema.ts'
 export * from '../modules/opportunities/schema.ts'
 export * from '../modules/partnerships/schema.ts'
 export * from '../modules/raises/schema.ts'
@@ -21,7 +23,9 @@ export * from '../modules/hiring/schema.ts'
 export * from '../modules/plans/schema.ts'
 export * from '../modules/decisions/schema.ts'
 export * from '../modules/notes/schema.ts'
+export * from '../modules/lists/schema.ts'
 export * from '../modules/activities/schema.ts'
+export * from '../modules/custom-fields/schema.ts'
 export * from '../modules/handbook/schema.ts'
 export * from '../modules/forms/schema.ts'
 export * from '../modules/import-export/schema.ts'

package/src/testing/database.ts

@@ -15,24 +15,42 @@ import { TEST_EMAIL_FROM, TEST_EMAIL_PROVIDER, createTestServices } from './serv
  * A migrated database for integration tests.
  *
  * Tests connect to the same local Postgres the dev server uses, on a database
- * named by `TEST_DATABASE_URL`. Migrations run once per process; between tests
- * `truncateAll` empties the tables rather than re-migrating, which is an order of
- * magnitude faster and just as isolated.
+ * named by `TEST_DATABASE_URL` — suffixed per Vitest worker, so test files can
+ * run in parallel without sharing tables. Migrations run once per process;
+ * between tests `truncateAll` empties the tables rather than re-migrating.
+ *
+ * The reset deletes rather than truncates. TRUNCATE rebuilds every relation
+ * file and syncs it to disk, which measured 590-830ms per call against
+ * Dockerised Postgres; DELETE across the same mostly-empty tables is under a
+ * millisecond. Deletes run children-first so no foreign key is ever violated.
  */
 
 const silentLogger = createLogger({ level: 'error', transports: [] })
 
 export interface TestDatabase extends DatabaseConnection {
-  /** Empties every table. Cheaper than re-running migrations between tests. */
+  /** Empties every table. Cheaper than truncating or re-migrating between tests. */
   readonly truncateAll: () => Promise<void>
 }
 
 /**
  * Reads the test database location. Integration tests are skipped rather than
  * failed when it is absent, so `npm test` still works without Postgres running.
+ *
+ * Inside a Vitest worker the configured name gains the worker's pool id, so
+ * every worker owns its own database and test files can run in parallel.
+ * `connectTestDatabase` creates and migrates a missing database on first use.
  */
 export function testDatabaseUrl(environment: Environment): string | undefined {
-  return environment.TEST_DATABASE_URL
+  const configured = environment.TEST_DATABASE_URL
+  const poolId = environment.VITEST_POOL_ID
+
+  if (configured === undefined || poolId === undefined) {
+    return configured
+  }
+
+  const url = new URL(configured)
+  url.pathname = `${url.pathname}_${poolId}`
+  return url.toString()
 }
 
 /**
@@ -85,10 +103,18 @@ export async function connectTestDatabase(connectionString: string): Promise<Tes
 
   await runMigrations(connection.db, contributions.schemas, silentLogger)
 
-  async function truncateAll(): Promise<void> {
+  let cachedReset: string | undefined
+
+  /**
+   * Builds one `DO` block that deletes from every table, each table after
+   * every table that references it, so a plain DELETE never trips a foreign
+   * key. Built once per connection: the table set only changes with the
+   * migrations, which already ran.
+   */
+  async function buildResetStatement(): Promise<string | undefined> {
     // Names come from the catalog, not from user input, and every migrations
-    // table is excluded so truncation does not undo the migration record.
-    const rows = await connection.db.execute<{ table_name: string }>(sql`
+    // table is excluded so the reset does not undo the migration record.
+    const tables = await connection.db.execute<{ table_name: string }>(sql`
       select table_name
       from information_schema.tables
       where table_schema = 'public'
@@ -96,13 +122,73 @@ export async function connectTestDatabase(connectionString: string): Promise<Tes
         and table_name not like '\\_\\_drizzle\\_%'
     `)
 
-    const names = [...rows].map((row) => `"${row.table_name}"`)
+    const names = [...tables].map((row) => row.table_name)
 
     if (names.length === 0) {
-      return
+      return undefined
+    }
+
+    // Distinct pairs, so two foreign keys between the same tables do not
+    // count twice. Self-references are dropped: deleting every row of a table
+    // in one statement satisfies its own constraint.
+    const references = await connection.db.execute<{ child: string; parent: string }>(sql`
+      select distinct child.relname as child, parent.relname as parent
+      from pg_constraint con
+      join pg_class child on child.oid = con.conrelid
+      join pg_class parent on parent.oid = con.confrelid
+      where con.contype = 'f'
+        and con.connamespace = 'public'::regnamespace
+        and con.conrelid <> con.confrelid
+    `)
+
+    const included = new Set(names)
+    const parentsOf = new Map<string, string[]>()
+    const inboundReferences = new Map<string, number>(names.map((name) => [name, 0]))
+
+    for (const { child, parent } of references) {
+      if (!included.has(child) || !included.has(parent)) {
+        continue
+      }
+
+      parentsOf.set(child, [...(parentsOf.get(child) ?? []), parent])
+      inboundReferences.set(parent, (inboundReferences.get(parent) ?? 0) + 1)
     }
 
-    await connection.db.execute(sql.raw(`truncate table ${names.join(', ')} restart identity cascade`))
+    // Kahn's algorithm. A table joins the order once every table referencing
+    // it is already in it, which is exactly when deleting from it is safe.
+    const ordered = names.filter((name) => inboundReferences.get(name) === 0)
+
+    for (let index = 0; index < ordered.length; index += 1) {
+      const table = ordered[index]
+
+      if (table === undefined) {
+        continue
+      }
+
+      for (const parent of parentsOf.get(table) ?? []) {
+        const remaining = (inboundReferences.get(parent) ?? 0) - 1
+        inboundReferences.set(parent, remaining)
+
+        if (remaining === 0) {
+          ordered.push(parent)
+        }
+      }
+    }
+
+    if (ordered.length !== names.length) {
+      throw new Error('cannot order the table deletes: the foreign keys form a cycle')
+    }
+
+    const deletes = ordered.map((name) => `delete from "${name.replace(/"/gu, '""')}";`).join(' ')
+    return `do $reset$ begin ${deletes} end $reset$;`
+  }
+
+  async function truncateAll(): Promise<void> {
+    cachedReset ??= await buildResetStatement()
+
+    if (cachedReset !== undefined) {
+      await connection.db.execute(sql.raw(cachedReset))
+    }
   }
 
   return { ...connection, truncateAll }