@kelpie/server 0.1.0

package/src/modules/plans/index.ts

@@ -0,0 +1,39 @@
+import type { KelpieModule } from '../../runtime/module.ts'
+import { mountPlansRoutes } from './routes.ts'
+import * as schema from './schema.ts'
+import { createPlansService } from './service.ts'
+import { registerPlansTools } from './tools.ts'
+
+/**
+ * Plan items: the dated next steps on the four pipelines.
+ *
+ * Requires `workspace` for the owner reference. It does not require
+ * `activities`: a plan item writes no timeline entry, because `ACTIVITY_KINDS`
+ * has no value that describes one.
+ */
+export function createPlansModule(migrationsDirectory: string): KelpieModule {
+  return {
+    id: 'plans',
+    requires: ['workspace'],
+    structural: true,
+
+    register(context) {
+      const service = createPlansService({
+        db: context.db,
+        transaction: context.transaction,
+        createId: context.createId,
+        now: context.now,
+      })
+
+      context.schema(schema, migrationsDirectory)
+
+      context.routes((router) => {
+        mountPlansRoutes(router, { db: context.db, now: context.now, service })
+      })
+
+      registerPlansTools(context.mcp, service)
+
+      return Promise.resolve()
+    },
+  }
+}

package/src/modules/plans/repository.ts

