@kelpie/server 0.6.0 → 0.7.0

package/migrations/meta/_journal.json

@@ -134,6 +134,20 @@
       "when": 1786656430307,
       "tag": "0018_hard_mystique",
       "breakpoints": true
+    },
+    {
+      "idx": 19,
+      "version": "7",
+      "when": 1787446086593,
+      "tag": "0019_sharp_red_skull",
+      "breakpoints": true
+    },
+    {
+      "idx": 20,
+      "version": "7",
+      "when": 1787447911296,
+      "tag": "0020_early_nemesis",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kelpie/server",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "The Kelpie service as a library: module runtime, core CRM modules, REST API, MCP surface, and the shared migration pipeline.",
   "keywords": [
     "kelpie",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@hono/node-server": "^2.0.12",
-    "@kelpie/schemas": "^0.6.0",
+    "@kelpie/schemas": "^0.7.0",
     "@node-rs/argon2": "^2.0.2",
     "drizzle-orm": "^0.45.2",
     "emittery": "^2.0.0",

package/src/app.ts

@@ -2,6 +2,7 @@ import { Hono } from 'hono'
 import type { Context } from 'hono'
 import { cors } from 'hono/cors'
 
+import type { RuntimeMode } from './lib/config.ts'
 import type { DatabaseProbe } from './lib/database.ts'
 import { AppError, internalErrorBody, toErrorBody } from './lib/errors.ts'
 import { PUBLIC_ROUTE_PREFIX } from './lib/http.ts'
@@ -51,6 +52,18 @@ export interface AppDependencies {
    * control (`testing/app.ts`).
    */
   readonly resolveClientIp: (context: Context) => string
+  /**
+   * Reported through `GET /v1/public/config` so the browser knows which
+   * runtime it is talking to. Defaults to `'production'` so a caller that has
+   * not thought about it fails safe: no banner shows.
+   */
+  readonly runtimeMode?: RuntimeMode
+  /**
+   * Reported through `GET /v1/public/config` so a non-production UI can name
+   * the site it is on. Undefined is fine and means "this deployment did not
+   * name itself".
+   */
+  readonly siteName?: string | undefined
 }
 
 /** Per-request values the middleware chain sets and handlers read. */
@@ -161,6 +174,19 @@ export function createApp(dependencies: AppDependencies): Hono<AppBindings> {
     app.route(PUBLIC_ROUTE_PREFIX, router)
   }
 
+  // Public deployment metadata the browser reads once at boot. Sits under the
+  // public prefix so the CORS and rate-limit layers above cover it, and takes
+  // no credentials for the same reason /healthz does not: the pages that read
+  // it include the sign-in page, which runs before any session exists. The
+  // runtime mode is already visible in error messages, and the site name
+  // exists to be visible; nothing here is sensitive.
+  const runtimeMode: RuntimeMode = dependencies.runtimeMode ?? 'production'
+  const siteName = dependencies.siteName ?? null
+
+  app.get(`${PUBLIC_ROUTE_PREFIX}/config`, (context) =>
+    context.json({ runtime_mode: runtimeMode, site_name: siteName }, 200),
+  )
+
   for (const { router } of dependencies.contributions.routers) {
     app.route('/v1', router)
   }

package/src/boot.ts

@@ -0,0 +1,89 @@
+import type { Environment, KelpieConfig } from './lib/config.ts'
+import { connectDatabase } from './lib/database.ts'
+import type { DatabaseConnection } from './lib/database.ts'
+import { createIdFactory } from './lib/ids.ts'
+import type { IdFactory } from './lib/ids.ts'
+import { resolveKelpieConfig } from './lib/kelpieConfigFile.ts'
+import type { KelpieConfigInput } from './lib/kelpieConfigFile.ts'
+import { createLogger, createTransportForDestination } from './lib/logger.ts'
+import type { Logger } from './lib/logger.ts'
+import { readModuleConfigFile } from './lib/moduleConfig.ts'
+import { resolveActorFrom } from './modules/auth/credentials.ts'
+import type { CredentialDependencies } from './modules/auth/credentials.ts'
+import { createEventBus } from './runtime/events.ts'
+import { registerModules } from './runtime/registry.ts'
+import type { ModuleContributions } from './runtime/registry.ts'
+import { createTransactionScope } from './runtime/transaction.ts'
+
+/**
+ * A resolved assembly: config parsed, database connected, modules registered.
+ *
+ * This is the common prelude every entry point needs before it does its own
+ * work. `server.ts` goes on to build the app and serve; `migrate.ts` goes on to
+ * apply migrations and exit. Both start here, so the wiring lives in one place
+ * rather than drifting between two copies.
+ *
+ * The database is connected but not opened: postgres.js connects lazily, and
+ * registration issues no query, so a caller that only needs the contributions
+ * pays for no connection. The caller owns `database.close()`.
+ */
+export interface AssemblyBoot {
+  readonly config: KelpieConfig
+  readonly logger: Logger
+  readonly database: DatabaseConnection
+  readonly createId: IdFactory
+  readonly credentials: CredentialDependencies
+  readonly contributions: ModuleContributions
+}
+
+/**
+ * Resolves an assembly's config, connects the database, and runs the module
+ * registration pass.
+ *
+ * Registration touches no database. It only collects what the modules
+ * contribute, migrations directories included, which is why an entry point can
+ * call this and then decide whether to serve, migrate, or both.
+ *
+ * @throws ConfigurationError when a required variable is missing or malformed.
+ * @throws ModuleConfigFileError when the module override file cannot be read.
+ * @throws ModuleBootError when the module list is invalid or a module fails to
+ *   register. The caller maps these to a fix hint and an exit code.
+ */
+export async function bootAssembly(
+  kelpieConfig: KelpieConfigInput,
+  environment: Environment,
+): Promise<AssemblyBoot> {
+  const config = resolveKelpieConfig(kelpieConfig, environment)
+  const logger = createLogger({
+    level: config.logging.level,
+    transports: config.logging.destinations.map(createTransportForDestination),
+  })
+  const database = connectDatabase(config.databaseUrl, logger)
+  const events = createEventBus(logger)
+  const createId = createIdFactory()
+  const credentials: CredentialDependencies = { db: database.db, now: () => new Date() }
+  const moduleConfig = readModuleConfigFile(config.moduleConfigPath)
+  const contributions = await registerModules({
+    modules: kelpieConfig.modules,
+    environment: config.env,
+    logger,
+    events,
+    moduleConfig,
+    resolveActor: (context) => resolveActorFrom(credentials, context),
+    services: {
+      db: database.db,
+      transaction: createTransactionScope({ db: database.db, bus: events, logger, createId }),
+      createId,
+      now: () => new Date(),
+      appBaseUrl: config.appBaseUrl,
+      secretEncryption: config.secretEncryption,
+    },
+    // `provider` picks a named sender from the runtime's registry. `'log'` is
+    // built in; `'smtp'` is registered by the built-in `smtp-email` core
+    // module; other names come from third-party provider modules listed in
+    // `kelpie.config.ts`. `from` is the address on every outgoing message.
+    email: { provider: config.email.EMAIL_PROVIDER, from: config.email.EMAIL_FROM },
+  })
+
+  return { config, logger, database, createId, credentials, contributions }
+}

package/src/index.ts

@@ -1,6 +1,14 @@
+// Carries each module's `KelpieEventMap` augmentation into the emitted
+// `index.d.ts` so consumers installed from npm get a typed `event.data`. See
+// `modules/eventCatalogs.ts` for why the entry point has to reference them.
+import './modules/eventCatalogs.ts'
+
 export { createApp } from './app.ts'
 export type { AppDependencies, AppBindings } from './app.ts'
 
+export { bootAssembly } from './boot.ts'
+export type { AssemblyBoot } from './boot.ts'
+
 export { WebBundleError, serveWebBundle } from './webBundle.ts'
 export type { WebBundleOptions } from './webBundle.ts'
 

package/src/lib/config.ts

@@ -39,6 +39,13 @@ export interface KelpieConfig {
   readonly runtimeMode: RuntimeMode
   readonly port: number
   readonly databaseUrl: string
+  /**
+   * Human-readable name of this deployment ("dev", "demo", "cloud", or
+   * whatever the self-hoster picks). Undefined is normal. Exposed to the
+   * browser through `GET /v1/public/config` so a non-production UI can name
+   * the site it is on. Ignored when `runtimeMode` is `production`.
+   */
+  readonly siteName: string | undefined
   readonly logging: LoggingConfig
   /**
    * The provider name the module runtime looks up in its registry, and the
@@ -119,6 +126,7 @@ const environmentSchema = z.object({
     .refine(isPostgresUrl, { message: 'must be a postgres:// or postgresql:// connection string' }),
   LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']),
   KELPIE_MODULE_CONFIG_PATH: z.string().min(1).optional(),
+  KELPIE_SITE_NAME: z.string().min(1).optional(),
   WEB_BUNDLE_DIR: z.string().min(1).optional(),
   TRUSTED_PROXY_HOP_COUNT: z.coerce.number().int().nonnegative().default(0),
   ...rateLimitConfigSchema.shape,
@@ -156,6 +164,7 @@ export function loadConfig(environment: Environment): KelpieConfig {
     },
     email: emailResult.data,
     moduleConfigPath: environmentResult.data.KELPIE_MODULE_CONFIG_PATH,
+    siteName: environmentResult.data.KELPIE_SITE_NAME,
     webBundleDirectory: environmentResult.data.WEB_BUNDLE_DIR,
     rateLimit: rateLimitConfigFrom(environmentResult.data),
     trustedProxyHopCount: environmentResult.data.TRUSTED_PROXY_HOP_COUNT,

package/src/lib/kelpieConfigFile.ts

@@ -27,6 +27,12 @@ export interface KelpieConfigInput {
   readonly webBundleDirectory?: ConfigValue<string | undefined>
   /** Optional; unset in development, set to the deploy-time module override file. */
   readonly moduleConfigPath?: ConfigValue<string | undefined>
+  /**
+   * Human-readable name of this deployment ("dev", "demo", "cloud"). Optional.
+   * Read by the browser through `GET /v1/public/config` so a non-production UI
+   * can name the site it is on. Ignored when `runtimeMode` is `production`.
+   */
+  readonly siteName?: ConfigValue<string | undefined>
   /** Optional; defaults to 0 (no proxy in front). */
   readonly trustedProxyHopCount?: ConfigValue<number>
   /**
@@ -173,6 +179,7 @@ export function resolveKelpieConfig(input: KelpieConfigInput, environment: Envir
     },
     email,
     moduleConfigPath: resolved.moduleConfigPath,
+    siteName: resolved.siteName,
     webBundleDirectory: resolved.webBundleDirectory,
     rateLimit,
     trustedProxyHopCount: resolved.trustedProxyHopCount ?? 0,
@@ -208,6 +215,7 @@ interface ResolvedInput {
   }
   readonly webBundleDirectory?: string | undefined
   readonly moduleConfigPath?: string | undefined
+  readonly siteName?: string | undefined
   readonly trustedProxyHopCount?: number
   readonly appBaseUrl?: string
   readonly secretEncryption?: ResolvedSecretEncryption

package/src/modules/eventCatalogs.ts

@@ -0,0 +1,35 @@
+/**
+ * Loads every core module's `KelpieEventMap` augmentation at the package entry.
+ *
+ * Each module declares its event payload types in `<module>/events.ts` through
+ * `declare module '../../runtime/events.ts'`. Inside the monorepo those merge
+ * because the source graph reaches every file. A consumer that installs
+ * `@kelpie/server` from npm typechecks against `dist`, and declaration emit
+ * keeps only the imports a file actually references. Nothing in `dist/index.d.ts`
+ * referenced the per-module `events.d.ts` files, so `KelpieEventMap` stayed empty
+ * for consumers and every `subscribe` handler saw `event.data: unknown`.
+ *
+ * These side-effect imports give `index.ts` one reference into each catalog. The
+ * emitted `index.d.ts` carries them, so a consumer loads the augmentations and
+ * gets a typed `event.data` without a cast at the read site.
+ *
+ * List only modules whose `events.ts` augments `KelpieEventMap`. A module that
+ * publishes no events has no `events.ts` and does not belong here. Order mirrors
+ * `coreModules` in `core.ts` for readability; it has no runtime effect.
+ */
+
+import './workspace/events.ts'
+import './people/events.ts'
+import './companies/events.ts'
+import './positions/events.ts'
+import './notes/events.ts'
+import './deals/events.ts'
+import './opportunities/events.ts'
+import './partnerships/events.ts'
+import './raises/events.ts'
+import './hiring/events.ts'
+import './plans/events.ts'
+import './decisions/events.ts'
+import './handbook/events.ts'
+import './forms/events.ts'
+import './import-export/events.ts'

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

@@ -174,6 +174,33 @@ export function personDraft(mapped: Readonly<Record<string, string>>): PersonDra
   })
 }
 
