@kelpie/server 0.12.0 → 0.14.0

package/src/modules/forms/fillAddresses.ts

@@ -0,0 +1,185 @@
+import {
+  COMPANY_ADDRESS_KINDS,
+  PERSON_ADDRESS_KINDS,
+  normaliseCountry,
+} from '@kelpie/schemas'
+import type { CompanyAddress, PersonAddress } from '@kelpie/schemas'
+
+import { fillBlank } from './mapping.ts'
+
+/**
+ * Compose one address from `*.address.*` form answers and fill-blank it onto
+ * the stored list. Default kind is mailing on a Person and hq on a Company.
+ * An existing address of that kind keeps any part it already has.
+ */
+
+const ADDRESS_PART_FIELDS = ['line1', 'line2', 'city', 'region', 'postal_code', 'country'] as const
+
+type AddressPartField = (typeof ADDRESS_PART_FIELDS)[number]
+
+function readPart(
+  standard: Readonly<Record<string, string>>,
+  field: AddressPartField,
+): string | undefined {
+  const raw = standard[`address.${field}`]
+
+  if (raw === undefined) {
+    return undefined
+  }
+
+  const trimmed = raw.trim()
+
+  return trimmed.length === 0 ? undefined : trimmed
+}
+
+function hasAddressAnswers(standard: Readonly<Record<string, string>>): boolean {
+  if (standard['address.kind'] !== undefined && standard['address.kind'].trim().length > 0) {
+    return true
+  }
+
+  return ADDRESS_PART_FIELDS.some((field) => readPart(standard, field) !== undefined)
+}
+
+function resolveCountry(raw: string | undefined): string | null | undefined {
+  if (raw === undefined) {
+    return undefined
+  }
+
+  return normaliseCountry(raw)
+}
+
+function fillPart(stored: string | null, inbound: string | undefined): string | null {
+  const filled = fillBlank(stored, inbound)
+
+  return filled === undefined ? stored : filled
+}
+
+function mergeAddress<Kind extends string>(
+  stored: { readonly line1: string | null; readonly line2: string | null; readonly city: string | null; readonly region: string | null; readonly postalCode: string | null; readonly country: string | null } | undefined,
+  inbound: {
+    readonly line1: string | undefined
+    readonly line2: string | undefined
+    readonly city: string | undefined
+    readonly region: string | undefined
+    readonly postalCode: string | undefined
+    readonly country: string | null | undefined
+  },
+  kind: Kind,
+  primary: boolean,
+): {
+  readonly kind: Kind
+  readonly line1: string | null
+  readonly line2: string | null
+  readonly city: string | null
+  readonly region: string | null
+  readonly postalCode: string | null
+  readonly country: string | null
+  readonly primary: boolean
+} {
+  const empty = {
+    line1: null,
+    line2: null,
+    city: null,
+    region: null,
+    postalCode: null,
+    country: null,
+  }
+  const base = stored ?? empty
+
+  return {
+    kind,
+    line1: fillPart(base.line1, inbound.line1),
+    line2: fillPart(base.line2, inbound.line2),
+    city: fillPart(base.city, inbound.city),
+    region: fillPart(base.region, inbound.region),
+    postalCode: fillPart(base.postalCode, inbound.postalCode),
+    country: inbound.country === undefined ? base.country : fillPart(base.country, inbound.country ?? undefined),
+    primary,
+  }
+}
+
+function hasLocation(address: {
+  readonly line1: string | null
+  readonly line2: string | null
+  readonly city: string | null
+  readonly region: string | null
+  readonly postalCode: string | null
+  readonly country: string | null
+}): boolean {
+  return (
+    address.line1 !== null ||
+    address.line2 !== null ||
+    address.city !== null ||
+    address.region !== null ||
+    address.postalCode !== null ||
+    address.country !== null
+  )
+}
+
+function fillTypedAddress<Kind extends string>(
+  stored: readonly {
+    readonly kind: Kind
+    readonly line1: string | null
+    readonly line2: string | null
+    readonly city: string | null
+    readonly region: string | null
+    readonly postalCode: string | null
+    readonly country: string | null
+    readonly primary: boolean
+  }[],
+  standard: Readonly<Record<string, string>>,
+  kinds: readonly Kind[],
+  defaultKind: Kind,
+): readonly {
+  readonly kind: Kind
+  readonly line1: string | null
+  readonly line2: string | null
+  readonly city: string | null
+  readonly region: string | null
+  readonly postalCode: string | null
+  readonly country: string | null
+  readonly primary: boolean
+}[] | undefined {
+  if (!hasAddressAnswers(standard)) {
+    return undefined
+  }
+
+  const requested = (standard['address.kind'] ?? '').trim()
+  const kind = kinds.includes(requested as Kind) ? (requested as Kind) : defaultKind
+  const inbound = {
+    line1: readPart(standard, 'line1'),
+    line2: readPart(standard, 'line2'),
+    city: readPart(standard, 'city'),
+    region: readPart(standard, 'region'),
+    postalCode: readPart(standard, 'postal_code'),
+    country: resolveCountry(readPart(standard, 'country')),
+  }
+
+  const existing = stored.find((address) => address.kind === kind)
+  const merged = mergeAddress(existing, inbound, kind, existing?.primary ?? stored.length === 0)
+
+  if (!hasLocation(merged)) {
+    return undefined
+  }
+
+  if (existing === undefined) {
+    const next = stored.map((address) => (merged.primary ? { ...address, primary: false } : address))
+    return [...next, merged]
+  }
+
+  return stored.map((address) => (address.kind === kind ? merged : address))
+}
+
+export function fillPersonAddresses(
+  stored: readonly PersonAddress[],
+  standard: Readonly<Record<string, string>>,
+): readonly PersonAddress[] | undefined {
+  return fillTypedAddress(stored, standard, PERSON_ADDRESS_KINDS, 'mailing')
+}
+
+export function fillCompanyAddresses(
+  stored: readonly CompanyAddress[],
+  standard: Readonly<Record<string, string>>,
+): readonly CompanyAddress[] | undefined {
+  return fillTypedAddress(stored, standard, COMPANY_ADDRESS_KINDS, 'hq')
+}