@@ -0,0 +1,174 @@
+import { and, eq, gte, inArray, lte } 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 type { Queryable } from '../../runtime/transaction.ts'
+import { workspaceMembers } from '../workspace/schema.ts'
+import { planItems } from './schema.ts'
+import type { PipelineKind, PlanItemStatus } from './schema.ts'
+
+export type PlanItemRecord = typeof planItems.$inferSelect
+
+/** The writable column shape. Services build one of these; nothing else knows the column names. */
+export type PlanItemColumns = typeof planItems.$inferInsert
+
+/**
+ * The sort fields `?sort=` documents for plan items.
+ *
+ * `date` is a `YYYY-MM-DD` string in and out of the driver, so it sorts as text
+ * and its cursor round-trips as itself. Every column here is non-nullable,
+ * because a keyset cannot seek past a null.
+ */
+export const PLAN_ITEM_SORTS: SortableFields<PlanItemRecord> = {
+  date: textSort(planItems.date, (item) => item.date),
+  created_at: timestampSort(planItems.createdAt, (item) => item.createdAt),
+  updated_at: timestampSort(planItems.updatedAt, (item) => item.updatedAt),
+}
+
+/**
+ * Soonest first. Unlike every other resource, a plan list is read forwards: it
+ * answers "what is next", so the oldest open item belongs at the top.
+ */
+export const DEFAULT_PLAN_ITEM_SORT = 'date'
+
+export interface PlanItemFilters {
+  /** `?target_type=`: one pipeline. The Planning page's type filter. */
+  readonly targetType?: PipelineKind | undefined
+  /** `?target_id=`, repeatable: one record's panel, or a page of records' next steps. */
+  readonly targetIds?: readonly string[] | undefined
+  /** `?status=`, repeatable. Naming the two open ones is how a caller asks for outstanding work. */
+  readonly statuses?: readonly PlanItemStatus[] | undefined
+  /** `?from=`, inclusive `YYYY-MM-DD`. */
+  readonly from?: string | undefined
+  /** `?to=`, inclusive `YYYY-MM-DD`. The calendar asks for one month with the pair. */
+  readonly to?: string | undefined
+}
+
+function conditionsFor(workspaceId: string, filters: PlanItemFilters): (SQL | undefined)[] {
+  return [
+    eq(planItems.workspaceId, workspaceId),
+    filters.targetType === undefined ? undefined : eq(planItems.targetType, filters.targetType),
+    filters.targetIds === undefined ? undefined : inArray(planItems.targetId, filters.targetIds),
+    filters.statuses === undefined ? undefined : inArray(planItems.status, filters.statuses),
+    filters.from === undefined ? undefined : gte(planItems.date, filters.from),
+    filters.to === undefined ? undefined : lte(planItems.date, filters.to),
+  ]
+}
+
+/** @returns Up to `window.fetchLimit` rows: one more than the page, so the caller can tell there is a next one. */
+export function listPlanItems(
+  db: Queryable,
+  workspaceId: string,
+  filters: PlanItemFilters,
+  window: ListWindow<PlanItemRecord>,
+): Promise<PlanItemRecord[]> {
+  return db
+    .select()
+    .from(planItems)
+    .where(and(...conditionsFor(workspaceId, filters), keysetCondition(window, planItems.id)))
+    .orderBy(...orderByWindow(window, planItems.id))
+    .limit(window.fetchLimit)
+}
+
+export async function findPlanItem(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+): Promise<PlanItemRecord | undefined> {
+  const [found] = await db
+    .select()
+    .from(planItems)
+    .where(and(eq(planItems.workspaceId, workspaceId), eq(planItems.id, id)))
+    .limit(1)
+
+  return found
+}
+
+export async function insertPlanItem(
+  db: Queryable,
+  values: PlanItemColumns,
+): Promise<PlanItemRecord> {
+  const [created] = await db.insert(planItems).values(values).returning()
+
+  if (created === undefined) {
+    throw new Error(`Inserting plan item ${values.id} returned no row`)
+  }
+
+  return created
+}
+
+export async function updatePlanItem(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+  changes: Partial<PlanItemColumns>,
+): Promise<PlanItemRecord | undefined> {
+  const [updated] = await db
+    .update(planItems)
+    .set(changes)
+    .where(and(eq(planItems.workspaceId, workspaceId), eq(planItems.id, id)))
+    .returning()
+
+  return updated
+}
+
+export async function deletePlanItem(
+  db: Queryable,
+  workspaceId: string,
+  id: string,
+): Promise<number> {
+  const deleted = await db
+    .delete(planItems)
+    .where(and(eq(planItems.workspaceId, workspaceId), eq(planItems.id, id)))
+    .returning({ id: planItems.id })
+
+  return deleted.length
+}
+
+/**
+ * Removes every plan item attached to a target.
+ *
+ * The target is polymorphic and carries no foreign key, so nothing in the
+ * database deletes these. The service that deletes the target calls this inside
+ * the same transaction (`attachedRecords.ts`).
+ */
+export async function deleteForTarget(
+  db: Queryable,
+  workspaceId: string,
+  targetType: string,
+  targetId: string,
+): Promise<number> {
+  const deleted = await db
+    .delete(planItems)
+    .where(
+      and(
+        eq(planItems.workspaceId, workspaceId),
+        eq(planItems.targetType, targetType),
+        eq(planItems.targetId, targetId),
+      ),
+    )
+    .returning({ id: planItems.id })
+
+  return deleted.length
+}
+
+/** Whether a member belongs to this workspace, for validating `owner_id`. */
+export async function memberExists(
+  db: Queryable,
+  workspaceId: string,
+  memberId: string,
+): Promise<boolean> {
+  const [found] = await db
+    .select({ id: workspaceMembers.id })
+    .from(workspaceMembers)
+    .where(and(eq(workspaceMembers.workspaceId, workspaceId), eq(workspaceMembers.id, memberId)))
+    .limit(1)
+
+  return found !== undefined
+}

package/src/modules/plans/routes.ts