+/**
+ * The company a People row's affiliation would create.
+ *
+ * Built from the row's `company_domain` and `company_name` cells, not the
+ * `name`/`domain` a Companies file uses. The name falls back to the raw domain
+ * so a create from a domain-only row is not a nameless company. The write lays
+ * `NEW_COMPANY_DEFAULTS` over this, the same as a Companies import.
+ */
+export function affiliationCompanyDraft(mapped: Readonly<Record<string, string>>): CompanyDraft {
+  const domainRaw = text(mapped, 'company_domain')
+
+  return present<CompanyDraft>({
+    name: text(mapped, 'company_name') ?? domainRaw,
+    domain: domainRaw === undefined ? undefined : (normaliseDomain(domainRaw) ?? undefined),
+    industry: undefined,
+    description: undefined,
+    stage: undefined,
+    sizeBand: undefined,
+    hq: undefined,
+    website: undefined,
+    accountType: undefined,
+    icpFit: undefined,
+    summary: undefined,
+    tags: undefined,
+  })
+}
+
 /**
  * `value` is required, so `moneyToCents` has already been checked by
  * `validateRow` and cannot be undefined here.

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

@@ -26,8 +26,17 @@ function joinList(values: readonly string[]): string {
   return values.join('|')
 }
 
+/**
+ * The header row of an export and of a template.
+ *
+ * `importOnly` columns are left out: a People import may map `company_domain`,
+ * `company_name` and `title` to drive a Position, but a person holds many
+ * positions and none of them is a field on the person. Writing one on the export
+ * would be lossy, so the export and the template carry the round-trippable
+ * columns only, and each cell function matches this order one for one.
+ */
 export function headersFor(object: ImportObject): readonly string[] {
-  return OBJECT_COLUMNS[object].map((column) => column.key)
+  return OBJECT_COLUMNS[object].filter((column) => column.importOnly !== true).map((column) => column.key)
 }
 
 export function companyCells(row: ExportCompanyRow): readonly string[] {

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

@@ -3,10 +3,11 @@ import type {
   ImportCounts,
   ImportObject,
   MatchKeyOption,
+  OnMissingCompany,
 } from '@kelpie/schemas'
 
 import { normaliseDomain, normaliseEmail } from '../../lib/normalisation.ts'
-import { companyDraft, dealFieldsDraft, personDraft } from './drafts.ts'
+import { affiliationCompanyDraft, companyDraft, dealFieldsDraft, personDraft } from './drafts.ts'
 import type { CompanyDraft, DealFieldsDraft, PersonDraft } from './drafts.ts'
 import { buildMatchKey, splitList } from './mapping.ts'
 import { aliasedStageSlug } from './presets.ts'
@@ -29,6 +30,8 @@ export interface ImportLookups {
   readonly existing: ReadonlyMap<string, string>
   readonly personIdByEmail: ReadonlyMap<string, string>
   readonly companyIdByDomain: ReadonlyMap<string, string>
+  /** Company id by its folded name, for a People affiliation matched by name. */
+  readonly companyIdByName: ReadonlyMap<string, string>
   /** Workspace member id by the address of the user behind it. */
   readonly memberIdByEmail: ReadonlyMap<string, string>
   /** Deal stage id, keyed by both its slug and its folded label. */
@@ -39,13 +42,28 @@ export interface PlanContext {
   readonly object: ImportObject
   readonly matchKey: MatchKeyOption
   readonly conflictMode: ImportConflictMode
+  /** What a People row does with an absent company. Ignored by the other objects. */
+  readonly onMissingCompany: OnMissingCompany
   readonly lookups: ImportLookups
 }
 
+/**
+ * A company affiliation a People row asks for: the position to write, and
+ * whether the company must be created before it can be linked.
+ */
+export type PlannedAffiliation =
+  | { readonly kind: 'link'; readonly companyId: string; readonly title: string }
+  | { readonly kind: 'create'; readonly company: CompanyDraft; readonly title: string }
+
 /** The values a write applies, once every reference in the row has been resolved. */
 export type ImportWrite =
   | { readonly object: 'companies'; readonly draft: CompanyDraft }
-  | { readonly object: 'people'; readonly draft: PersonDraft }
+  | {
+      readonly object: 'people'
+      readonly draft: PersonDraft
+      /** A position to upsert alongside the person, when the row named a company and a title. */
+      readonly affiliation?: PlannedAffiliation
+    }
   | {
       readonly object: 'positions'
       readonly personId: string
@@ -78,12 +96,19 @@ export type RowPlan =
    * reaches the row the earlier one has been written, so it resolves to an id.
    */
   | { readonly action: 'skip'; readonly key: string; readonly targetId: string | null }
-  | { readonly action: 'create'; readonly key: string; readonly write: ImportWrite }
+  | {
+      readonly action: 'create'
+      readonly key: string
+      readonly write: ImportWrite
+      /** Non-fatal notes about the applied row, e.g. a People affiliation left unlinked. */
+      readonly warnings?: readonly StoredRowError[]
+    }
   | {
       readonly action: 'update'
       readonly key: string
       readonly targetId: string | null
       readonly write: ImportWrite
+      readonly warnings?: readonly StoredRowError[]
     }
 
 export interface PlannedRow {
@@ -233,6 +258,80 @@ function resolveWrite(context: PlanContext, mapped: Readonly<Record<string, stri
   }
 }
 
+/**
+ * The company affiliation a People row asks for, if any, and any note about it.
+ *
+ * A row states an affiliation only when it carries both a title and a company
+ * identity, so a blank optional cell still says nothing, the additive rule every
+ * column follows. The company is matched by domain when the row has one and by
+ * name otherwise. A named company that is not here follows `on_missing_company`:
+ * `create` invents it from the row, `skip` imports the person alone and returns
+ * a warning.
+ */
+function planAffiliation(
+  context: PlanContext,
+  mapped: Readonly<Record<string, string>>,
+): { readonly affiliation?: PlannedAffiliation; readonly warnings: readonly StoredRowError[] } {
+  const title = (mapped.title ?? '').trim()
+  const domainRaw = (mapped.company_domain ?? '').trim()
+  const nameRaw = (mapped.company_name ?? '').trim()
+
+  if (title.length === 0 || (domainRaw.length === 0 && nameRaw.length === 0)) {
+    return { warnings: [] }
+  }
+
+  const domain = normaliseDomain(domainRaw)
+  const companyId =
+    domainRaw.length > 0
+      ? domain === null
+        ? undefined
+        : context.lookups.companyIdByDomain.get(domain)
+      : context.lookups.companyIdByName.get(nameRaw.toLowerCase())
+
+  if (companyId !== undefined) {
+    return { affiliation: { kind: 'link', companyId, title }, warnings: [] }
+  }
+
+  if (context.onMissingCompany === 'create') {
+    return {
+      affiliation: { kind: 'create', company: affiliationCompanyDraft(mapped), title },
+      warnings: [],
+    }
+  }
+
+  const named = domainRaw.length > 0 ? domainRaw : nameRaw
+
+  return {
+    warnings: [
+      {
+        field: domainRaw.length > 0 ? 'company_domain' : 'company_name',
+        message: `No company here matches "${named}", so the person imported without a position`,
+      },
+    ],
+  }
+}
+
+/**
+ * Folds a People row's affiliation into its create or update plan.
+ *
+ * A no-op for every other object, and for a person the row said nothing about a
+ * company for. The affiliation rides on the write; any note rides on the plan.
+ */
+function withAffiliation(
+  context: PlanContext,
+  mapped: Readonly<Record<string, string>>,
+  plan: Extract<RowPlan, { action: 'create' } | { action: 'update' }>,
+): RowPlan {
+  if (context.object !== 'people' || plan.write.object !== 'people') {
+    return plan
+  }
+
+  const { affiliation, warnings } = planAffiliation(context, mapped)
+  const write = affiliation === undefined ? plan.write : { ...plan.write, affiliation }
+
+  return { ...plan, write, ...(warnings.length > 0 ? { warnings } : {}) }
+}
+
 /**
  * @param mapped The row's cells by Kelpie column, from `mapRow`.
  * @returns What this row would do. `create` when its key matches nothing;
@@ -265,15 +364,18 @@ export function planRow(context: PlanContext, mapped: Readonly<Record<string, st
   const targetId = context.lookups.existing.get(key)
 
   if (targetId === undefined) {
-    return { action: 'create', key, write }
+    return withAffiliation(context, mapped, { action: 'create', key, write })
   }
 
   // An empty string is the placeholder an in-file match carries: the record it
   // matched has not been written yet, so there is no id to report.
   const resolved = targetId.length === 0 ? null : targetId
 
+  // A skipped row is left entirely alone, affiliation included. A caller who
+  // wants an existing person's position updated runs the job in `update` mode,
+  // which is where the rename-in-place lives.
   return context.conflictMode === 'update'
-    ? { action: 'update', key, targetId: resolved, write }
+    ? withAffiliation(context, mapped, { action: 'update', key, targetId: resolved, write })
     : { action: 'skip', key, targetId: resolved }
 }
 

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

@@ -31,6 +31,8 @@ export const SOURCE_PRESETS: Readonly<Record<ImportSource, SourcePreset>> = {
       email: 'Email',
       phones: 'Phone Number',
       location: 'City',
+      company_domain: 'Company Domain Name',
+      title: 'Job Title',
     },
     positions: {
       person_email: 'Email',
@@ -60,6 +62,8 @@ export const SOURCE_PRESETS: Readonly<Record<ImportSource, SourcePreset>> = {
       email: 'Email',
       phones: 'Phone',
       location: 'Mailing City',
+      company_name: 'Account Name',
+      title: 'Title',
     },
     positions: {
       person_email: 'Email',
@@ -76,6 +80,27 @@ export const SOURCE_PRESETS: Readonly<Record<ImportSource, SourcePreset>> = {
       external_id: 'Opportunity ID',
     },
   },
+  attio: {
+    // Attio's export writes one column per attribute, and a linked or nested
+    // attribute as `Parent > Child`. Only Companies and People are mapped: the
+    // sample export carries no Deals or Positions file, and an Attio People row
+    // names its company but not the company's domain, so a Position could not be
+    // keyed from it. Those objects fall back to `custom`.
+    companies: {
+      name: 'Record',
+      domain: 'Domains',
+      industry: 'Categories',
+      description: 'Description',
+      hq: 'Primary location > Country',
+    },
+    people: {
+      name: 'Record',
+      email: 'Email addresses',
+      location: 'Primary location > Country',
+      company_name: 'Company > Name',
+      title: 'Job title',
+    },
+  },
 }
 
 /**

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

@@ -175,6 +175,8 @@ export interface RowOutcome {
   readonly rowNumber: number
   readonly action: SettledRowAction
   readonly errors: readonly { readonly field: string; readonly message: string }[]
+  /** Non-fatal notes about a row that was applied anyway, e.g. an unlinked position. */
+  readonly warnings: readonly { readonly field: string; readonly message: string }[]
 }
 
 /**
@@ -202,12 +204,18 @@ export async function recordRowOutcome(
       values,
       action: outcome.action,
       errors: outcome.errors,
+      warnings: outcome.warnings,
       createdAt: now,
       updatedAt: now,
     })
     .onConflictDoUpdate({
       target: [importJobRows.jobId, importJobRows.rowNumber],
-      set: { action: outcome.action, errors: outcome.errors, updatedAt: now },
+      set: {
+        action: outcome.action,
+        errors: outcome.errors,
+        warnings: outcome.warnings,
+        updatedAt: now,
+      },
     })
 }
 
@@ -381,6 +389,32 @@ export function findCompanyIdsByDomain(
   )
 }
 
+/**
+ * Company ids by folded name, for a People affiliation matched on a company
+ * name rather than a domain.
+ *
+ * `lower(name) in (…)` rather than `ilike`, so a `%` inside a caller-supplied
+ * name is a literal, not a wildcard. The same rule `findCompanyKeys` follows.
+ * The caller passes names already lowercased.
+ */
+export function findCompanyIdsByName(
+  db: Queryable,
+  workspaceId: string,
+  names: readonly string[],
+): Promise<{ name: string; id: string }[]> {
+  return overChunks(names, (chunk) =>
+    db
+      .select({ id: companies.id, name: companies.name })
+      .from(companies)
+      .where(
+        and(
+          eq(companies.workspaceId, workspaceId),
+          inArray(sql<string>`lower(${companies.name})`, [...chunk]),
+        ),
+      ),
+  )
+}
+
 /** Every member of the workspace, by the address of the user behind them. */
 export function listMemberEmails(
   db: Queryable,

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

@@ -3,6 +3,7 @@ import {
   IMPORT_OBJECTS,
   IMPORT_SOURCES,
   MAX_IMPORT_FILE_BYTES,
+  ON_MISSING_COMPANY,
   defaultMatchKeyId,
 } from '@kelpie/schemas'
 import type { ImportColumnMap, ImportObject } from '@kelpie/schemas'
@@ -42,6 +43,7 @@ const createJobForm = z.object({
   source: z.enum(IMPORT_SOURCES),
   object: z.enum(IMPORT_OBJECTS),
   conflict_mode: z.enum(IMPORT_CONFLICT_MODES).default('skip'),
+  on_missing_company: z.enum(ON_MISSING_COMPANY).default('skip'),
   match_key: z.string().min(1).optional(),
   column_map: z.string().optional(),
   dry_run: z.enum(['true', 'false']).default('true'),
@@ -58,12 +60,14 @@ export function importJobResponse(job: ImportJobView): Record<string, unknown> {
     object: job.object,
     status: job.status,
     conflict_mode: job.conflictMode,
+    on_missing_company: job.onMissingCompany,
     match_key: job.matchKey,
     column_map: job.columnMap,
     source_headers: job.sourceHeaders,
     file_name: job.fileName,
     counts: job.counts,
     errors: job.errors,
+    warnings: job.warnings,
     preview: job.preview,
     created_at: job.createdAt.toISOString(),
     updated_at: job.updatedAt.toISOString(),
@@ -230,6 +234,7 @@ export function mountImportExportRoutes(
       source: parsed.data.source,
       object: parsed.data.object,
       conflictMode: parsed.data.conflict_mode,
+      onMissingCompany: parsed.data.on_missing_company,
       matchKeyId: parsed.data.match_key ?? defaultMatchKeyId(parsed.data.object),
       columnMap: readColumnMap(parsed.data.column_map),
       fileName: file.name.length === 0 ? null : file.name,