@kelpie/server 0.1.0

package/src/modules/pipelines/repository.ts

@@ -0,0 +1,116 @@
+import { and, asc, eq } from 'drizzle-orm'
+import type { SQL } from 'drizzle-orm'
+
+import { integerSort, keysetCondition, orderByWindow, timestampSort } from '../../lib/pagination.ts'
+import type { ListWindow, SortableFields } from '../../lib/pagination.ts'
+import type { Queryable } from '../../runtime/transaction.ts'
+import { pipelineStages } from './schema.ts'
+import type { PipelineKind } from './schema.ts'
+
+export type PipelineStageRecord = typeof pipelineStages.$inferSelect
+
+/** The writable column shape. Services build one of these; nothing else knows the column names. */
+export type PipelineStageColumns = typeof pipelineStages.$inferInsert
+
+export const PIPELINE_STAGE_SORTS: SortableFields<PipelineStageRecord> = {
+  sort_order: integerSort(pipelineStages.sortOrder, (stage) => stage.sortOrder),
+  created_at: timestampSort(pipelineStages.createdAt, (stage) => stage.createdAt),
+  updated_at: timestampSort(pipelineStages.updatedAt, (stage) => stage.updatedAt),
+}
+
+/** Board order, not creation order: a stage list is a board's columns. */
+export const DEFAULT_PIPELINE_STAGE_SORT = 'sort_order'
+
+export interface PipelineStageFilters {
+  /** `?kind=`: one pipeline's stages. Absent lists all four pipelines' stages. */
+  readonly kind?: PipelineKind | undefined
+}
+
+function conditionsFor(workspaceId: string, filters: PipelineStageFilters): (SQL | undefined)[] {
+  return [
+    eq(pipelineStages.workspaceId, workspaceId),
+    filters.kind === undefined ? undefined : eq(pipelineStages.kind, filters.kind),
+  ]
+}
+
+/** @returns Up to `window.fetchLimit` rows: one more than the page, so the caller can tell there is a next one. */
+export function listStages(
+  db: Queryable,
+  workspaceId: string,
+  filters: PipelineStageFilters,
+  window: ListWindow<PipelineStageRecord>,
+): Promise<PipelineStageRecord[]> {
+  return db
+    .select()
+    .from(pipelineStages)
+    .where(and(...conditionsFor(workspaceId, filters), keysetCondition(window, pipelineStages.id)))
+    .orderBy(...orderByWindow(window, pipelineStages.id))
+    .limit(window.fetchLimit)
+}
+
+/**
+ * One pipeline's stages in board order, whole. Reordering, adding, and removing
+ * all work on the full column list, which is small by construction.
+ */
+export function listStagesOfKind(
+  db: Queryable,
+  workspaceId: string,
+  kind: PipelineKind,
+): Promise<PipelineStageRecord[]> {
+  return db
+    .select()
+    .from(pipelineStages)
+    .where(and(eq(pipelineStages.workspaceId, workspaceId), eq(pipelineStages.kind, kind)))
+    .orderBy(asc(pipelineStages.sortOrder), asc(pipelineStages.id))
+}
+
+export async function findStage(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+): Promise<PipelineStageRecord | undefined> {
+  const [found] = await db
+    .select()
+    .from(pipelineStages)
+    .where(and(eq(pipelineStages.workspaceId, workspaceId), eq(pipelineStages.id, id)))
+    .limit(1)
+
+  return found
+}
+
+export async function insertStage(
+  db: Queryable,
+  values: PipelineStageColumns,
+): Promise<PipelineStageRecord> {
+  const [created] = await db.insert(pipelineStages).values(values).returning()
+
+  if (created === undefined) {
+    throw new Error(`Inserting pipeline stage ${values.id} returned no row`)
+  }
+
+  return created
+}
+
+export async function updateStage(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+  changes: Partial<PipelineStageColumns>,
+): Promise<PipelineStageRecord | undefined> {
+  const [updated] = await db
+    .update(pipelineStages)
+    .set(changes)
+    .where(and(eq(pipelineStages.workspaceId, workspaceId), eq(pipelineStages.id, id)))
+    .returning()
+
+  return updated
+}
+
+export async function deleteStage(db: Queryable, workspaceId: string, id: string): Promise<number> {
+  const deleted = await db
+    .delete(pipelineStages)
+    .where(and(eq(pipelineStages.workspaceId, workspaceId), eq(pipelineStages.id, id)))
+    .returning({ id: pipelineStages.id })
+
+  return deleted.length
+}