package/src/modules/forms/repository.ts

@@ -1,7 +1,7 @@
 import { and, asc, eq, ilike, inArray, or } from 'drizzle-orm'
 import type { SQL } from 'drizzle-orm'
 import type { AnyPgColumn } from 'drizzle-orm/pg-core'
-import type { FormSubmissionLinkTarget, PipelineKind } from '@kelpie/schemas'
+import type { FormSubmissionLinkTarget, FormAttachTargetType } from '@kelpie/schemas'
 
 import { keysetCondition, orderByWindow, textSort, timestampSort } from '../../lib/pagination.ts'
 import type { ListWindow, SortableFields } from '../../lib/pagination.ts'
@@ -332,7 +332,7 @@ export async function replaceFormLists(
 
 /** One form's configured attach targets, ordered so a resent identical set is not a write. */
 export interface FormAttachTargetRow {
-  readonly targetType: PipelineKind
+  readonly targetType: FormAttachTargetType
   readonly targetId: string
 }
 
@@ -347,7 +347,7 @@ export async function listAttachTargets(
     .orderBy(asc(formAttachTargets.targetType), asc(formAttachTargets.targetId))
 
   return rows.map((row) => ({
-    targetType: row.targetType as PipelineKind,
+    targetType: row.targetType as FormAttachTargetType,
     targetId: row.targetId,
   }))
 }

package/src/modules/forms/routes.ts

@@ -1,6 +1,6 @@
 import type { Context, Hono } from 'hono'
 import { z } from 'zod'
-import { FORM_SUBMISSION_LINK_TARGETS, PIPELINE_KINDS } from '@kelpie/schemas'
+import { FORM_ATTACH_TARGET_TYPES, FORM_SUBMISSION_LINK_TARGETS } from '@kelpie/schemas'
 import type { FormAttachTarget, FormSubmissionLinkTarget } from '@kelpie/schemas'
 
 import { AppError } from '../../lib/errors.ts'
@@ -59,7 +59,7 @@ const fieldBody = z.strictObject({
 })
 
 const attachTargetBody = z.strictObject({
-  target_type: z.enum(PIPELINE_KINDS),
+  target_type: z.enum(FORM_ATTACH_TARGET_TYPES),
   target_id: z.string().min(1),
 })
 

package/src/modules/forms/schema.ts

@@ -1,7 +1,7 @@
 import {
+  FORM_ATTACH_TARGET_TYPES,
   FORM_FIELD_TYPES,
   FORM_STATUSES,
-  PIPELINE_KINDS,
 } from '@kelpie/schemas'
 import type { FormOptionValueType, FormSubmissionActionEntry } from '@kelpie/schemas'
 import { boolean, index, integer, jsonb, pgTable, primaryKey, text } from 'drizzle-orm/pg-core'
@@ -187,7 +187,7 @@ export const formAttachTargets = pgTable(
       table.targetType,
       table.targetId,
     ),
-    checkOneOf('form_attach_targets_target_type_check', table.targetType, PIPELINE_KINDS),
+    checkOneOf('form_attach_targets_target_type_check', table.targetType, FORM_ATTACH_TARGET_TYPES),
   ],
 )
 

