@kelpie/server 0.9.0 → 0.11.0

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

@@ -1,6 +1,7 @@
 import { changedKeys } from '../../lib/changes.ts'
 import { AppError } from '../../lib/errors.ts'
 import type { IdFactory } from '../../lib/ids.ts'
+import type { CustomFieldValue, CustomFieldWireValue, PipelineKind } from '@kelpie/schemas'
 import type { RecordObjectType } from '../../runtime/events.ts'
 import type { Transaction } from '../../runtime/transaction.ts'
 import type { ActivityRecorder } from '../activities/recorder.ts'
@@ -8,11 +9,18 @@ import { describeCreationVia, describeLink, describeUpdateVia } from '../activit
 import type { Actor } from '../auth/actor.ts'
 import * as companyRepository from '../companies/repository.ts'
 import * as consentPurposesRepository from '../consent-purposes/repository.ts'
+import * as customFieldRepository from '../custom-fields/repository.ts'
+import { createCustomFieldValues } from '../custom-fields/values.ts'
+import type { CustomFieldObjectType } from '../custom-fields/schema.ts'
 import * as dealRepository from '../deals/repository.ts'
+import * as enquiryRepository from '../enquiries/repository.ts'
+import * as opportunityRepository from '../opportunities/repository.ts'
+import * as partnershipRepository from '../partnerships/repository.ts'
 import * as peopleRepository from '../people/repository.ts'
 import { upsertPersonConsent } from '../people/personConsentWrites.ts'
 import * as personLinks from '../personLinks.ts'
 import * as positionRepository from '../positions/repository.ts'
+import * as raiseRepository from '../raises/repository.ts'
 import { IMPORT_DEAL_CURRENCY, NEW_COMPANY_DEFAULTS, NEW_PERSON_DEFAULTS } from './drafts.ts'
 import type { ImportConsentGrant, ImportWrite, PlannedAffiliation, RowPlan } from './plan.ts'
 
@@ -52,9 +60,11 @@ export interface SideRecord {
   readonly changedFields: readonly string[]
 }
 