package/src/modules/pipelines/routes.ts

@@ -0,0 +1,157 @@
+import type { Context, Hono } from 'hono'
+import { z } from 'zod'
+
+import { AppError } from '../../lib/errors.ts'
+import { pageBody, 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 { PIPELINE_KINDS } from './schema.ts'
+import type { PipelineKind } from './schema.ts'
+import type {
+  CreateStageInput,
+  PipelineStageView,
+  PipelineStagesService,
+  UpdateStageInput,
+} from './service.ts'
+
+/** Wire shapes for `/v1/pipeline_stages`. Bodies are strict; an unknown field is a 422, per `api.md`. */
+
+export const createBody = z.strictObject({
+  kind: z.enum(PIPELINE_KINDS),
+  label: z.string().min(1),
+  open: z.boolean().default(true),
+})
+
+/**
+ * `label` renames the column, `slug` never moves (imports alias to it), `open`
+ * flips the Open-scope visibility, and `sort_order` is the stage's new 0-based
+ * position on its board.
+ */
+export const updateBody = z
+  .strictObject({
+    label: z.string().min(1),
+    open: z.boolean(),
+    sort_order: z.number().int().min(0),
+  })
+  .partial()
+
+const kindFilter = z.enum(PIPELINE_KINDS)
+
+export interface PipelinesRoutesDependencies extends CredentialDependencies {
+  readonly service: PipelineStagesService
+}
+
+function readKindFilter(context: Context): PipelineKind | undefined {
+  const raw = context.req.query('kind')
+
+  if (raw === undefined) {
+    return undefined
+  }
+
+  const parsed = kindFilter.safeParse(raw)
+
+  if (!parsed.success) {
+    throw AppError.validationFailed('That pipeline kind does not exist', [
+      { field: 'kind', message: `Use one of: ${PIPELINE_KINDS.join(', ')}` },
+    ])
+  }
+
+  return parsed.data
+}
+
+/** `?move_to=` on DELETE: where the removed stage's records go. */
+function readMoveTo(context: Context): string | undefined {
+  const raw = context.req.query('move_to')
+
+  if (raw === undefined) {
+    return undefined
+  }
+
+  if (raw.length === 0) {
+    throw AppError.validationFailed('"move_to" cannot be blank', [
+      { field: 'move_to', message: 'Expected a stage id' },
+    ])
+  }
+
+  return raw
+}
+
+export function toCreateInput(body: z.infer<typeof createBody>): CreateStageInput {
+  return { kind: body.kind, label: body.label, open: body.open }
+}
+
+export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateStageInput {
+  return {
+    ...(body.label === undefined ? {} : { label: body.label }),
+    ...(body.open === undefined ? {} : { open: body.open }),
+    ...(body.sort_order === undefined ? {} : { sortOrder: body.sort_order }),
+  }
+}
+
+export function stageResponse(stage: PipelineStageView): Record<string, unknown> {
+  return {
+    id: stage.id,
+    kind: stage.kind,
+    slug: stage.slug,
+    label: stage.label,
+    open: stage.open,
+    sort_order: stage.sortOrder,
+    created_at: stage.createdAt.toISOString(),
+    updated_at: stage.updatedAt.toISOString(),
+  }
+}
+
+export function mountPipelinesRoutes(
+  router: Hono,
+  dependencies: PipelinesRoutesDependencies,
+): void {
+  const requireActor = (context: Context): Promise<Actor> => resolveActorFrom(dependencies, context)
+
+  router.get('/pipeline_stages', async (context) => {
+    const page = await dependencies.service.list(
+      await requireActor(context),
+      { kind: readKindFilter(context) },
+      readListParameters(context),
+    )
+
+    return context.json(pageBody(page, stageResponse))
+  })
+
+  router.post('/pipeline_stages', async (context) => {
+    const body = await readJsonBody(context, createBody)
+    const stage = await dependencies.service.create(await requireActor(context), toCreateInput(body))
+
+    return context.json(stageResponse(stage), 201)
+  })
+
+  router.get('/pipeline_stages/:id', async (context) => {
+    const stage = await dependencies.service.get(
+      await requireActor(context),
+      context.req.param('id'),
+    )
+
+    return context.json(stageResponse(stage))
+  })
+
+  router.patch('/pipeline_stages/:id', async (context) => {
+    const body = await readJsonBody(context, updateBody)
+    const stage = await dependencies.service.update(
+      await requireActor(context),
+      context.req.param('id'),
+      toUpdateInput(body),
+    )
+
+    return context.json(stageResponse(stage))
+  })
+
+  router.delete('/pipeline_stages/:id', async (context) => {
+    await dependencies.service.remove(
+      await requireActor(context),
+      context.req.param('id'),
+      readMoveTo(context),
+    )
+
+    return context.body(null, 204)
+  })
+}

package/src/modules/pipelines/schema.ts

@@ -0,0 +1,37 @@
+import { PIPELINE_KINDS } from '@kelpie/schemas'
+import { boolean, index, integer, pgTable, text, unique } from 'drizzle-orm/pg-core'
+
+import { checkOneOf, createdAt, primaryId, updatedAt } from '../../lib/columns.ts'
+import { workspaces } from '../workspace/schema.ts'
+
+export { PIPELINE_KINDS } from '@kelpie/schemas'
+export type { PipelineKind } from '@kelpie/schemas'
+
+/**
+ * Board columns for all four pipelines. `slug` is the stable id imports alias to;
+ * `label` is what the board shows and is free to change.
+ *
+ * Seeded per workspace at creation. Deleting a stage is restricted while records
+ * reference it; the API's remove-with-reassign moves records first.
+ */
+export const pipelineStages = pgTable(
+  'pipeline_stages',
+  {
+    id: primaryId(),
+    workspaceId: text('workspace_id')
+      .notNull()
+      .references(() => workspaces.id, { onDelete: 'cascade' }),
+    kind: text('kind').notNull(),
+    slug: text('slug').notNull(),
+    label: text('label').notNull(),
+    open: boolean('open').notNull().default(true),
+    sortOrder: integer('sort_order').notNull(),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+  },
+  (table) => [
+    unique('pipeline_stages_workspace_kind_slug_key').on(table.workspaceId, table.kind, table.slug),
+    index('pipeline_stages_workspace_kind_idx').on(table.workspaceId, table.kind),
+    checkOneOf('pipeline_stages_kind_check', table.kind, PIPELINE_KINDS),
+  ],
+)

package/src/modules/pipelines/service.ts

@@ -0,0 +1,339 @@
+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 { mapPage, readListWindow, toPage } from '../../lib/pagination.ts'
+import type { ListQueryParameters, Page } from '../../lib/pagination.ts'
+import type { Transaction, TransactionScope } from '../../runtime/transaction.ts'
+import type { ActivityRecorder } from '../activities/recorder.ts'
+import { describeStageChange } from '../activities/wording.ts'
+import type { Actor } from '../auth/actor.ts'
+import { requireWorkspaceId } from '../auth/actor.ts'
+import { referencedElsewhere } from '../references.ts'
+import { reassignStagedRecords } from '../stagedRecords.ts'
+import * as repository from './repository.ts'
+import { DEFAULT_PIPELINE_STAGE_SORT, PIPELINE_STAGE_SORTS } from './repository.ts'
+import type { PipelineStageFilters, PipelineStageRecord } from './repository.ts'
+import { PIPELINE_KINDS } from './schema.ts'
+import type { PipelineKind } from './schema.ts'
+
+/**
+ * Stage configuration for the four pipelines: what the board's columns are.
+ *
+ * Stages are workspace config, not CRM records: changing one writes no activity
+ * and emits no `record.*` event. The exception is remove-with-reassign, where the
+ * records forced out of the removed stage each get the same `stage_changed`
+ * activity and `stage.changed` event a hand move would have produced.
+ */
+
+export interface PipelinesDependencies {
+  readonly db: Database
+  readonly transaction: TransactionScope
+  readonly createId: IdFactory
+  readonly now: () => Date
+  readonly recordActivity: ActivityRecorder
+}
+
+/** A stage as the API returns one: the stored row minus the tenancy column. */
+export type PipelineStageView = Omit<PipelineStageRecord, 'workspaceId'>
+
+export interface CreateStageInput {
+  readonly kind: PipelineKind
+  readonly label: string
+  readonly open: boolean
+}
+
+export interface UpdateStageInput {
+  readonly label?: string | undefined
+  readonly open?: boolean | undefined
+  /** The stage's new position on the board, 0-based. The others shift around it. */
+  readonly sortOrder?: number | undefined
+}
+
+export interface PipelineStagesService {
+  list(
+    actor: Actor,
+    filters: PipelineStageFilters,
+    query: ListQueryParameters,
+  ): Promise<Page<PipelineStageView>>
+  get(actor: Actor, id: string): Promise<PipelineStageView>
+  create(actor: Actor, input: CreateStageInput): Promise<PipelineStageView>
+  update(actor: Actor, id: string, changes: UpdateStageInput): Promise<PipelineStageView>
+  /**
+   * @param moveToId Where the records standing in the removed stage go. Omitted
+   *   is the same as absent: the removal refuses if the stage still holds any.
+   */
+  remove(actor: Actor, id: string, moveToId?: string | undefined): Promise<void>
+}
+
+function toView(record: PipelineStageRecord): PipelineStageView {
+  const { workspaceId: _workspaceId, ...view } = record
+
+  return view
+}
+
+/**
+ * The stored `kind`, narrowed back to the fixed set the check constraint
+ * enforces. A row outside it is corrupt data, so this failing is a 500, not a 4xx.
+ */
+function stageKind(stage: PipelineStageRecord): PipelineKind {
+  const kind = PIPELINE_KINDS.find((candidate) => candidate === stage.kind)
+
+  if (kind === undefined) {
+    throw new Error(`Pipeline stage ${stage.id} has unknown kind "${stage.kind}"`)
+  }
+
+  return kind
+}
+
+/**
+ * The import-alias slug for a new stage, derived from its label the way the
+ * starter slugs are written: lowercase, runs of anything else collapsed to one
+ * underscore. `Term sheet` → `term_sheet`.
+ */
+function slugFromLabel(label: string): string {
+  const slug = label
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/gu, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, '_')
+    .replace(/^_+|_+$/gu, '')
+
+  return slug.length === 0 ? 'stage' : slug
+}
+
+/** `won`, `won_2`, `won_3`: labels may repeat, the import alias may not. */
+function uniqueSlug(taken: ReadonlySet<string>, base: string): string {
+  if (!taken.has(base)) {
+    return base
+  }
+
+  for (let suffix = 2; ; suffix += 1) {
+    const candidate = `${base}_${String(suffix)}`
+
+    if (!taken.has(candidate)) {
+      return candidate
+    }
+  }
+}
+
+function duplicateSlug(): AppError {
+  return AppError.conflict('A stage with that name was just created in this pipeline', [
+    { field: 'label', message: 'Try again' },
+  ])
+}
+
+export function createPipelineStagesService(
+  dependencies: PipelinesDependencies,
+): PipelineStagesService {
+  async function require(workspaceId: string, id: string): Promise<PipelineStageRecord> {
+    const stage = await repository.findStage(dependencies.db, workspaceId, id)
+
+    if (stage === undefined) {
+      throw AppError.notFound('Pipeline stage not found')
+    }
+
+    return stage
+  }
+
+  /**
+   * Renumbers one pipeline to `order`, writing only the rows whose position
+   * moved. Sort orders stay contiguous from 0, which is what lets a PATCHed
+   * `sort_order` mean "position on the board".
+   */
+  async function renumber(
+    tx: Transaction,
+    workspaceId: string,
+    order: readonly PipelineStageRecord[],
+  ): Promise<void> {
+    for (const [index, stage] of order.entries()) {
+      if (stage.sortOrder !== index) {
+        await repository.updateStage(tx, workspaceId, stage.id, {
+          sortOrder: index,
+          updatedAt: dependencies.now(),
+        })
+      }
+    }
+  }
+
+  async function moveToPosition(
+    tx: Transaction,
+    workspaceId: string,
+    stage: PipelineStageRecord,
+    position: number,
+  ): Promise<void> {
+    const rows = await repository.listStagesOfKind(tx, workspaceId, stageKind(stage))
+    const target = rows.find((row) => row.id === stage.id)
+
+    if (target === undefined) {
+      throw AppError.notFound('Pipeline stage not found')
+    }
+
+    if (position >= rows.length) {
+      throw AppError.validationFailed('That position is past the end of the pipeline', [
+        { field: 'sort_order', message: `Use 0 to ${String(rows.length - 1)}` },
+      ])
+    }
+
+    const reordered = rows.filter((row) => row.id !== stage.id)
+
+    reordered.splice(position, 0, target)
+    await renumber(tx, workspaceId, reordered)
+  }
+
+  return {
+    async list(actor, filters, query) {
+      const workspaceId = requireWorkspaceId(actor)
+      const window = readListWindow(query, PIPELINE_STAGE_SORTS, DEFAULT_PIPELINE_STAGE_SORT)
+      const rows = await repository.listStages(dependencies.db, workspaceId, filters, window)
+
+      return mapPage(toPage(rows, window, (stage) => stage.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('pipelineStage')
+
+      return dependencies.transaction(async ({ tx }) => {
+        const rows = await repository.listStagesOfKind(tx, workspaceId, input.kind)
+        const slug = uniqueSlug(new Set(rows.map((row) => row.slug)), slugFromLabel(input.label))
+
+        try {
+          const created = await repository.insertStage(tx, {
+            id,
+            workspaceId,
+            kind: input.kind,
+            slug,
+            label: input.label,
+            open: input.open,
+            sortOrder: (rows.at(-1)?.sortOrder ?? -1) + 1,
+          })
+
+          return toView(created)
+        } catch (error: unknown) {
+          // Two concurrent creates can derive the same slug from the same read.
+          if (postgresErrorCode(error) === UNIQUE_VIOLATION) {
+            throw duplicateSlug()
+          }
+
+          throw error
+        }
+      })
+    },
+
+    async update(actor, id, changes) {
+      const workspaceId = requireWorkspaceId(actor)
+      const existing = await require(workspaceId, id)
+      const columns = {
+        ...(changes.label === undefined ? {} : { label: changes.label }),
+        ...(changes.open === undefined ? {} : { open: changes.open }),
+      }
+      const changed = changedKeys(existing, columns)
+      const position = changes.sortOrder
+
+      if (changed.length === 0 && position === undefined) {
+        return toView(existing)
+      }
+
+      return dependencies.transaction(async ({ tx }) => {
+        if (position !== undefined) {
+          await moveToPosition(tx, workspaceId, existing, position)
+        }
+
+        if (changed.length > 0) {
+          const updated = await repository.updateStage(tx, workspaceId, id, {
+            ...columns,
+            updatedAt: dependencies.now(),
+          })
+
+          if (updated === undefined) {
+            throw AppError.notFound('Pipeline stage not found')
+          }
+
+          return toView(updated)
+        }
+
+        const moved = await repository.findStage(tx, workspaceId, id)
+
+        if (moved === undefined) {
+          throw AppError.notFound('Pipeline stage not found')
+        }
+
+        return toView(moved)
+      })
+    },
+
+    async remove(actor, id, moveToId) {
+      const workspaceId = requireWorkspaceId(actor)
+      const stage = await require(workspaceId, id)
+      const kind = stageKind(stage)
+
+      await dependencies.transaction(async ({ tx, events }) => {
+        const rows = await repository.listStagesOfKind(tx, workspaceId, kind)
+
+        // A pipeline with no stages would leave its records nowhere to sit and
+        // its board nothing to render. The mockup disables the last Remove
+        // button; the API refuses regardless of who is calling.
+        if (rows.length <= 1) {
+          throw AppError.conflict('A pipeline needs at least one stage', [
+            { field: 'id', message: 'This is the last stage of this pipeline' },
+          ])
+        }
+
+        if (moveToId !== undefined) {
+          const moveTo = rows.find((row) => row.id === moveToId)
+
+          if (moveTo === undefined || moveTo.id === stage.id) {
+            throw AppError.validationFailed('Records can only move to another stage of the same pipeline', [
+              { field: 'move_to', message: `Use another ${kind} stage in this workspace` },
+            ])
+          }
+
+          const movedIds = await reassignStagedRecords(tx, kind, {
+            workspaceId,
+            fromStageId: stage.id,
+            toStageId: moveTo.id,
+            movedAt: dependencies.now(),
+          })
+
+          // The same trail a hand move leaves, once per displaced record: the
+          // timeline should say why a deal is suddenly in another column.
+          for (const recordId of movedIds) {
+            await dependencies.recordActivity(tx, workspaceId, actor, {
+              targetType: kind,
+              targetId: recordId,
+              kind: 'stage_changed',
+              ...describeStageChange(stage.label, moveTo.label),
+            })
+            events.emit('stage.changed', {
+              workspaceId,
+              objectType: kind,
+              recordId,
+              fromStageId: stage.id,
+              toStageId: moveTo.id,
+            })
+          }
+        }
+
+        try {
+          await repository.deleteStage(tx, workspaceId, id)
+        } catch (error: unknown) {
+          // No `move_to` and records still in the stage: the restrict foreign
+          // key refuses, and the caller learns what to pass next time.
+          if (isReferenceViolation(error)) {
+            throw referencedElsewhere(error, 'pipeline stage')
+          }
+
+          throw error
+        }
+
+        await renumber(tx, workspaceId, rows.filter((row) => row.id !== id))
+      })
+    },
+  }
+}

package/src/modules/pipelines/tools.ts

@@ -0,0 +1,52 @@
+import { PIPELINE_KINDS } from '@kelpie/schemas'
+import { z } from 'zod'
+
+import type { McpToolRegistry } from '../../runtime/module.ts'
+import { deleteResult, idArg, listWindowShape, registerCrudTools } from '../crudTools.ts'
+import { createBody, stageResponse, toCreateInput, toUpdateInput, updateBody } from './routes.ts'
+import type { PipelineStagesService } from './service.ts'
+
+/** `pipeline_stages_*`. Same schemas and mappers as `/v1/pipeline_stages`. */
+
+const listArgs = z.strictObject({
+  ...listWindowShape,
+  kind: z.enum(PIPELINE_KINDS).optional().describe("One pipeline's stages. Absent lists every pipeline's."),
+})
+
+export function registerPipelineTools(mcp: McpToolRegistry, service: PipelineStagesService): void {
+  registerCrudTools(mcp, {
+    resource: 'pipeline_stages',
+    subject: 'pipeline stage',
+    about:
+      'A column on one of the four kanban boards. Read these to find the stage_id to ' +
+      'move a deal, opportunity, partnership or raise into.',
+    service,
+    render: stageResponse,
+    listArgs,
+    toFilters: (args) => ({ kind: args.kind }),
+    createArgs: createBody,
+    toCreateInput,
+    updateArgs: updateBody.extend({ id: idArg }),
+    toUpdateInput,
+
+    // The one resource whose delete takes more than an id: removing a stage that
+    // still holds records has to say where they go, or it refuses.
+    registerDelete: (registry) => {
+      registry.tool({
+        name: 'pipeline_stages_delete',
+        description:
+          'Delete a pipeline stage. A stage that still holds records refuses unless ' +
+          'move_to names the stage they move to. Mirrors DELETE /v1/pipeline_stages/{id}.',
+        inputSchema: z.strictObject({
+          id: idArg,
+          move_to: idArg.optional().describe('Where the records standing in this stage go.'),
+        }),
+        invoke: async ({ id, move_to: moveTo }, actor) => {
+          await service.remove(actor, id, moveTo)
+
+          return deleteResult(id)
+        },
+      })
+    },
+  })
+}