@kelpie/server 0.1.0

package/src/modules/companies/repository.ts

@@ -0,0 +1,185 @@
+import { and, asc, eq, ilike, inArray, or, sql } from 'drizzle-orm'
+import type { SQL } from 'drizzle-orm'
+
+import { keysetCondition, orderByWindow, textSort, timestampSort } from '../../lib/pagination.ts'
+import type { ListWindow, SortableFields } from '../../lib/pagination.ts'
+import { arrayContainsPattern, containsPattern } from '../../lib/search.ts'
+import type { Queryable } from '../../runtime/transaction.ts'
+import { positions } from '../positions/schema.ts'
+import { companies } from './schema.ts'
+
+export type CompanyRecord = typeof companies.$inferSelect
+
+/** The writable column shape. Services build one of these; nothing else knows the column names. */
+export type CompanyColumns = typeof companies.$inferInsert
+
+/** The sort fields `?sort=` documents for companies. Nullable columns stay out: a keyset cannot seek past a null. */
+export const COMPANY_SORTS: SortableFields<CompanyRecord> = {
+  name: textSort(companies.name, (company) => company.name),
+  created_at: timestampSort(companies.createdAt, (company) => company.createdAt),
+  updated_at: timestampSort(companies.updatedAt, (company) => company.updatedAt),
+}
+
+export const DEFAULT_COMPANY_SORT = '-created_at'
+
+export interface CompanyFilters {
+  /** `?q=`, matched the way the mockup's Companies filter matches. */
+  readonly term?: string | undefined
+  /** `?person_id=`, repeatable: companies where any of these people holds a position. */
+  readonly personIds?: readonly string[] | undefined
+}
+
+/**
+ * `api.md` has no `include` expansion, so without this filter a person detail
+ * page would fetch the person's positions and then one company per position.
+ *
+ * Reads the `positions` table, never its repository. See the same note in the
+ * people repository.
+ */
+function employsAnyOf(personIds: readonly string[]): SQL {
+  return sql`exists (
+    select 1
+    from ${positions}
+    where ${positions.companyId} = ${companies.id}
+      and ${positions.workspaceId} = ${companies.workspaceId}
+      and ${inArray(positions.personId, personIds)}
+  )`
+}
+
+function matchesTerm(term: string): SQL | undefined {
+  const pattern = containsPattern(term)
+
+  return or(
+    ilike(companies.name, pattern),
+    ilike(companies.domain, pattern),
+    ilike(companies.industry, pattern),
+    ilike(companies.summary, pattern),
+    ilike(companies.accountType, pattern),
+    arrayContainsPattern(companies.tags, pattern),
+  )
+}
+
+function conditionsFor(workspaceId: string, filters: CompanyFilters): (SQL | undefined)[] {
+  return [
+    eq(companies.workspaceId, workspaceId),
+    filters.term === undefined ? undefined : matchesTerm(filters.term),
+    filters.personIds === undefined ? undefined : employsAnyOf(filters.personIds),
+  ]
+}
+
+/** @returns Up to `window.fetchLimit` rows: one more than the page, so the caller can tell there is a next one. */
+export function listCompanies(
+  db: Queryable,
+  workspaceId: string,
+  filters: CompanyFilters,
+  window: ListWindow<CompanyRecord>,
+): Promise<CompanyRecord[]> {
+  return db
+    .select()
+    .from(companies)
+    .where(and(...conditionsFor(workspaceId, filters), keysetCondition(window, companies.id)))
+    .orderBy(...orderByWindow(window, companies.id))
+    .limit(window.fetchLimit)
+}
+
+export async function findCompany(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+): Promise<CompanyRecord | undefined> {
+  const [found] = await db
+    .select()
+    .from(companies)
+    .where(and(eq(companies.workspaceId, workspaceId), eq(companies.id, id)))
+    .limit(1)
+
+  return found
+}
+
+/**
+ * The one company in this workspace on a domain. `domain` is unique per
+ * workspace and `citext`, so the comparison matches whatever case arrived.
+ */
+export async function findCompanyByDomain(
+  db: Queryable,
+  workspaceId: string,
+  domain: string,
+): Promise<CompanyRecord | undefined> {
+  const [found] = await db
+    .select()
+    .from(companies)
+    .where(and(eq(companies.workspaceId, workspaceId), eq(companies.domain, domain)))
+    .limit(1)
+
+  return found
+}
+
+/**
+ * A company matched by name, for a form submit that was given a name and no
+ * domain.
+ *
+ * Names are not unique, so this is a weaker match than the domain one and is
+ * only ever tried second (`forms.md` submit rule 4). The oldest row wins, which
+ * makes a repeat submission attach to the same company every time rather than
+ * following whichever duplicate was edited last.
+ *
+ * `lower(…) = lower(…)` rather than `ilike`: the name is caller data, and
+ * `ilike` would read a `%` or `_` inside it as a wildcard.
+ */
+export async function findCompanyByName(
+  db: Queryable,
+  workspaceId: string,
+  name: string,
+): Promise<CompanyRecord | undefined> {
+  const [found] = await db
+    .select()
+    .from(companies)
+    .where(
+      and(
+        eq(companies.workspaceId, workspaceId),
+        sql`lower(${companies.name}) = lower(${sql.param(name, companies.name)})`,
+      ),
+    )
+    .orderBy(asc(companies.createdAt), asc(companies.id))
+    .limit(1)
+
+  return found
+}
+
+export async function insertCompany(db: Queryable, values: CompanyColumns): Promise<CompanyRecord> {
+  const [created] = await db.insert(companies).values(values).returning()
+
+  if (created === undefined) {
+    throw new Error(`Inserting company ${values.id} returned no row`)
+  }
+
+  return created
+}
+
+export async function updateCompany(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+  changes: Partial<CompanyColumns>,
+): Promise<CompanyRecord | undefined> {
+  const [updated] = await db
+    .update(companies)
+    .set(changes)
+    .where(and(eq(companies.workspaceId, workspaceId), eq(companies.id, id)))
+    .returning()
+
+  return updated
+}
+
+export async function deleteCompany(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+): Promise<number> {
+  const deleted = await db
+    .delete(companies)
+    .where(and(eq(companies.workspaceId, workspaceId), eq(companies.id, id)))
+    .returning({ id: companies.id })
+
+  return deleted.length
+}