@@ -0,0 +1,212 @@
+import type { Context, Hono } from 'hono'
+import { z } from 'zod'
+
+import { isoDateSchema } from '../../lib/dates.ts'
+import { AppError } from '../../lib/errors.ts'
+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 type { PlanItemFilters } from './repository.ts'
+import { PIPELINE_KINDS, PLAN_ITEM_STATUSES } from './schema.ts'
+import type { PipelineKind, PlanItemStatus } from './schema.ts'
+import type {
+  CreatePlanItemInput,
+  PlanItemView,
+  PlansService,
+  UpdatePlanItemInput,
+} from './service.ts'
+
+/**
+ * Wire shapes for `/v1/plan_items`.
+ *
+ * Bodies are strict: `api.md` makes an unknown field a 422 rather than something
+ * dropped in silence.
+ */
+
+/** The full field set, without defaults. `createBody` adds those; `updateBody` makes it partial. */
+const planItemShape = {
+  date: isoDateSchema,
+  title: z.string().min(1),
+  owner_id: z.string().min(1).nullable(),
+  status: z.enum(PLAN_ITEM_STATUSES),
+}
+
+/**
+ * Only the target, the date, and the title are required. An absent `owner_id`
+ * means unassigned rather than the caller: the panel's own form offers
+ * "Unassigned" as its default, and a plan item is a note of what must happen
+ * before it is a claim about who will do it.
+ */
+export const createBody = z.strictObject({
+  ...planItemShape,
+  target_type: z.enum(PIPELINE_KINDS),
+  target_id: z.string().min(1),
+  owner_id: planItemShape.owner_id.default(null),
+  status: planItemShape.status.default('todo'),
+})
+
+/** The target never moves. Re-filing an item under another record is a delete and a create. */
+export const updateBody = z.strictObject(planItemShape).partial()
+
+export interface PlansRoutesDependencies extends CredentialDependencies {
+  readonly service: PlansService
+}
+
+export function planItemResponse(item: PlanItemView): Record<string, unknown> {
+  return {
+    id: item.id,
+    target_type: item.targetType,
+    target_id: item.targetId,
+    date: item.date,
+    title: item.title,
+    owner_id: item.ownerId,
+    status: item.status,
+    created_at: item.createdAt.toISOString(),
+    updated_at: item.updatedAt.toISOString(),
+  }
+}
+
+export function toCreateInput(body: z.infer<typeof createBody>): CreatePlanItemInput {
+  return {
+    targetType: body.target_type,
+    targetId: body.target_id,
+    date: body.date,
+    title: body.title,
+    ownerId: body.owner_id,
+    status: body.status,
+  }
+}
+
+export function toUpdateInput(body: z.infer<typeof updateBody>): UpdatePlanItemInput {
+  return {
+    ...(body.date === undefined ? {} : { date: body.date }),
+    ...(body.title === undefined ? {} : { title: body.title }),
+    ...(body.owner_id === undefined ? {} : { ownerId: body.owner_id }),
+    ...(body.status === undefined ? {} : { status: body.status }),
+  }
+}
+
+/**
+ * `?target_type=`, one pipeline kind.
+ *
+ * @throws AppError 422 for a kind that is not one of the four. A plan item
+ *   cannot attach to a Person, so answering the person question with an empty
+ *   list would read as "none yet" instead of "that is not a thing".
+ */
+function readTargetType(context: Context): PipelineKind | undefined {
+  const raw = context.req.query('target_type')
+
+  if (raw === undefined) {
+    return undefined
+  }
+
+  const parsed = z.enum(PIPELINE_KINDS).safeParse(raw)
+
+  if (!parsed.success) {
+    throw AppError.validationFailed('That is not a record type a plan item attaches to', [
+      { field: 'target_type', message: `Use one of: ${PIPELINE_KINDS.join(', ')}` },
+    ])
+  }
+
+  return parsed.data
+}
+
+/**
+ * `?status=`, repeatable: `?status=todo&status=in_progress` is how a caller asks
+ * for outstanding work. There is no `open` pseudo-value, because naming the two
+ * real statuses says the same thing without inventing a third.
+ */
+function readStatuses(context: Context): readonly PlanItemStatus[] | undefined {
+  const values = context.req.queries('status')
+
+  if (values === undefined || values.length === 0) {
+    return undefined
+  }
+
+  const parsed = z.array(z.enum(PLAN_ITEM_STATUSES)).safeParse(values)
+
+  if (!parsed.success) {
+    throw AppError.validationFailed('That is not a plan item status', [
+      { field: 'status', message: `Use one of: ${PLAN_ITEM_STATUSES.join(', ')}` },
+    ])
+  }
+
+  return parsed.data
+}
+
+/** `?from=` / `?to=`, inclusive `YYYY-MM-DD` bounds. The month calendar asks with the pair. */
+function readDateBound(context: Context, name: 'from' | 'to'): string | undefined {
+  const raw = context.req.query(name)
+
+  if (raw === undefined) {
+    return undefined
+  }
+
+  const parsed = isoDateSchema.safeParse(raw)
+
+  if (!parsed.success) {
+    throw AppError.validationFailed(`"${name}" is not a date`, [
+      { field: name, message: 'Use YYYY-MM-DD' },
+    ])
+  }
+
+  return parsed.data
+}
+
+function readFilters(context: Context): PlanItemFilters {
+  return {
+    targetType: readTargetType(context),
+    targetIds: readIdFilter(context, 'target_id'),
+    statuses: readStatuses(context),
+    from: readDateBound(context, 'from'),
+    to: readDateBound(context, 'to'),
+  }
+}
+
+export function mountPlansRoutes(router: Hono, dependencies: PlansRoutesDependencies): void {
+  const requireActor = (context: Context): Promise<Actor> => resolveActorFrom(dependencies, context)
+
+  router.get('/plan_items', async (context) => {
+    const page = await dependencies.service.list(
+      await requireActor(context),
+      readFilters(context),
+      readListParameters(context),
+    )
+
+    return context.json(pageBody(page, planItemResponse))
+  })
+
+  router.post('/plan_items', async (context) => {
+    const body = await readJsonBody(context, createBody)
+    const item = await dependencies.service.create(await requireActor(context), toCreateInput(body))
+
+    return context.json(planItemResponse(item), 201)
+  })
+
+  router.get('/plan_items/:id', async (context) => {
+    const item = await dependencies.service.get(
+      await requireActor(context),
+      context.req.param('id'),
+    )
+
+    return context.json(planItemResponse(item))
+  })
+
+  router.patch('/plan_items/:id', async (context) => {
+    const body = await readJsonBody(context, updateBody)
+    const item = await dependencies.service.update(
+      await requireActor(context),
+      context.req.param('id'),
+      toUpdateInput(body),
+    )
+
+    return context.json(planItemResponse(item))
+  })
+
+  router.delete('/plan_items/:id', async (context) => {
+    await dependencies.service.remove(await requireActor(context), context.req.param('id'))
+
+    return context.body(null, 204)
+  })
+}