package/src/modules/forms/service.ts

@@ -4,7 +4,7 @@ import type {
   FormSubmissionLinkTarget,
   PipelineKind,
 } from '@kelpie/schemas'
-import { PIPELINE_KINDS } from '@kelpie/schemas'
+import { FORM_ATTACH_TARGET_TYPES } from '@kelpie/schemas'
 
 import { changedKeys } from '../../lib/changes.ts'
 import type { Database } from '../../lib/database.ts'
@@ -422,7 +422,7 @@ export function createFormsService(dependencies: FormsDependencies): FormsServic
 
     const problems: { field: string; message: string }[] = []
 
-    for (const kind of PIPELINE_KINDS) {
+    for (const kind of FORM_ATTACH_TARGET_TYPES) {
       const ofKind = targets.filter((target) => target.targetType === kind)
 
       if (ofKind.length === 0) {

package/src/modules/forms/submission.ts

@@ -17,6 +17,8 @@ import * as dealRepository from '../deals/repository.ts'
 import '../deals/events.ts'
 import * as enquiryRepository from '../enquiries/repository.ts'
 import '../enquiries/events.ts'
+import '../events/catalog.ts'
+import * as eventRepository from '../events/repository.ts'
 import '../lists/events.ts'
 import * as listsRepository from '../lists/repository.ts'
 import * as opportunityRepository from '../opportunities/repository.ts'
@@ -1196,18 +1198,46 @@ export function createFormSubmitService(dependencies: SubmissionDependencies): F
             events,
             actionLog,
             `attach:${target.targetType}:${target.targetId}`,
-            async (inner) => {
+            async (inner, emit) => {
+              const targetType = target.targetType
+              const targetId = target.targetId
+
               // Racing a target delete would fail the FK-less insert with the
               // same effect as an existence check: log an error, continue.
-              if (!(await targetExists(inner, workspaceId, target.targetType, target.targetId))) {
-                throw AppError.notFound(`${target.targetType} ${target.targetId} not found`)
+              if (!(await targetExists(inner, workspaceId, targetType, targetId))) {
+                throw AppError.notFound(`${targetType} ${targetId} not found`)
+              }
+
+              if (targetType === 'event') {
+                const { record, inserted } = await eventRepository.insertAttendanceIfAbsent(
+                  inner,
+                  {
+                    id: dependencies.createId('attendance'),
+                    workspaceId,
+                    eventId: targetId,
+                    personId: person.record.id,
+                    status: 'registered',
+                    source: 'form',
+                    createdAt: now,
+                    updatedAt: now,
+                  },
+                )
+
+                if (inserted) {
+                  emit('events.attendance.created', { type: 'attendance', id: record.id }, {})
+                }
+
+                return {
+                  status: 'ok',
+                  detail: inserted ? 'registered' : 'already registered',
+                }
               }
 
               const inserted = await personLinks.linkPersonIfAbsent(
                 inner,
                 dependencies.createId,
                 workspaceId,
-                target,
+                { targetType, targetId },
                 person.record.id,
               )
 

package/src/modules/hiring/roles.ts

@@ -13,7 +13,7 @@ import { toEventActor } from '../../lib/actor.ts'
 import type { Actor } from '../auth/actor.ts'
 import { requireWorkspaceId } from '../auth/actor.ts'
 import './events.ts'
-import { deleteRecordsAttachedTo } from '../attachedRecords.ts'
+import { deleteEventAssociationsForTarget, deleteRecordsAttachedTo } from '../attachedRecords.ts'
 import * as repository from './repository.ts'
 import { DEFAULT_ROLE_SORT, ROLE_SORTS } from './repository.ts'
 import type { RoleFilters, RoleRecord } from './repository.ts'
@@ -162,6 +162,7 @@ export function createRolesService(dependencies: RolesDependencies): RolesServic
           })
         }
 
+        await deleteEventAssociationsForTarget(tx, workspaceId, 'role', id)
         await repository.deleteRole(tx, workspaceId, id)
 
         events.emit('hiring.role.deleted', { type: 'role', id }, {})

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

@@ -0,0 +1,150 @@
+import {
+  ADDRESS_PARTS,
+  addressColumnKey,
+  COMPANY_ADDRESS_KINDS,
+  PERSON_ADDRESS_KINDS,
+} from '@kelpie/schemas'
+import type {
+  AddressPart,
+  CompanyAddress,
+  CompanyAddressKind,
+  PersonAddress,
+  PersonAddressKind,
+  PostalAddress,
+} from '@kelpie/schemas'
+import { normaliseCountry } from '@kelpie/schemas'
+
+/**
+ * Flattened CSV address columns → jsonb addresses, and the reverse for export.
+ *
+ * One group per kind. A group with any non-empty part becomes an address of
+ * that kind. The first non-empty kind in the object's kind order is primary.
+ * An unknown country is a warning and leaves `country` null rather than
+ * failing the row.
+ */
+
+export interface AddressImportWarning {
+  readonly field: string
+  readonly message: string
+}
+
+export interface AddressImportResult<Kind extends string> {
+  readonly addresses: readonly PostalAddress<Kind>[] | undefined
+  readonly warnings: readonly AddressImportWarning[]
+}
+
+const CAMEL_PART: Readonly<Record<AddressPart, 'line1' | 'line2' | 'city' | 'region' | 'postalCode' | 'country'>> =
+  {
+    line1: 'line1',
+    line2: 'line2',
+    city: 'city',
+    region: 'region',
+    postal_code: 'postalCode',
+    country: 'country',
+  }
+
+function cell(mapped: Readonly<Record<string, string>>, key: string): string | undefined {
+  const value = (mapped[key] ?? '').trim()
+
+  return value.length === 0 ? undefined : value
+}
+
+function addressesFromMapped<Kind extends string>(
+  mapped: Readonly<Record<string, string>>,
+  kinds: readonly Kind[],
+): AddressImportResult<Kind> {
+  const warnings: AddressImportWarning[] = []
+  const addresses: PostalAddress<Kind>[] = []
+
+  for (const kind of kinds) {
+    const parts: {
+      line1: string | null
+      line2: string | null
+      city: string | null
+      region: string | null
+      postalCode: string | null
+      country: string | null
+    } = {
+      line1: cell(mapped, addressColumnKey(kind, 'line1')) ?? null,
+      line2: cell(mapped, addressColumnKey(kind, 'line2')) ?? null,
+      city: cell(mapped, addressColumnKey(kind, 'city')) ?? null,
+      region: cell(mapped, addressColumnKey(kind, 'region')) ?? null,
+      postalCode: cell(mapped, addressColumnKey(kind, 'postal_code')) ?? null,
+      country: null,
+    }
+
+    const countryRaw = cell(mapped, addressColumnKey(kind, 'country'))
+
+    if (countryRaw !== undefined) {
+      const code = normaliseCountry(countryRaw)
+
+      if (code === null) {
+        warnings.push({
+          field: addressColumnKey(kind, 'country'),
+          message: `"${countryRaw}" is not a country Kelpie knows. Country left blank`,
+        })
+      } else {
+        parts.country = code
+      }
+    }
+
+    const hasPart = Object.values(parts).some((value) => value !== null)
+
+    if (!hasPart) {
+      continue
+    }
+
+    addresses.push({
+      kind,
+      ...parts,
+      primary: false,
+    })
+  }
+
+  if (addresses.length === 0) {
+    return { addresses: undefined, warnings }
+  }
+
+  return {
+    addresses: addresses.map((address, index) => ({ ...address, primary: index === 0 })),
+    warnings,
+  }
+}
+
+export function personAddressesFromMapped(
+  mapped: Readonly<Record<string, string>>,
+): AddressImportResult<PersonAddressKind> {
+  return addressesFromMapped(mapped, PERSON_ADDRESS_KINDS)
+}
+
+export function companyAddressesFromMapped(
+  mapped: Readonly<Record<string, string>>,
+): AddressImportResult<CompanyAddressKind> {
+  return addressesFromMapped(mapped, COMPANY_ADDRESS_KINDS)
+}
+
+function partValue(address: PostalAddress | undefined, part: AddressPart): string {
+  if (address === undefined) {
+    return ''
+  }
+
+  const value = address[CAMEL_PART[part]]
+
+  return value ?? ''
+}
+
+export function personAddressCells(addresses: readonly PersonAddress[]): readonly string[] {
+  return PERSON_ADDRESS_KINDS.flatMap((kind) => {
+    const address = addresses.find((entry) => entry.kind === kind)
+
+    return ADDRESS_PARTS.map((part) => partValue(address, part))
+  })
+}
+
+export function companyAddressCells(addresses: readonly CompanyAddress[]): readonly string[] {
+  return COMPANY_ADDRESS_KINDS.flatMap((kind) => {
+    const address = addresses.find((entry) => entry.kind === kind)
+
+    return ADDRESS_PARTS.map((part) => partValue(address, part))
+  })
+}

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

@@ -9,9 +9,10 @@ import {
   composeName,
 } from '@kelpie/schemas'
 
-import type { CustomFieldWireValue } from '@kelpie/schemas'
+import type { CompanyAddress, CustomFieldWireValue, PersonAddress } from '@kelpie/schemas'
 
 import { normaliseDomain, normaliseEmail } from '../../lib/normalisation.ts'
+import { companyAddressesFromMapped, personAddressesFromMapped } from './addresses.ts'
 import { moneyToCents, splitList } from './mapping.ts'
 import { canonicalEnum } from './validation.ts'
 
@@ -36,8 +37,7 @@ export interface CompanyDraft {
   readonly description?: string
   readonly stage?: string
   readonly sizeBand?: string
-  readonly hq?: string
-  readonly website?: string
+  readonly addresses?: readonly CompanyAddress[]
   readonly accountType?: string
   readonly icpFit?: string
   readonly summary?: string
@@ -54,7 +54,7 @@ export interface PersonDraft {
   readonly email?: string
   readonly phones?: readonly string[]
   readonly timezone?: string
-  readonly location?: string
+  readonly addresses?: readonly PersonAddress[]
   readonly preferredChannel?: string
   readonly influence?: string
   readonly relationship?: string
@@ -211,8 +211,7 @@ export function companyDraft(
     description: text(mapped, 'description'),
     stage: enumeration(mapped, 'stage', COMPANY_STAGES),
     sizeBand: enumeration(mapped, 'size_band', SIZE_BANDS),
-    hq: text(mapped, 'hq'),
-    website: text(mapped, 'website'),
+    addresses: companyAddressesFromMapped(mapped).addresses,
     accountType: enumeration(mapped, 'account_type', ACCOUNT_TYPES),
     icpFit: enumeration(mapped, 'icp_fit', ICP_FITS),
     summary: text(mapped, 'summary'),
@@ -246,7 +245,7 @@ export function personDraft(
     email: email === undefined ? undefined : (normaliseEmail(email) ?? undefined),
     phones: list(mapped, 'phones'),
     timezone: text(mapped, 'timezone'),
-    location: text(mapped, 'location'),
+    addresses: personAddressesFromMapped(mapped).addresses,
     preferredChannel: enumeration(mapped, 'preferred_channel', PREFERRED_CHANNELS),
     influence: enumeration(mapped, 'influence', INFLUENCE_LEVELS),
     relationship: enumeration(mapped, 'relationship', RELATIONSHIP_LEVELS),
@@ -274,8 +273,7 @@ export function affiliationCompanyDraft(mapped: Readonly<Record<string, string>>
     description: undefined,
     stage: undefined,
     sizeBand: undefined,
-    hq: undefined,
-    website: undefined,
+    addresses: undefined,
     accountType: undefined,
     icpFit: undefined,
     summary: undefined,

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

@@ -1,6 +1,7 @@
 import { OBJECT_COLUMNS, customFieldObjectTypeForExport } from '@kelpie/schemas'
 import type { CsvColumn, CustomFieldValue, ExportObject } from '@kelpie/schemas'
 
+import { companyAddressCells, personAddressCells } from './addresses.ts'
 import type { CustomFieldDefinitionRecord } from '../custom-fields/repository.ts'
 import { customFieldCells, customFieldDefinitionCells, customFieldHeaderKeys } from './customFieldCsv.ts'
 import { centsToMoney } from './mapping.ts'
@@ -101,8 +102,7 @@ export function companyCells(
       row.description,
       row.summary,
       joinList(row.tags),
-      row.website ?? '',
-      row.hq ?? '',
+      ...companyAddressCells(row.addresses),
     ],
     row.customFields,
     definitions,
@@ -122,7 +122,7 @@ export function personCells(
       row.suffix ?? '',
       row.email ?? '',
       row.timezone ?? '',
-      row.location ?? '',
+      ...personAddressCells(row.addresses),
       row.preferredChannel,
       row.influence,
       row.relationship,

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

@@ -11,6 +11,7 @@ import { pipelineKindForImport } from '@kelpie/schemas'
 
 import { normaliseDomain, normaliseEmail } from '../../lib/normalisation.ts'
 import type { CustomFieldDefinitionRecord } from '../custom-fields/repository.ts'
+import { companyAddressesFromMapped, personAddressesFromMapped } from './addresses.ts'
 import {
   customFieldWireValues,
   extractCustomFieldRaw,
@@ -628,6 +629,29 @@ function withAffiliation(
   return { ...plan, write, ...(warnings.length > 0 ? { warnings } : {}) }
 }
 
+function withAddressWarnings(
+  context: PlanContext,
+  mapped: Readonly<Record<string, string>>,
+  plan: RowPlan,
+): RowPlan {
+  if (plan.action !== 'create' && plan.action !== 'update') {
+    return plan
+  }
+
+  const extra =
+    context.object === 'people'
+      ? personAddressesFromMapped(mapped).warnings
+      : context.object === 'companies'
+        ? companyAddressesFromMapped(mapped).warnings
+        : []
+
+  if (extra.length === 0) {
+    return plan
+  }
+
+  return { ...plan, warnings: [...(plan.warnings ?? []), ...extra] }
+}
+
 /**
  * @param mapped The row's cells by Kelpie column, from `mapRow`.
  * @returns What this row would do. `create` when its key matches nothing;
@@ -663,7 +687,7 @@ export function planRow(context: PlanContext, mapped: Readonly<Record<string, st
   const targetId = context.lookups.existing.get(key)
 
   if (targetId === undefined) {
-    return withAffiliation(context, mapped, { action: 'create', key, write })
+    return withAddressWarnings(context, mapped, withAffiliation(context, mapped, { action: 'create', key, write }))
   }
 
   // An empty string is the placeholder an in-file match carries: the record it
@@ -674,7 +698,11 @@ export function planRow(context: PlanContext, mapped: Readonly<Record<string, st
   // 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'
-    ? withAffiliation(context, mapped, { action: 'update', key, targetId: resolved, write })
+    ? withAddressWarnings(
+        context,
+        mapped,
+        withAffiliation(context, mapped, { action: 'update', key, targetId: resolved, write }),
+      )
     : { action: 'skip', key, targetId: resolved }
 }