package/src/modules/companies/routes.ts

@@ -0,0 +1,170 @@
+import type { Context, Hono } from 'hono'
+import { z } from 'zod'
+
+import { pageBody, readIdFilter, readJsonBody, readListParameters } from '../../lib/http.ts'
+import type { Actor } from '../auth/actor.ts'
+import { resolveActorFrom } from '../auth/credentials.ts'
+import type { CredentialDependencies } from '../auth/credentials.ts'
+import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from './schema.ts'
+import type {
+  CompaniesService,
+  CompanyView,
+  CreateCompanyInput,
+  UpdateCompanyInput,
+} from './service.ts'
+
+/** Wire shapes for `/v1/companies`. Bodies are strict; an unknown field is a 422, per `api.md`. */
+
+/** The full field set, without defaults. `createBody` adds those; `updateBody` makes it partial. */
+const companyShape = {
+  name: z.string().min(1),
+  domain: z.string().nullable(),
+  industry: z.string().nullable(),
+  description: z.string(),
+  stage: z.enum(COMPANY_STAGES),
+  size_band: z.enum(SIZE_BANDS),
+  hq: z.string().nullable(),
+  website: z.string().nullable(),
+  account_type: z.enum(ACCOUNT_TYPES),
+  icp_fit: z.enum(ICP_FITS),
+  tech_stack: z.array(z.string().min(1)),
+  summary: z.string(),
+  tags: z.array(z.string().min(1)),
+}
+
+/**
+ * Only `name` is required. The defaults are the ones the mockup's own Add company
+ * button writes, so creating through the API and creating through the UI produce
+ * the same record.
+ */
+export const createBody = z.strictObject({
+  ...companyShape,
+  domain: companyShape.domain.default(null),
+  industry: companyShape.industry.default(null),
+  description: companyShape.description.default(''),
+  stage: companyShape.stage.default('startup'),
+  size_band: companyShape.size_band.default('1-10'),
+  hq: companyShape.hq.default(null),
+  website: companyShape.website.default(null),
+  account_type: companyShape.account_type.default('prospect'),
+  icp_fit: companyShape.icp_fit.default('unknown'),
+  tech_stack: companyShape.tech_stack.default([]),
+  summary: companyShape.summary.default(''),
+  tags: companyShape.tags.default([]),
+})
+
+export const updateBody = z.strictObject(companyShape).partial()
+
+export interface CompaniesRoutesDependencies extends CredentialDependencies {
+  readonly service: CompaniesService
+}
+
+export function toCreateInput(body: z.infer<typeof createBody>): CreateCompanyInput {
+  return {
+    name: body.name,
+    domain: body.domain,
+    industry: body.industry,
+    description: body.description,
+    stage: body.stage,
+    sizeBand: body.size_band,
+    hq: body.hq,
+    website: body.website,
+    accountType: body.account_type,
+    icpFit: body.icp_fit,
+    techStack: body.tech_stack,
+    summary: body.summary,
+    tags: body.tags,
+  }
+}
+
+export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateCompanyInput {
+  return {
+    ...(body.name === undefined ? {} : { name: body.name }),
+    ...(body.domain === undefined ? {} : { domain: body.domain }),
+    ...(body.industry === undefined ? {} : { industry: body.industry }),
+    ...(body.description === undefined ? {} : { description: body.description }),
+    ...(body.stage === undefined ? {} : { stage: body.stage }),
+    ...(body.size_band === undefined ? {} : { sizeBand: body.size_band }),
+    ...(body.hq === undefined ? {} : { hq: body.hq }),
+    ...(body.website === undefined ? {} : { website: body.website }),
+    ...(body.account_type === undefined ? {} : { accountType: body.account_type }),
+    ...(body.icp_fit === undefined ? {} : { icpFit: body.icp_fit }),
+    ...(body.tech_stack === undefined ? {} : { techStack: body.tech_stack }),
+    ...(body.summary === undefined ? {} : { summary: body.summary }),
+    ...(body.tags === undefined ? {} : { tags: body.tags }),
+  }
+}
+
+export function companyResponse(company: CompanyView): Record<string, unknown> {
+  return {
+    id: company.id,
+    name: company.name,
+    domain: company.domain,
+    industry: company.industry,
+    description: company.description,
+    stage: company.stage,
+    size_band: company.sizeBand,
+    hq: company.hq,
+    website: company.website,
+    account_type: company.accountType,
+    icp_fit: company.icpFit,
+    tech_stack: company.techStack,
+    summary: company.summary,
+    tags: company.tags,
+    created_at: company.createdAt.toISOString(),
+    updated_at: company.updatedAt.toISOString(),
+  }
+}
+
+export function mountCompaniesRoutes(router: Hono, dependencies: CompaniesRoutesDependencies): void {
+  const requireActor = (context: Context): Promise<Actor> => resolveActorFrom(dependencies, context)
+
+  router.get('/companies', async (context) => {
+    const page = await dependencies.service.list(
+      await requireActor(context),
+      {
+        term: context.req.query('q'),
+        personIds: readIdFilter(context, 'person_id'),
+      },
+      readListParameters(context),
+    )
+
+    return context.json(pageBody(page, companyResponse))
+  })
+
+  router.post('/companies', async (context) => {
+    const body = await readJsonBody(context, createBody)
+    const company = await dependencies.service.create(
+      await requireActor(context),
+      toCreateInput(body),
+    )
+
+    return context.json(companyResponse(company), 201)
+  })
+
+  router.get('/companies/:id', async (context) => {
+    const company = await dependencies.service.get(
+      await requireActor(context),
+      context.req.param('id'),
+    )
+
+    return context.json(companyResponse(company))
+  })
+
+  router.patch('/companies/:id', async (context) => {
+    const body = await readJsonBody(context, updateBody)
+    const company = await dependencies.service.update(
+      await requireActor(context),
+      context.req.param('id'),
+      toUpdateInput(body),
+    )
+
+    return context.json(companyResponse(company))
+  })
+
+  router.delete('/companies/:id', async (context) => {
+    await dependencies.service.remove(await requireActor(context), context.req.param('id'))
+
+    return context.body(null, 204)
+  })
+}