+export type ImportWrittenObjectType = RecordObjectType | 'custom_field'
+
 export interface WriteOutcome {
   readonly recordId: string
-  readonly objectType: RecordObjectType
+  readonly objectType: ImportWrittenObjectType
   /**
    * The columns an update moved, for `record.updated`. Empty on a create, and
    * empty on an update that resent the values already stored — which emits
@@ -79,6 +89,51 @@ function requireTarget(plan: Extract<RowPlan, { action: 'update' }>): string {
   return plan.targetId
 }
 
+async function validatedCustomFieldsForCreate(
+  tx: Transaction,
+  workspaceId: string,
+  objectType: CustomFieldObjectType,
+  sent: Readonly<Record<string, CustomFieldWireValue>> | undefined,
+): Promise<Readonly<Record<string, CustomFieldValue>> | undefined> {
+  if (sent === undefined || Object.keys(sent).length === 0) {
+    return undefined
+  }
+
+  return createCustomFieldValues({ db: tx }).forCreate(tx, workspaceId, objectType, sent)
+}
+
+async function validatedCustomFieldsForUpdate(
+  tx: Transaction,
+  workspaceId: string,
+  objectType: CustomFieldObjectType,
+  stored: Readonly<Record<string, CustomFieldValue>>,
+  sent: Readonly<Record<string, CustomFieldWireValue>> | undefined,
+): Promise<
+  | {
+      readonly merged: Readonly<Record<string, CustomFieldValue>>
+      readonly changedPaths: readonly string[]
+    }
+  | undefined
+> {
+  if (sent === undefined || Object.keys(sent).length === 0) {
+    return undefined
+  }
+
+  const merge = await createCustomFieldValues({ db: tx }).forUpdate(
+    tx,
+    workspaceId,
+    objectType,
+    stored,
+    sent,
+  )
+
+  if (merge === undefined) {
+    return undefined
+  }
+
+  return { merged: merge.merged, changedPaths: merge.changedPaths }
+}
+
 async function writeCompany(
   dependencies: WriteDependencies,
   plan: WritablePlan,
@@ -87,10 +142,18 @@ async function writeCompany(
   const { tx, workspaceId } = dependencies
 
   if (plan.action === 'create') {
+    const customFields = await validatedCustomFieldsForCreate(
+      tx,
+      workspaceId,
+      'company',
+      write.draft.customFields,
+    )
+    const { customFields: _draftCustomFields, tags, ...rest } = write.draft
     const created = await companyRepository.insertCompany(tx, {
       ...NEW_COMPANY_DEFAULTS,
-      ...write.draft,
-      tags: write.draft.tags === undefined ? undefined : [...write.draft.tags],
+      ...rest,
+      tags: tags === undefined ? undefined : [...tags],
+      ...(customFields === undefined ? {} : { customFields }),
       id: dependencies.createId('company'),
       workspaceId,
       name: write.draft.name ?? '',
@@ -106,11 +169,23 @@ async function writeCompany(
     throw AppError.notFound('Company not found')
   }
 
+  const { customFields: draftCustomFields, tags, ...rest } = write.draft
+  const customMerge = await validatedCustomFieldsForUpdate(
+    tx,
+    workspaceId,
+    'company',
+    existing.customFields,
+    draftCustomFields,
+  )
   const columns = {
-    ...write.draft,
-    tags: write.draft.tags === undefined ? undefined : [...write.draft.tags],
+    ...rest,
+    tags: tags === undefined ? undefined : [...tags],
+    ...(customMerge === undefined ? {} : { customFields: customMerge.merged }),
   }
-  const changedFields = changedKeys(existing, columns)
+  const changedFields = [
+    ...changedKeys(existing, columns),
+    ...(customMerge?.changedPaths ?? []),
+  ]
 
   if (changedFields.length > 0) {
     await companyRepository.updateCompany(tx, workspaceId, id, {
@@ -146,10 +221,11 @@ async function applyAffiliation(
       return affiliation.companyId
     }
 
+    const { customFields: _customFields, tags, ...companyRest } = affiliation.company
     const created = await companyRepository.insertCompany(tx, {
       ...NEW_COMPANY_DEFAULTS,
-      ...affiliation.company,
-      tags: affiliation.company.tags === undefined ? undefined : [...affiliation.company.tags],
+      ...companyRest,
+      tags: tags === undefined ? undefined : [...tags],
       id: dependencies.createId('company'),
       workspaceId,
       name: affiliation.company.name ?? '',
@@ -216,11 +292,19 @@ async function writePerson(
   const { tx, workspaceId } = dependencies
 
   if (plan.action === 'create') {
+    const customFields = await validatedCustomFieldsForCreate(
+      tx,
+      workspaceId,
+      'person',
+      write.draft.customFields,
+    )
+    const { customFields: _draftCustomFields, phones, tags, ...rest } = write.draft
     const created = await peopleRepository.insertPerson(tx, {
       ...NEW_PERSON_DEFAULTS,
-      ...write.draft,
-      phones: write.draft.phones === undefined ? undefined : [...write.draft.phones],
-      tags: write.draft.tags === undefined ? undefined : [...write.draft.tags],
+      ...rest,
+      phones: phones === undefined ? undefined : [...phones],
+      tags: tags === undefined ? undefined : [...tags],
+      ...(customFields === undefined ? {} : { customFields }),
       id: dependencies.createId('person'),
       workspaceId,
       // `name` is not a required column any more; the People row check is what
@@ -248,12 +332,24 @@ async function writePerson(
     throw AppError.notFound('Person not found')
   }
 
+  const { customFields: draftCustomFields, phones, tags, ...rest } = write.draft
+  const customMerge = await validatedCustomFieldsForUpdate(
+    tx,
+    workspaceId,
+    'person',
+    existing.customFields,
+    draftCustomFields,
+  )
   const columns = {
-    ...write.draft,
-    phones: write.draft.phones === undefined ? undefined : [...write.draft.phones],
-    tags: write.draft.tags === undefined ? undefined : [...write.draft.tags],
+    ...rest,
+    phones: phones === undefined ? undefined : [...phones],
+    tags: tags === undefined ? undefined : [...tags],
+    ...(customMerge === undefined ? {} : { customFields: customMerge.merged }),
   }
-  const changedFields = changedKeys(existing, columns)
+  const changedFields = [
+    ...changedKeys(existing, columns),
+    ...(customMerge?.changedPaths ?? []),
+  ]
 
   if (changedFields.length > 0) {
     await peopleRepository.updatePerson(tx, workspaceId, id, {
@@ -365,12 +461,13 @@ async function writePosition(
  * rule every other column follows. A mapped, filled-in cell is the file stating
  * the list, so it replaces.
  */
-async function reconcileDealPeople(
+async function reconcileLinkedPeople(
   dependencies: WriteDependencies,
-  dealId: string,
+  targetType: PipelineKind,
+  targetId: string,
   personIds: readonly string[],
 ): Promise<boolean> {
-  const target = { targetType: 'deal' as const, targetId: dealId }
+  const target = { targetType, targetId }
   const current = await personLinks.listPersonIds(dependencies.tx, dependencies.workspaceId, target)
   const added = personIds.filter((personId) => !current.includes(personId))
   const removed = current.filter((personId) => !personIds.includes(personId))
@@ -396,11 +493,25 @@ async function writeDeal(
 
   if (plan.action === 'create') {
     const id = dependencies.createId('deal')
+    const customFields = await validatedCustomFieldsForCreate(
+      tx,
+      workspaceId,
+      'deal',
+      write.draft.customFields,
+    )
+
+    const {
+      customFields: _draftCustomFields,
+      competitors,
+      tags,
+      ...rest
+    } = write.draft
 
     await dealRepository.insertDeal(tx, {
-      ...write.draft,
-      competitors: write.draft.competitors === undefined ? undefined : [...write.draft.competitors],
-      tags: write.draft.tags === undefined ? undefined : [...write.draft.tags],
+      ...rest,
+      competitors: competitors === undefined ? undefined : [...competitors],
+      tags: tags === undefined ? undefined : [...tags],
+      ...(customFields === undefined ? {} : { customFields }),
       id,
       workspaceId,
       name: write.draft.name ?? '',
@@ -429,15 +540,29 @@ async function writeDeal(
     throw AppError.notFound('Deal not found')
   }
 
+  const {
+    customFields: draftCustomFields,
+    competitors,
+    tags,
+    ...rest
+  } = write.draft
+  const customMerge = await validatedCustomFieldsForUpdate(
+    tx,
+    workspaceId,
+    'deal',
+    existing.customFields,
+    draftCustomFields,
+  )
   const columns = {
-    ...write.draft,
-    competitors: write.draft.competitors === undefined ? undefined : [...write.draft.competitors],
-    tags: write.draft.tags === undefined ? undefined : [...write.draft.tags],
+    ...rest,
+    competitors: competitors === undefined ? undefined : [...competitors],
+    tags: tags === undefined ? undefined : [...tags],
     companyId: write.companyId,
     stageId: write.stageId,
     ...(write.ownerId === null ? {} : { ownerId: write.ownerId }),
+    ...(customMerge === undefined ? {} : { customFields: customMerge.merged }),
   }
-  const changed = changedKeys(existing, columns)
+  const changed = [...changedKeys(existing, columns), ...(customMerge?.changedPaths ?? [])]
 
   if (changed.length > 0) {
     await dealRepository.updateDeal(tx, workspaceId, id, {
@@ -447,7 +572,7 @@ async function writeDeal(
   }
 
   const peopleMoved = write.setsPeople
-    ? await reconcileDealPeople(dependencies, id, write.personIds)
+    ? await reconcileLinkedPeople(dependencies, 'deal', id, write.personIds)
     : false
 
   return {
@@ -457,12 +582,405 @@ async function writeDeal(
   }
 }
 
+async function writeOpportunity(
+  dependencies: WriteDependencies,
+  plan: WritablePlan,
+  write: Extract<ImportWrite, { object: 'opportunities' }>,
+): Promise<WriteOutcome> {
+  const { tx, workspaceId } = dependencies
+
+  if (plan.action === 'create') {
+    const id = dependencies.createId('opportunity')
+    const customFields = await validatedCustomFieldsForCreate(
+      tx,
+      workspaceId,
+      'opportunity',
+      write.draft.customFields,
+    )
+
+    const { customFields: _draftCustomFields, tags, ...rest } = write.draft
+
+    await opportunityRepository.insertOpportunity(tx, {
+      ...rest,
+      tags: tags === undefined ? undefined : [...tags],
+      ...(customFields === undefined ? {} : { customFields }),
+      id,
+      workspaceId,
+      name: write.draft.name ?? '',
+      kind: write.draft.kind ?? '',
+      stageId: write.stageId,
+      companyId: write.companyId,
+      ownerId: write.ownerId,
+    })
+    await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'opportunity', targetId: id }, write.personIds)
+
+    return { recordId: id, objectType: 'opportunity', changedFields: [] }
+  }
+
+  const id = requireTarget(plan)
+  const existing = await opportunityRepository.findOpportunity(tx, workspaceId, id)
+
+  if (existing === undefined) {
+    throw AppError.notFound('Opportunity not found')
+  }
+
+  const { customFields: draftCustomFields, tags, ...rest } = write.draft
+  const customMerge = await validatedCustomFieldsForUpdate(
+    tx,
+    workspaceId,
+    'opportunity',
+    existing.customFields,
+    draftCustomFields,
+  )
+  const columns = {
+    ...rest,
+    tags: tags === undefined ? undefined : [...tags],
+    stageId: write.stageId,
+    companyId: write.companyId,
+    ...(write.ownerId === null ? {} : { ownerId: write.ownerId }),
+    ...(customMerge === undefined ? {} : { customFields: customMerge.merged }),
+  }
+  const changed = [...changedKeys(existing, columns), ...(customMerge?.changedPaths ?? [])]
+
+  if (changed.length > 0) {
+    await opportunityRepository.updateOpportunity(tx, workspaceId, id, {
+      ...columns,
+      updatedAt: dependencies.now,
+    })
+  }
+
+  const peopleMoved = write.setsPeople
+    ? await reconcileLinkedPeople(dependencies, 'opportunity', id, write.personIds)
+    : false
+
+  return {
+    recordId: id,
+    objectType: 'opportunity',
+    changedFields: peopleMoved ? [...changed, 'personIds'] : changed,
+  }
+}
+
+async function writeEnquiry(
+  dependencies: WriteDependencies,
+  plan: WritablePlan,
+  write: Extract<ImportWrite, { object: 'enquiries' }>,
+): Promise<WriteOutcome> {
+  const { tx, workspaceId } = dependencies
+
+  if (plan.action === 'create') {
+    const id = dependencies.createId('enquiry')
+    const customFields = await validatedCustomFieldsForCreate(
+      tx,
+      workspaceId,
+      'enquiry',
+      write.draft.customFields,
+    )
+
+    const { customFields: _draftCustomFields, tags, ...rest } = write.draft
+
+    await enquiryRepository.insertEnquiry(tx, {
+      ...rest,
+      tags: tags === undefined ? undefined : [...tags],
+      ...(customFields === undefined ? {} : { customFields }),
+      id,
+      workspaceId,
+      name: write.draft.name ?? '',
+      source: write.draft.source ?? '',
+      stageId: write.stageId,
+      companyId: write.companyId,
+      ownerId: write.ownerId,
+    })
+    await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'enquiry', targetId: id }, write.personIds)
+
+    return { recordId: id, objectType: 'enquiry', changedFields: [] }
+  }
+
+  const id = requireTarget(plan)
+  const existing = await enquiryRepository.findEnquiry(tx, workspaceId, id)
+
+  if (existing === undefined) {
+    throw AppError.notFound('Enquiry not found')
+  }
+
+  const { customFields: draftCustomFields, tags, ...rest } = write.draft
+  const customMerge = await validatedCustomFieldsForUpdate(
+    tx,
+    workspaceId,
+    'enquiry',
+    existing.customFields,
+    draftCustomFields,
+  )
+  const columns = {
+    ...rest,
+    tags: tags === undefined ? undefined : [...tags],
+    stageId: write.stageId,
+    companyId: write.companyId,
+    ...(write.ownerId === null ? {} : { ownerId: write.ownerId }),
+    ...(customMerge === undefined ? {} : { customFields: customMerge.merged }),
+  }
+  const changed = [...changedKeys(existing, columns), ...(customMerge?.changedPaths ?? [])]
+
+  if (changed.length > 0) {
+    await enquiryRepository.updateEnquiry(tx, workspaceId, id, {
+      ...columns,
+      updatedAt: dependencies.now,
+    })
+  }
+
+  const peopleMoved = write.setsPeople
+    ? await reconcileLinkedPeople(dependencies, 'enquiry', id, write.personIds)
+    : false
+
+  return {
+    recordId: id,
+    objectType: 'enquiry',
+    changedFields: peopleMoved ? [...changed, 'personIds'] : changed,
+  }
+}
+
+async function writePartnership(
+  dependencies: WriteDependencies,
+  plan: WritablePlan,
+  write: Extract<ImportWrite, { object: 'partnerships' }>,
+): Promise<WriteOutcome> {
+  const { tx, workspaceId } = dependencies
+
+  if (plan.action === 'create') {
+    const id = dependencies.createId('partnership')
+    const customFields = await validatedCustomFieldsForCreate(
+      tx,
+      workspaceId,
+      'partnership',
+      write.draft.customFields,
+    )
+
+    const { customFields: _draftCustomFields, tags, ...rest } = write.draft
+
+    await partnershipRepository.insertPartnership(tx, {
+      ...rest,
+      tags: tags === undefined ? undefined : [...tags],
+      ...(customFields === undefined ? {} : { customFields }),
+      id,
+      workspaceId,
+      name: write.draft.name ?? '',
+      kind: write.draft.kind ?? '',
+      stageId: write.stageId,
+      companyId: write.companyId,
+      ownerId: write.ownerId,
+    })
+    await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'partnership', targetId: id }, write.personIds)
+
+    return { recordId: id, objectType: 'partnership', changedFields: [] }
+  }
+
+  const id = requireTarget(plan)
+  const existing = await partnershipRepository.findPartnership(tx, workspaceId, id)
+
+  if (existing === undefined) {
+    throw AppError.notFound('Partnership not found')
+  }
+
+  const { customFields: draftCustomFields, tags, ...rest } = write.draft
+  const customMerge = await validatedCustomFieldsForUpdate(
+    tx,
+    workspaceId,
+    'partnership',
+    existing.customFields,
+    draftCustomFields,
+  )
+  const columns = {
+    ...rest,
+    tags: tags === undefined ? undefined : [...tags],
+    stageId: write.stageId,
+    companyId: write.companyId,
+    ...(write.ownerId === null ? {} : { ownerId: write.ownerId }),
+    ...(customMerge === undefined ? {} : { customFields: customMerge.merged }),
+  }
+  const changed = [...changedKeys(existing, columns), ...(customMerge?.changedPaths ?? [])]
+
+  if (changed.length > 0) {
+    await partnershipRepository.updatePartnership(tx, workspaceId, id, {
+      ...columns,
+      updatedAt: dependencies.now,
+    })
+  }
+
+  const peopleMoved = write.setsPeople
+    ? await reconcileLinkedPeople(dependencies, 'partnership', id, write.personIds)
+    : false
+
+  return {
+    recordId: id,
+    objectType: 'partnership',
+    changedFields: peopleMoved ? [...changed, 'personIds'] : changed,
+  }
+}
+
+async function writeRaise(
+  dependencies: WriteDependencies,
+  plan: WritablePlan,
+  write: Extract<ImportWrite, { object: 'raises' }>,
+): Promise<WriteOutcome> {
+  const { tx, workspaceId } = dependencies
+
+  if (plan.action === 'create') {
+    const id = dependencies.createId('raise')
+    const customFields = await validatedCustomFieldsForCreate(
+      tx,
+      workspaceId,
+      'raise',
+      write.draft.customFields,
+    )
+
+    const { customFields: _draftCustomFields, tags, ...rest } = write.draft
+
+    await raiseRepository.insertRaise(tx, {
+      ...rest,
+      tags: tags === undefined ? undefined : [...tags],
+      ...(customFields === undefined ? {} : { customFields }),
+      id,
+      workspaceId,
+      name: write.draft.name ?? '',
+      stageId: write.stageId,
+      companyId: write.companyId,
+      ownerId: write.ownerId,
+      currency:
+        write.draft.currency ??
+        (write.draft.checkSizeCents === undefined || write.draft.checkSizeCents === null
+          ? undefined
+          : IMPORT_DEAL_CURRENCY),
+    })
+    await personLinks.linkPeople(tx, dependencies.createId, workspaceId, { targetType: 'raise', targetId: id }, write.personIds)
+
+    return { recordId: id, objectType: 'raise', changedFields: [] }
+  }
+
+  const id = requireTarget(plan)
+  const existing = await raiseRepository.findRaise(tx, workspaceId, id)
+
+  if (existing === undefined) {
+    throw AppError.notFound('Raise not found')
+  }
+
+  const { customFields: draftCustomFields, tags, ...rest } = write.draft
+  const customMerge = await validatedCustomFieldsForUpdate(
+    tx,
+    workspaceId,
+    'raise',
+    existing.customFields,
+    draftCustomFields,
+  )
+  const columns = {
+    ...rest,
+    tags: tags === undefined ? undefined : [...tags],
+    stageId: write.stageId,
+    companyId: write.companyId,
+    ...(write.ownerId === null ? {} : { ownerId: write.ownerId }),
+    ...(customMerge === undefined ? {} : { customFields: customMerge.merged }),
+  }
+  const changed = [...changedKeys(existing, columns), ...(customMerge?.changedPaths ?? [])]
+
+  if (changed.length > 0) {
+    await raiseRepository.updateRaise(tx, workspaceId, id, {
+      ...columns,
+      updatedAt: dependencies.now,
+    })
+  }
+
+  const peopleMoved = write.setsPeople
+    ? await reconcileLinkedPeople(dependencies, 'raise', id, write.personIds)
+    : false
+
+  return {
+    recordId: id,
+    objectType: 'raise',
+    changedFields: peopleMoved ? [...changed, 'personIds'] : changed,
+  }
+}
+
+async function writeCustomFieldDefinition(
+  dependencies: WriteDependencies,
+  plan: WritablePlan,
+  write: Extract<ImportWrite, { object: 'custom_fields' }>,
+): Promise<WriteOutcome> {
+  const { tx, workspaceId } = dependencies
+
+  if (plan.action === 'create') {
+    const id = dependencies.createId('customFieldDefinition')
+    const created = await customFieldRepository.insertDefinition(tx, {
+      id,
+      workspaceId,
+      objectType: write.draft.objectType as CustomFieldObjectType,
+      key: write.draft.key ?? '',
+      label: write.draft.label ?? '',
+      type: write.draft.type as import('../custom-fields/schema.ts').CustomFieldType,
+      options: write.draft.options === undefined ? [] : [...write.draft.options],
+      description: write.draft.description ?? '',
+      sortOrder: write.draft.sortOrder ?? 0,
+    })
+
+    return { recordId: created.id, objectType: 'custom_field', changedFields: [] }
+  }
+
+  const id = requireTarget(plan)
+  const existing = await customFieldRepository.findDefinition(tx, workspaceId, id)
+
+  if (existing === undefined) {
+    throw AppError.notFound('Custom field not found')
+  }
+
+  const columns = {
+    ...(write.draft.label === undefined ? {} : { label: write.draft.label }),
+    ...(write.draft.description === undefined ? {} : { description: write.draft.description }),
+    ...(write.draft.options === undefined ? {} : { options: [...write.draft.options] }),
+    ...(write.draft.sortOrder === undefined ? {} : { sortOrder: write.draft.sortOrder }),
+  }
+  const changedFields = changedKeys(existing, columns)
+
+  if (changedFields.length > 0) {
+    await customFieldRepository.updateDefinition(tx, workspaceId, id, {
+      ...columns,
+      updatedAt: dependencies.now,
+    })
+  }
+
+  return { recordId: id, objectType: 'custom_field', changedFields }
+}
+
 /** What a timeline calls each object. */
 const OBJECT_LABEL: Readonly<Record<ImportWrite['object'], string>> = {
   companies: 'Company',
   people: 'Person',
   positions: 'Position',
   deals: 'Deal',
+  opportunities: 'Opportunity',
+  enquiries: 'Enquiry',
+  partnerships: 'Partnership',
+  raises: 'Raise',
+  custom_fields: 'Custom field',
+}
+
+function historyTargetType(
+  write: ImportWrite,
+): 'company' | 'person' | 'deal' | 'opportunity' | 'enquiry' | 'partnership' | 'raise' {
+  switch (write.object) {
+    case 'companies':
+      return 'company'
+    case 'people':
+      return 'person'
+    case 'deals':
+      return 'deal'
+    case 'opportunities':
+      return 'opportunity'
+    case 'enquiries':
+      return 'enquiry'
+    case 'partnerships':
+      return 'partnership'
+    case 'raises':
+      return 'raise'
+    default:
+      throw new Error(`No history target for ${write.object}`)
+  }
 }
 
 /**
@@ -480,6 +998,10 @@ async function recordHistory(
 ): Promise<void> {
   const { tx, workspaceId, actor, sourceName } = dependencies
 
+  if (write.object === 'custom_fields') {
+    return
+  }
+
   if (write.object === 'positions') {
     if (plan.action !== 'create') {
       return
@@ -509,7 +1031,7 @@ async function recordHistory(
   const label = OBJECT_LABEL[write.object]
 
   await dependencies.recordActivity(tx, workspaceId, actor, {
-    targetType: write.object === 'companies' ? 'company' : write.object === 'people' ? 'person' : 'deal',
+    targetType: historyTargetType(write),
     targetId: outcome.recordId,
     kind: plan.action === 'create' ? 'created' : 'updated',
     ...(plan.action === 'create'
@@ -534,6 +1056,16 @@ export async function applyWrite(
         return writePosition(dependencies, plan, write)
       case 'deals':
         return writeDeal(dependencies, plan, write)
+      case 'opportunities':
+        return writeOpportunity(dependencies, plan, write)
+      case 'enquiries':
+        return writeEnquiry(dependencies, plan, write)
+      case 'partnerships':
+        return writePartnership(dependencies, plan, write)
+      case 'raises':
+        return writeRaise(dependencies, plan, write)
+      case 'custom_fields':
+        return writeCustomFieldDefinition(dependencies, plan, write)
     }
   })()