package/src/modules/plans/schema.ts

@@ -0,0 +1,45 @@
+import { PIPELINE_KINDS, PLAN_ITEM_STATUSES } from '@kelpie/schemas'
+import { date, index, pgTable, text } from 'drizzle-orm/pg-core'
+
+import { checkOneOf, createdAt, primaryId, searchVector, updatedAt } from '../../lib/columns.ts'
+import type { SearchVectorPart } from '../../lib/columns.ts'
+import { workspaceMembers, workspaces } from '../workspace/schema.ts'
+
+/** Re-exported for the routes and service that constrain themselves to this table. */
+export { PIPELINE_KINDS, PLAN_ITEM_STATUSES } from '@kelpie/schemas'
+export type { PipelineKind, PlanItemStatus } from '@kelpie/schemas'
+
+/**
+ * Dated action items on the four pipelines. These replace any next-step text
+ * field: a plan item is queryable, has an owner, and can be overdue.
+ *
+ * The target set is narrower than notes and decisions, which attach to people and
+ * companies too.
+ */
+export const planItems = pgTable(
+  'plan_items',
+  {
+    id: primaryId(),
+    workspaceId: text('workspace_id')
+      .notNull()
+      .references(() => workspaces.id, { onDelete: 'cascade' }),
+    targetType: text('target_type').notNull(),
+    targetId: text('target_id').notNull(),
+    date: date('date').notNull(),
+    title: text('title').notNull(),
+    ownerId: text('owner_id').references(() => workspaceMembers.id, { onDelete: 'restrict' }),
+    status: text('status').notNull().default('todo'),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+    // A plan item is never a search result itself. This vector exists so a search
+    // for a planned step finds the Deal, Opportunity or Raise it sits on.
+    searchVector: searchVector((): readonly SearchVectorPart[] => [{ column: planItems.title, weight: 'A' }]),
+  },
+  (table) => [
+    index('plan_items_target_idx').on(table.workspaceId, table.targetType, table.targetId),
+    index('plan_items_date_idx').on(table.workspaceId, table.date),
+    index('plan_items_search_idx').using('gin', table.searchVector),
+    checkOneOf('plan_items_target_type_check', table.targetType, PIPELINE_KINDS),
+    checkOneOf('plan_items_status_check', table.status, PLAN_ITEM_STATUSES),
+  ],
+)