package/src/modules/companies/schema.ts

@@ -0,0 +1,66 @@
+import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from '@kelpie/schemas'
+import { index, pgTable, text, unique } from 'drizzle-orm/pg-core'
+
+import {
+  checkOneOf,
+  citext,
+  createdAt,
+  primaryId,
+  searchVector,
+  updatedAt,
+} from '../../lib/columns.ts'
+import type { SearchVectorPart } from '../../lib/columns.ts'
+import { workspaces } from '../workspace/schema.ts'
+
+/**
+ * The fixed value sets come from `@kelpie/schemas`, so this table's check
+ * constraints, this module's Zod enums, and the browser's decoder are one list
+ * rather than three copies. A value the boundary accepts and the check
+ * constraint refuses would be a 500 where a 422 belongs.
+ */
+export { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from '@kelpie/schemas'
+export type { AccountType, CompanyStage, IcpFit, SizeBand } from '@kelpie/schemas'
+
+/** Organisations. `domain` is normalised (no scheme, no path) and compared case-insensitively. */
+export const companies = pgTable(
+  'companies',
+  {
+    id: primaryId(),
+    workspaceId: text('workspace_id')
+      .notNull()
+      .references(() => workspaces.id, { onDelete: 'cascade' }),
+    name: text('name').notNull(),
+    domain: citext('domain'),
+    industry: text('industry'),
+    description: text('description').notNull().default(''),
+    stage: text('stage').notNull(),
+    sizeBand: text('size_band').notNull(),
+    hq: text('hq'),
+    website: text('website'),
+    accountType: text('account_type').notNull(),
+    icpFit: text('icp_fit').notNull(),
+    techStack: text('tech_stack').array().notNull().default([]),
+    summary: text('summary').notNull().default(''),
+    tags: text('tags').array().notNull().default([]),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+    searchVector: searchVector((): readonly SearchVectorPart[] => [
+      { column: companies.name, weight: 'A' },
+      { column: companies.domain, weight: 'B' },
+      { column: companies.industry, weight: 'B' },
+      { column: companies.description, weight: 'B' },
+      { column: companies.summary, weight: 'B' },
+      { column: companies.tags, weight: 'C', array: true },
+      { column: companies.techStack, weight: 'C', array: true },
+    ]),
+  },
+  (table) => [
+    unique('companies_workspace_domain_key').on(table.workspaceId, table.domain),
+    index('companies_workspace_idx').on(table.workspaceId),
+    index('companies_search_idx').using('gin', table.searchVector),
+    checkOneOf('companies_stage_check', table.stage, COMPANY_STAGES),
+    checkOneOf('companies_size_band_check', table.sizeBand, SIZE_BANDS),
+    checkOneOf('companies_account_type_check', table.accountType, ACCOUNT_TYPES),
+    checkOneOf('companies_icp_fit_check', table.icpFit, ICP_FITS),
+  ],
+)

package/src/modules/companies/service.ts

@@ -0,0 +1,267 @@
+import { changedKeys } from '../../lib/changes.ts'
+import { UNIQUE_VIOLATION, isReferenceViolation, postgresErrorCode } from '../../lib/database.ts'
+import type { Database } from '../../lib/database.ts'
+import { AppError } from '../../lib/errors.ts'
+import type { IdFactory } from '../../lib/ids.ts'
+import { normaliseDomain } from '../../lib/normalisation.ts'
+import { mapPage, readListWindow, toPage } from '../../lib/pagination.ts'
+import type { ListQueryParameters, Page } from '../../lib/pagination.ts'
+import type { TransactionScope } from '../../runtime/transaction.ts'
+import type { ActivityRecorder } from '../activities/recorder.ts'
+import { describeCreation, describeUpdate } from '../activities/wording.ts'
+import type { FieldLabels } from '../activities/wording.ts'
+import type { Actor } from '../auth/actor.ts'
+import { requireWorkspaceId } from '../auth/actor.ts'
+import { deleteRecordsAttachedTo } from '../attachedRecords.ts'
+import { referencedElsewhere } from '../references.ts'
+import * as repository from './repository.ts'
+import { COMPANY_SORTS, DEFAULT_COMPANY_SORT } from './repository.ts'
+import type { CompanyFilters, CompanyRecord } from './repository.ts'
+import type { AccountType, CompanyStage, IcpFit, SizeBand } from './schema.ts'
+
+/**
+ * Companies: the organisations behind the people.
+ *
+ * People attach through Position, never through a company id on Person, so
+ * nothing here knows about a person except through that link.
+ */
+
+export interface CompaniesDependencies {
+  readonly db: Database
+  readonly transaction: TransactionScope
+  readonly createId: IdFactory
+  readonly now: () => Date
+  readonly recordActivity: ActivityRecorder
+}
+
+/** What a changed column is called on a timeline. `icpFit` is why these are written out. */
+const COMPANY_FIELD_LABELS: FieldLabels = {
+  name: 'Name',
+  domain: 'Domain',
+  industry: 'Industry',
+  description: 'Description',
+  stage: 'Stage',
+  sizeBand: 'Size',
+  hq: 'Headquarters',
+  website: 'Website',
+  accountType: 'Account type',
+  icpFit: 'ICP fit',
+  techStack: 'Tech stack',
+  summary: 'Summary',
+  tags: 'Tags',
+}
+
+/** A company as the API returns one: the stored row minus the tenancy column. */
+export type CompanyView = Omit<CompanyRecord, 'workspaceId'>
+
+export interface CreateCompanyInput {
+  readonly name: string
+  readonly domain: string | null
+  readonly industry: string | null
+  readonly description: string
+  readonly stage: CompanyStage
+  readonly sizeBand: SizeBand
+  readonly hq: string | null
+  readonly website: string | null
+  readonly accountType: AccountType
+  readonly icpFit: IcpFit
+  readonly techStack: readonly string[]
+  readonly summary: string
+  readonly tags: readonly string[]
+}
+
+/** PATCH semantics: an absent field is left alone, and null clears a nullable one. */
+export type UpdateCompanyInput = Partial<CreateCompanyInput>
+
+export interface CompaniesService {
+  list(actor: Actor, filters: CompanyFilters, query: ListQueryParameters): Promise<Page<CompanyView>>
+  get(actor: Actor, id: string): Promise<CompanyView>
+  create(actor: Actor, input: CreateCompanyInput): Promise<CompanyView>
+  update(actor: Actor, id: string, changes: UpdateCompanyInput): Promise<CompanyView>
+  remove(actor: Actor, id: string): Promise<void>
+}
+
+function toView(record: CompanyRecord): CompanyView {
+  const { workspaceId: _workspaceId, ...view } = record
+
+  return view
+}
+
+/**
+ * The stored form of what the caller sent. A domain arrives however someone
+ * pasted it and is reduced to a host; blank becomes null, because the domain is
+ * unique per workspace and a stored `''` would make the second company without a
+ * website a 409.
+ */
+function toStoredColumns(input: UpdateCompanyInput): Partial<repository.CompanyColumns> {
+  return {
+    ...(input.name === undefined ? {} : { name: input.name }),
+    ...(input.domain === undefined
+      ? {}
+      : { domain: input.domain === null ? null : normaliseDomain(input.domain) }),
+    ...(input.industry === undefined ? {} : { industry: input.industry }),
+    ...(input.description === undefined ? {} : { description: input.description }),
+    ...(input.stage === undefined ? {} : { stage: input.stage }),
+    ...(input.sizeBand === undefined ? {} : { sizeBand: input.sizeBand }),
+    ...(input.hq === undefined ? {} : { hq: input.hq }),
+    ...(input.website === undefined ? {} : { website: input.website }),
+    ...(input.accountType === undefined ? {} : { accountType: input.accountType }),
+    ...(input.icpFit === undefined ? {} : { icpFit: input.icpFit }),
+    ...(input.techStack === undefined ? {} : { techStack: [...input.techStack] }),
+    ...(input.summary === undefined ? {} : { summary: input.summary }),
+    ...(input.tags === undefined ? {} : { tags: [...input.tags] }),
+  }
+}
+
+function duplicateDomain(): AppError {
+  return AppError.conflict('Another company in this workspace already has that domain', [
+    { field: 'domain', message: 'Already in use' },
+  ])
+}
+
+export function createCompaniesService(dependencies: CompaniesDependencies): CompaniesService {
+  async function require(workspaceId: string, id: string): Promise<CompanyRecord> {
+    const company = await repository.findCompany(dependencies.db, workspaceId, id)
+
+    // A company in another workspace is indistinguishable from one that never
+    // existed, per `api.md`.
+    if (company === undefined) {
+      throw AppError.notFound('Company not found')
+    }
+
+    return company
+  }
+
+  return {
+    async list(actor, filters, query) {
+      const workspaceId = requireWorkspaceId(actor)
+      const window = readListWindow(query, COMPANY_SORTS, DEFAULT_COMPANY_SORT)
+      const rows = await repository.listCompanies(dependencies.db, workspaceId, filters, window)
+
+      return mapPage(toPage(rows, window, (company) => company.id), toView)
+    },
+
+    async get(actor, id) {
+      return toView(await require(requireWorkspaceId(actor), id))
+    },
+
+    async create(actor, input) {
+      const workspaceId = requireWorkspaceId(actor)
+      const id = dependencies.createId('company')
+
+      return dependencies.transaction(async ({ tx, events }) => {
+        let created: CompanyRecord
+
+        try {
+          created = await repository.insertCompany(tx, {
+            id,
+            workspaceId,
+            name: input.name,
+            domain: input.domain === null ? null : normaliseDomain(input.domain),
+            industry: input.industry,
+            description: input.description,
+            stage: input.stage,
+            sizeBand: input.sizeBand,
+            hq: input.hq,
+            website: input.website,
+            accountType: input.accountType,
+            icpFit: input.icpFit,
+            techStack: [...input.techStack],
+            summary: input.summary,
+            tags: [...input.tags],
+          })
+        } catch (error: unknown) {
+          if (postgresErrorCode(error) === UNIQUE_VIOLATION) {
+            throw duplicateDomain()
+          }
+
+          throw error
+        }
+
+        await dependencies.recordActivity(tx, workspaceId, actor, {
+          targetType: 'company',
+          targetId: created.id,
+          kind: 'created',
+          ...describeCreation('Company'),
+        })
+
+        events.emit('record.created', { workspaceId, objectType: 'company', recordId: created.id })
+
+        return toView(created)
+      })
+    },
+
+    async update(actor, id, changes) {
+      const workspaceId = requireWorkspaceId(actor)
+      const existing = await require(workspaceId, id)
+      const columns = toStoredColumns(changes)
+      const changed = changedKeys(existing, columns)
+
+      if (changed.length === 0) {
+        return toView(existing)
+      }
+
+      return dependencies.transaction(async ({ tx, events }) => {
+        let updated: CompanyRecord | undefined
+
+        try {
+          updated = await repository.updateCompany(tx, workspaceId, id, {
+            ...columns,
+            updatedAt: dependencies.now(),
+          })
+        } catch (error: unknown) {
+          if (postgresErrorCode(error) === UNIQUE_VIOLATION) {
+            throw duplicateDomain()
+          }
+
+          throw error
+        }
+
+        if (updated === undefined) {
+          throw AppError.notFound('Company not found')
+        }
+
+        await dependencies.recordActivity(tx, workspaceId, actor, {
+          targetType: 'company',
+          targetId: id,
+          kind: 'updated',
+          ...describeUpdate(changed, COMPANY_FIELD_LABELS, existing, columns),
+        })
+
+        events.emit('record.updated', {
+          workspaceId,
+          objectType: 'company',
+          recordId: id,
+          changedFields: changed,
+        })
+
+        return toView(updated)
+      })
+    },
+
+    async remove(actor, id) {
+      const workspaceId = requireWorkspaceId(actor)
+
+      await dependencies.transaction(async ({ tx, events }) => {
+        await require(workspaceId, id)
+
+        // Positions die with the company through their foreign key. Notes,
+        // activities and decisions have none, so they are removed here, in the
+        // same transaction as the delete that may still be refused.
+        await deleteRecordsAttachedTo(tx, workspaceId, 'company', id)
+
+        try {
+          await repository.deleteCompany(tx, workspaceId, id)
+        } catch (error: unknown) {
+          if (isReferenceViolation(error)) {
+            throw referencedElsewhere(error, 'company')
+          }
+
+          throw error
+        }
+
+        events.emit('record.deleted', { workspaceId, objectType: 'company', recordId: id })
+      })
+    },
+  }
+}