package/src/modules/plans/service.ts

@@ -0,0 +1,223 @@
+import { changedKeys } from '../../lib/changes.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 { TransactionScope } from '../../runtime/transaction.ts'
+import type { Actor } from '../auth/actor.ts'
+import { requireWorkspaceId } from '../auth/actor.ts'
+import { targetExists } from '../recordTargets.ts'
+import * as repository from './repository.ts'
+import { DEFAULT_PLAN_ITEM_SORT, PLAN_ITEM_SORTS } from './repository.ts'
+import type { PlanItemFilters, PlanItemRecord } from './repository.ts'
+import type { PipelineKind, PlanItemStatus } from './schema.ts'
+
+/**
+ * Plan items: the dated next steps on a Deal, Opportunity, Raise or Partnership.
+ *
+ * The target is polymorphic and has no foreign key, so this service is what
+ * refuses a plan item attached to an id that does not exist or belongs to another
+ * workspace. Nothing in the database would.
+ *
+ * No activity rows. `ACTIVITY_KINDS` carries nothing that describes a plan item,
+ * and filing one under `updated` would put a sentence on a timeline about a
+ * record the timeline is not for. Adding a kind is a check-constraint migration
+ * and belongs to whichever feature decides plan history is worth keeping.
+ */
+
+export interface PlansDependencies {
+  readonly db: Database
+  readonly transaction: TransactionScope
+  readonly createId: IdFactory
+  readonly now: () => Date
+}
+
+/** A plan item as the API returns one: the stored row minus the tenancy column. */
+export type PlanItemView = Omit<PlanItemRecord, 'workspaceId'>
+
+export interface CreatePlanItemInput {
+  readonly targetType: PipelineKind
+  readonly targetId: string
+  /** `YYYY-MM-DD`. Validated as a real calendar date at the boundary. */
+  readonly date: string
+  readonly title: string
+  /**
+   * Absent means unassigned, which is what the panel's own form offers. Unlike a
+   * Deal, a plan item does not acquire the caller as its owner: writing down what
+   * has to happen is not the same as volunteering to do it.
+   */
+  readonly ownerId: string | null
+  readonly status: PlanItemStatus
+}
+
+/** PATCH semantics: an absent field is left alone, and null clears the owner. */
+export interface UpdatePlanItemInput {
+  readonly date?: string | undefined
+  readonly title?: string | undefined
+  readonly ownerId?: string | null | undefined
+  readonly status?: PlanItemStatus | undefined
+}
+
+export interface PlansService {
+  list(
+    actor: Actor,
+    filters: PlanItemFilters,
+    query: ListQueryParameters,
+  ): Promise<Page<PlanItemView>>
+  get(actor: Actor, id: string): Promise<PlanItemView>
+  create(actor: Actor, input: CreatePlanItemInput): Promise<PlanItemView>
+  update(actor: Actor, id: string, changes: UpdatePlanItemInput): Promise<PlanItemView>
+  remove(actor: Actor, id: string): Promise<void>
+}
+
+function toView(record: PlanItemRecord): PlanItemView {
+  const { workspaceId: _workspaceId, ...view } = record
+
+  return view
+}
+
+export function createPlansService(dependencies: PlansDependencies): PlansService {
+  async function require(workspaceId: string, id: string): Promise<PlanItemRecord> {
+    const item = await repository.findPlanItem(dependencies.db, workspaceId, id)
+
+    // A plan item in another workspace is indistinguishable from one that never
+    // existed, per `api.md`.
+    if (item === undefined) {
+      throw AppError.notFound('Plan item not found')
+    }
+
+    return item
+  }
+
+  async function requireTarget(
+    workspaceId: string,
+    targetType: PipelineKind,
+    targetId: string,
+  ): Promise<void> {
+    if (!(await targetExists(dependencies.db, workspaceId, targetType, targetId))) {
+      throw AppError.notFound('Record not found')
+    }
+  }
+
+  async function requireOwner(workspaceId: string, ownerId: string): Promise<void> {
+    if (!(await repository.memberExists(dependencies.db, workspaceId, ownerId))) {
+      throw AppError.notFound('Team member not found')
+    }
+  }
+
+  return {
+    async list(actor, filters, query) {
+      const workspaceId = requireWorkspaceId(actor)
+      const window = readListWindow(query, PLAN_ITEM_SORTS, DEFAULT_PLAN_ITEM_SORT)
+      const rows = await repository.listPlanItems(dependencies.db, workspaceId, filters, window)
+
+      return mapPage(
+        toPage(rows, window, (item) => item.id),
+        toView,
+      )
+    },
+
+    async get(actor, id) {
+      return toView(await require(requireWorkspaceId(actor), id))
+    },
+
+    async create(actor, input) {
+      const workspaceId = requireWorkspaceId(actor)
+
+      await requireTarget(workspaceId, input.targetType, input.targetId)
+
+      if (input.ownerId !== null) {
+        await requireOwner(workspaceId, input.ownerId)
+      }
+
+      const id = dependencies.createId('planItem')
+
+      return dependencies.transaction(async ({ tx, events }) => {
+        const created = await repository.insertPlanItem(tx, {
+          id,
+          workspaceId,
+          targetType: input.targetType,
+          targetId: input.targetId,
+          date: input.date,
+          title: input.title,
+          ownerId: input.ownerId,
+          status: input.status,
+        })
+
+        // The event fires whenever an item enters `done`, including one recorded
+        // as already finished. A consumer watching for completed work cares that
+        // the work is done, not whether it passed through `todo` on the way.
+        if (created.status === 'done') {
+          events.emit('plan.completed', {
+            workspaceId,
+            planItemId: created.id,
+            targetType: created.targetType,
+            targetId: created.targetId,
+          })
+        }
+
+        return toView(created)
+      })
+    },
+
+    async update(actor, id, changes) {
+      const workspaceId = requireWorkspaceId(actor)
+      const existing = await require(workspaceId, id)
+
+      if (typeof changes.ownerId === 'string' && changes.ownerId !== existing.ownerId) {
+        await requireOwner(workspaceId, changes.ownerId)
+      }
+
+      const columns: Partial<repository.PlanItemColumns> = {
+        ...(changes.date === undefined ? {} : { date: changes.date }),
+        ...(changes.title === undefined ? {} : { title: changes.title }),
+        ...(changes.ownerId === undefined ? {} : { ownerId: changes.ownerId }),
+        ...(changes.status === undefined ? {} : { status: changes.status }),
+      }
+      const changed = changedKeys(existing, columns)
+
+      // A PATCH that changes nothing is not a write. Bumping `updated_at` for it
+      // would make the item look freshly touched to anything sorting by it.
+      if (changed.length === 0) {
+        return toView(existing)
+      }
+
+      return dependencies.transaction(async ({ tx, events }) => {
+        const updated = await repository.updatePlanItem(tx, workspaceId, id, {
+          ...columns,
+          updatedAt: dependencies.now(),
+        })
+
+        if (updated === undefined) {
+          throw AppError.notFound('Plan item not found')
+        }
+
+        // On the transition only. Re-sending `done` on a finished item changes
+        // nothing, and it is caught above before it reaches here.
+        if (changed.includes('status') && updated.status === 'done') {
+          events.emit('plan.completed', {
+            workspaceId,
+            planItemId: updated.id,
+            targetType: updated.targetType,
+            targetId: updated.targetId,
+          })
+        }
+
+        return toView(updated)
+      })
+    },
+
+    async remove(actor, id) {
+      const workspaceId = requireWorkspaceId(actor)
+
+      // No event. The catalog has `plan.completed` and nothing for a plan item
+      // going away, and inventing a name here would be one the webhooks engine
+      // has never been told about.
+      await dependencies.transaction(async ({ tx }) => {
+        await require(workspaceId, id)
+        await repository.deletePlanItem(tx, workspaceId, id)
+      })
+    },
+  }
+}