@crombolo/data 0.12.1 → 0.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crombolo/data",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "description": "SQLite and Postgres storage for crombolo: schema, migrations and repositories.",
   "license": "MIT",
   "author": "Crombolo",
@@ -28,6 +28,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@crombolo/core": "0.12.1"
+    "@crombolo/core": "0.13.1"
   }
 }

package/src/index.ts

@@ -12,6 +12,7 @@ export * from './migrations.ts'
 export * from './node-ref.ts'
 export * from './pending.ts'
 export * from './relations.ts'
+export * from './repositories/approvals.ts'
 export * from './repositories/bundles.ts'
 export * from './repositories/content-types.ts'
 export * from './repositories/data-types.ts'
@@ -38,6 +39,7 @@ export * from './repositories/transfer-runs.ts'
 export * from './repositories/user-data.ts'
 export * from './repositories/users.ts'
 export * from './repositories/webhooks.ts'
+export * from './schema/approvals.ts'
 export * from './schema/assistant.ts'
 export * from './schema/audit-log.ts'
 export * from './schema/built-in-content-types.ts'
@@ -81,3 +83,4 @@ export * from './search-text.ts'
 export * from './setup.ts'
 export * from './tree-invariants.ts'
 export * from './url-options.ts'
+export * from './workflow-store.ts'

package/src/repositories/approvals.ts

@@ -0,0 +1,277 @@
+/**
+ * Approval requests (story 028): a page sent for approval, the stages it has
+ * reached, and its history. What the rules decide is the engine's
+ * (`packages/server/src/approvals.ts`); this only keeps the record.
+ * docs/workflows.md.
+ */
+import { normaliseUuid, type SchemaWorkflow } from '@crombolo/core'
+import type { Db } from '../database.ts'
+import { DbDate } from '../dialect.ts'
+
+export type ApprovalAction = 'publish' | 'unpublish'
+export type ApprovalState = 'waiting' | 'approved' | 'sent-back' | 'withdrawn'
+export type ApprovalStepState = 'waiting' | 'approved' | 'sent-back' | 'discarded'
+export type ApprovalHistoryKind =
+  | 'sent'
+  | 'approved'
+  | 'sent-back'
+  | 'withdrawn'
+  | 'edited'
+  | 'restarted'
+  | 'published'
+  | 'unpublished'
+
+export interface ApprovalRequest {
+  id: number
+  key: string
+  nodeKey: string
+  /** Null for the invariant variant, or the whole page. */
+  cultures: string[] | null
+  action: ApprovalAction
+  /** The page's head event when it was sent, or after the last edit the workflow let through. */
+  eventId: number | null
+  workflowKey: string
+  workflowVersion: string
+  /** The workflow as it stood when the request started, or was restarted. */
+  workflow: SchemaWorkflow
+  state: ApprovalState
+  /** The user's key. */
+  requestedBy: string
+  requestedAt: Date
+  finishedAt: Date | null
+}
+
+export interface ApprovalStep {
+  id: number
+  requestId: number
+  stage: string
+  state: ApprovalStepState
+  reachedAt: Date
+  doneAt: Date | null
+}
+
+export interface ApprovalHistoryEntry {
+  id: number
+  requestId: number
+  /** The stage visit it belongs to: approvals count only toward the visit they were given in. */
+  stepId: number | null
+  stage: string | null
+  kind: ApprovalHistoryKind
+  userKey: string | null
+  comment: string | null
+  createDate: Date
+}
+
+const requestFrom = (row: Record<string, unknown>): ApprovalRequest => ({
+  id: Number(row.id),
+  key: normaliseUuid(String(row.key)),
+  nodeKey: normaliseUuid(String(row.node_key)),
+  cultures: row.cultures ? (JSON.parse(String(row.cultures)) as string[]) : null,
+  action: row.action === 'unpublish' ? 'unpublish' : 'publish',
+  eventId: row.event_id === null || row.event_id === undefined ? null : Number(row.event_id),
+  workflowKey: String(row.workflow_key),
+  workflowVersion: String(row.workflow_version),
+  workflow: JSON.parse(String(row.workflow)) as SchemaWorkflow,
+  state: String(row.state) as ApprovalState,
+  requestedBy: normaliseUuid(String(row.requested_by)),
+  requestedAt: DbDate.fromDb(row.requested_at) ?? new Date(0),
+  finishedAt: DbDate.fromDb(row.finished_at) ?? null,
+})
+
+const stepFrom = (row: Record<string, unknown>): ApprovalStep => ({
+  id: Number(row.id),
+  requestId: Number(row.request_id),
+  stage: String(row.stage),
+  state: String(row.state) as ApprovalStepState,
+  reachedAt: DbDate.fromDb(row.reached_at) ?? new Date(0),
+  doneAt: DbDate.fromDb(row.done_at) ?? null,
+})
+
+const historyFrom = (row: Record<string, unknown>): ApprovalHistoryEntry => ({
+  id: Number(row.id),
+  requestId: Number(row.request_id),
+  stepId: row.step_id === null || row.step_id === undefined ? null : Number(row.step_id),
+  stage: row.stage === null || row.stage === undefined ? null : String(row.stage),
+  kind: String(row.kind) as ApprovalHistoryKind,
+  userKey:
+    row.user_key === null || row.user_key === undefined
+      ? null
+      : normaliseUuid(String(row.user_key)),
+  comment: row.comment === null || row.comment === undefined ? null : String(row.comment),
+  createDate: DbDate.fromDb(row.create_date) ?? new Date(0),
+})
+
+/** The workflow's identity on a request: its key, or its alias when it has none. Pure. */
+export const workflowIdentity = (workflow: SchemaWorkflow): string => workflow.key ?? workflow.alias
+
+export class ApprovalRepository {
+  #db: Db
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  async create(input: {
+    nodeKey: string
+    cultures: string[] | null
+    action: ApprovalAction
+    eventId: number | null
+    workflow: SchemaWorkflow
+    workflowVersion: string
+    /** The user's key. */
+    requestedBy: string
+  }): Promise<ApprovalRequest> {
+    const key = crypto.randomUUID()
+    await this.#db.exec(
+      `INSERT INTO approval_request (key, node_key, cultures, action, event_id, workflow_key,
+         workflow_version, workflow, state, requested_by, requested_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'waiting', ?, ?)`,
+      [
+        key,
+        normaliseUuid(input.nodeKey),
+        input.cultures ? JSON.stringify(input.cultures) : null,
+        input.action,
+        input.eventId,
+        workflowIdentity(input.workflow),
+        input.workflowVersion,
+        JSON.stringify(input.workflow),
+        normaliseUuid(input.requestedBy),
+        DbDate.toDb(new Date()),
+      ],
+    )
+    return (await this.byKey(key)) as ApprovalRequest
+  }
+
+  async byKey(key: string): Promise<ApprovalRequest | undefined> {
+    const rows = await this.#db.query('SELECT * FROM approval_request WHERE key = ?', [
+      normaliseUuid(key),
+    ])
+    return rows[0] ? requestFrom(rows[0]) : undefined
+  }
+
+  /** The request a page is waiting on, if any: at most one at a time. */
+  async waitingFor(nodeKey: string): Promise<ApprovalRequest | undefined> {
+    const rows = await this.#db.query(
+      "SELECT * FROM approval_request WHERE node_key = ? AND state = 'waiting' ORDER BY id DESC",
+      [normaliseUuid(nodeKey)],
+    )
+    return rows[0] ? requestFrom(rows[0]) : undefined
+  }
+
+  /** A page's requests, newest first. */
+  async forNode(nodeKey: string, limit = 20): Promise<ApprovalRequest[]> {
+    const rows = await this.#db.query(
+      'SELECT * FROM approval_request WHERE node_key = ? ORDER BY id DESC LIMIT ?',
+      [normaliseUuid(nodeKey), limit],
+    )
+    return rows.map(requestFrom)
+  }
+
+  /** Every request still waiting, oldest first. */
+  async waiting(): Promise<ApprovalRequest[]> {
+    const rows = await this.#db.query(
+      "SELECT * FROM approval_request WHERE state = 'waiting' ORDER BY id",
+    )
+    return rows.map(requestFrom)
+  }
+
+  /** Requests that have finished, newest first. */
+  async finished(skip: number, take: number): Promise<{ total: number; items: ApprovalRequest[] }> {
+    const counted = await this.#db.query<{ n: number }>(
+      "SELECT COUNT(*) AS n FROM approval_request WHERE state <> 'waiting'",
+    )
+    const rows = await this.#db.query(
+      "SELECT * FROM approval_request WHERE state <> 'waiting' ORDER BY id DESC LIMIT ? OFFSET ?",
+      [take, skip],
+    )
+    return { total: Number(counted[0]?.n ?? 0), items: rows.map(requestFrom) }
+  }
+
+  async waitingUnder(workflowKey: string): Promise<ApprovalRequest[]> {
+    const rows = await this.#db.query(
+      "SELECT * FROM approval_request WHERE workflow_key = ? AND state = 'waiting' ORDER BY id",
+      [workflowKey],
+    )
+    return rows.map(requestFrom)
+  }
+
+  async setState(id: number, state: ApprovalState): Promise<void> {
+    await this.#db.exec('UPDATE approval_request SET state = ?, finished_at = ? WHERE id = ?', [
+      state,
+      state === 'waiting' ? null : DbDate.toDb(new Date()),
+      id,
+    ])
+  }
+
+  async setEvent(id: number, eventId: number | null): Promise<void> {
+    await this.#db.exec('UPDATE approval_request SET event_id = ? WHERE id = ?', [eventId, id])
+  }
+
+  /**
+   * Puts a request under another version of its workflow, starting over: its
+   * stage visits are cleared, and its history keeps what happened.
+   */
+  async rebase(id: number, workflow: SchemaWorkflow, version: string): Promise<void> {
+    await this.#db.exec(
+      'UPDATE approval_request SET workflow = ?, workflow_version = ? WHERE id = ?',
+      [JSON.stringify(workflow), version, id],
+    )
+    await this.#db.exec('DELETE FROM approval_step WHERE request_id = ?', [id])
+  }
+
+  async steps(requestId: number): Promise<ApprovalStep[]> {
+    const rows = await this.#db.query(
+      'SELECT * FROM approval_step WHERE request_id = ? ORDER BY id',
+      [requestId],
+    )
+    return rows.map(stepFrom)
+  }
+
+  async addStep(requestId: number, stage: string): Promise<number> {
+    const rows = await this.#db.query<{ id: number }>(
+      "INSERT INTO approval_step (request_id, stage, state, reached_at) VALUES (?, ?, 'waiting', ?) RETURNING id",
+      [requestId, stage, DbDate.toDb(new Date())],
+    )
+    return Number(rows[0]?.id)
+  }
+
+  async setStepState(id: number, state: ApprovalStepState): Promise<void> {
+    await this.#db.exec('UPDATE approval_step SET state = ?, done_at = ? WHERE id = ?', [
+      state,
+      state === 'waiting' ? null : DbDate.toDb(new Date()),
+      id,
+    ])
+  }
+
+  async record(
+    requestId: number,
+    entry: {
+      kind: ApprovalHistoryKind
+      stepId?: number | null
+      stage?: string | null
+      userKey?: string | null
+      comment?: string | null
+    },
+  ): Promise<void> {
+    await this.#db.exec(
+      `INSERT INTO approval_history (request_id, step_id, stage, kind, user_key, comment, create_date)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        requestId,
+        entry.stepId ?? null,
+        entry.stage ?? null,
+        entry.kind,
+        entry.userKey ? normaliseUuid(entry.userKey) : null,
+        entry.comment ?? null,
+        DbDate.toDb(new Date()),
+      ],
+    )
+  }
+
+  async history(requestId: number): Promise<ApprovalHistoryEntry[]> {
+    const rows = await this.#db.query(
+      'SELECT * FROM approval_history WHERE request_id = ? ORDER BY id',
+      [requestId],
+    )
+    return rows.map(historyFrom)
+  }
+}

package/src/repositories/redirects.ts

@@ -163,55 +163,40 @@ export class RedirectRepository {
   /**
    * Stores a rule, replacing any existing one matching the same thing. The
    * returned row carries the key, which is a fresh one only when the rule is new.
+   *
+   * One statement, not a read then a write: two nodes recording the same retired
+   * route at once would both find nothing and the second insert would hit the
+   * unique index. The upsert lets the database decide which one is new.
    */
   async save(input: RedirectInput): Promise<RedirectRow> {
     const hash = matchHash(input)
     const now = new Date()
-    return this.#db.transaction(async (tx) => {
-      const existing = await tx.query<{ key: string }>(
-        'SELECT key FROM redirect_url WHERE match_hash = ?',
-        [hash],
-      )
-      if (existing[0]) {
-        const key = normaliseUuid(String(existing[0].key))
-        await tx.exec(
-          `UPDATE redirect_url
-              SET target_kind = ?, target = ?, status_code = ?, sort_order = ?, create_date = ?
-            WHERE key = ?`,
-          [
-            input.targetKind,
-            input.target,
-            input.statusCode,
-            input.sortOrder,
-            DbDate.toDb(now),
-            key,
-          ],
-        )
-        return { ...input, key, createDate: now }
-      }
-      const key = crypto.randomUUID()
-      await tx.exec(
-        `INSERT INTO redirect_url
-           (key, source, match_kind, pattern, root_key, culture,
-            target_kind, target, status_code, sort_order, match_hash, create_date)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          key,
-          input.source,
-          input.matchKind,
-          input.pattern,
-          input.rootKey,
-          input.culture,
-          input.targetKind,
-          input.target,
-          input.statusCode,
-          input.sortOrder,
-          hash,
-          DbDate.toDb(now),
-        ],
-      )
-      return { ...input, key, createDate: now }
-    })
+    const rows = await this.#db.query<{ key: string }>(
+      `INSERT INTO redirect_url
+         (key, source, match_kind, pattern, root_key, culture,
+          target_kind, target, status_code, sort_order, match_hash, create_date)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (match_hash) DO UPDATE SET
+         target_kind = excluded.target_kind, target = excluded.target,
+         status_code = excluded.status_code, sort_order = excluded.sort_order,
+         create_date = excluded.create_date
+       RETURNING key`,
+      [
+        crypto.randomUUID(),
+        input.source,
+        input.matchKind,
+        input.pattern,
+        input.rootKey,
+        input.culture,
+        input.targetKind,
+        input.target,
+        input.statusCode,
+        input.sortOrder,
+        hash,
+        DbDate.toDb(now),
+      ],
+    )
+    return { ...input, key: normaliseUuid(String(rows[0]?.key)), createDate: now }
   }
 
   /** Deletes one rule. `false` means there was nothing with that key. */

package/src/schema/approvals.ts

@@ -0,0 +1,77 @@
+/**
+ * Migration 038 — approval requests (story 028): a request per page sent for
+ * approval, a row per stage it reaches, and its history. The workflow it runs
+ * under is copied onto the request, so a workflow changed later does not
+ * change one already in flight unless the workflow says so. Also gives the
+ * groups that edit content the Workflow section. docs/workflows.md.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_DELIVERY_MEMBER_TOKENS } from './delivery-member-tokens.ts'
+
+export const STATE_APPROVALS = '{8e4c0a3d-0038-4b62-9c07-3d5f2b0e6c48}'
+
+/** The section the Workflow screens live in, given where content is edited. */
+export const WORKFLOW_SECTION_GROUPS = ['admin', 'editor', 'writer']
+
+export const approvalsMigration: Migration = {
+  from: STATE_DELIVERY_MEMBER_TOKENS,
+  to: STATE_APPROVALS,
+  name: 'AddApprovals',
+  kind: 'expand',
+  release: '0.13.1',
+  async up(db: Db) {
+    const t = db.dialect.types
+    await db.exec(
+      `CREATE TABLE approval_request (
+         id ${t.identity},
+         key ${t.uuid} NOT NULL,
+         node_key ${t.uuid} NOT NULL,
+         cultures ${t.text},
+         action ${t.varchar(16)} NOT NULL,
+         event_id ${t.bigint},
+         workflow_key ${t.varchar(64)} NOT NULL,
+         workflow_version ${t.varchar(32)} NOT NULL,
+         workflow ${t.json} NOT NULL,
+         state ${t.varchar(16)} NOT NULL,
+         requested_by ${t.varchar(64)} NOT NULL,
+         requested_at ${t.timestamp} NOT NULL,
+         finished_at ${t.timestamp}
+       )`,
+    )
+    await db.exec('CREATE UNIQUE INDEX ux_approval_request_key ON approval_request (key)')
+    await db.exec('CREATE INDEX ix_approval_request_node ON approval_request (node_key, state)')
+    await db.exec(
+      `CREATE TABLE approval_step (
+         id ${t.identity},
+         request_id ${t.integer} NOT NULL,
+         stage ${t.varchar(64)} NOT NULL,
+         state ${t.varchar(16)} NOT NULL,
+         reached_at ${t.timestamp} NOT NULL,
+         done_at ${t.timestamp}
+       )`,
+    )
+    await db.exec('CREATE INDEX ix_approval_step_request ON approval_step (request_id, state)')
+    await db.exec(
+      `CREATE TABLE approval_history (
+         id ${t.identity},
+         request_id ${t.integer} NOT NULL,
+         step_id ${t.integer},
+         stage ${t.varchar(64)},
+         kind ${t.varchar(16)} NOT NULL,
+         user_key ${t.varchar(64)},
+         comment ${t.text},
+         create_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec('CREATE INDEX ix_approval_history_request ON approval_history (request_id)')
+    for (const alias of WORKFLOW_SECTION_GROUPS)
+      await db.exec(
+        `INSERT INTO user_group_section (user_group_id, app_alias)
+         SELECT g.id, 'workflow' FROM user_group g
+         WHERE g.alias = ? AND NOT EXISTS (
+           SELECT 1 FROM user_group_section s WHERE s.user_group_id = g.id AND s.app_alias = 'workflow')`,
+        [alias],
+      )
+  },
+}

package/src/schema/plan.ts

@@ -11,7 +11,9 @@
  * may only ship in a major (`x.0.0`), because every minor and patch is rolled
  * under live nodes. The first contract will therefore name 1.0.0 at the earliest.
  */
+
 import { MigrationPlan } from '../migrations.ts'
+import { approvalsMigration } from './approvals.ts'
 import { assistantMigration } from './assistant.ts'
 import { auditLogMigration } from './audit-log.ts'
 import { bundleComponentsMigration } from './bundle-components.ts'
@@ -88,4 +90,5 @@ export const cromboloPlan = new MigrationPlan([
   webhooksMigration,
   transferAnswersMigration,
   deliveryMemberTokensMigration,
+  approvalsMigration,
 ])

package/src/schema/seed.ts

@@ -160,6 +160,7 @@ export const BUILT_IN_GROUPS = [
       'forms',
       'translation',
       'library',
+      'workflow',
     ],
   },
   {
@@ -169,7 +170,7 @@ export const BUILT_IN_GROUPS = [
     name: 'Writers',
     icon: 'icon-edit',
     hasAccessToAllLanguages: true,
-    sections: ['content', 'library'],
+    sections: ['content', 'library', 'workflow'],
   },
   {
     id: 3,
@@ -178,7 +179,7 @@ export const BUILT_IN_GROUPS = [
     name: 'Editors',
     icon: 'icon-tools',
     hasAccessToAllLanguages: true,
-    sections: ['content', 'media', 'forms', 'library'],
+    sections: ['content', 'media', 'forms', 'library', 'workflow'],
   },
   {
     id: 4,

package/src/workflow-store.ts

@@ -0,0 +1,114 @@
+/**
+ * The approval workflows as last synced from `schema/workflows/` (story 028),
+ * each with its version, so a running node reads them without the files and a
+ * sync can tell which changed. docs/workflows.md.
+ */
+import { type SchemaWorkflow, startStages } from '@crombolo/core'
+import type { Db } from './database.ts'
+import { ApprovalRepository } from './repositories/approvals.ts'
+
+export const WORKFLOWS_KEY = 'crombolo:workflows'
+
+export interface StoredWorkflow {
+  workflow: SchemaWorkflow
+  version: string
+}
+
+/** Stored workflows read leniently: anything unreadable is none. Pure. */
+export function parseStoredWorkflows(value: string | undefined): StoredWorkflow[] {
+  if (!value) return []
+  try {
+    const parsed = JSON.parse(value) as unknown
+    return Array.isArray(parsed)
+      ? parsed.filter(
+          (w): w is StoredWorkflow =>
+            !!w && typeof w === 'object' && 'workflow' in w && 'version' in w,
+        )
+      : []
+  } catch {
+    return []
+  }
+}
+
+export async function readWorkflows(db: Db): Promise<StoredWorkflow[]> {
+  const rows = await db.query<{ value: string }>('SELECT value FROM key_value WHERE key = ?', [
+    WORKFLOWS_KEY,
+  ])
+  return parseStoredWorkflows(rows[0]?.value)
+}
+
+/** Stores the workflows; answers what was there before. */
+export async function writeWorkflows(
+  db: Db,
+  workflows: readonly StoredWorkflow[],
+): Promise<StoredWorkflow[]> {
+  return db.transaction(async (tx) => {
+    const before = await readWorkflows(tx)
+    const value = JSON.stringify(workflows)
+    const now = tx.dialect.now()
+    const updated = await tx.query<{ key: string }>(
+      `UPDATE key_value SET value = ?, update_date = ${now} WHERE key = ? RETURNING key`,
+      [value, WORKFLOWS_KEY],
+    )
+    if (updated.length === 0)
+      await tx.exec(`INSERT INTO key_value (key, value, update_date) VALUES (?, ?, ${now})`, [
+        WORKFLOWS_KEY,
+        value,
+      ])
+    return before
+  })
+}
+
+export interface WorkflowSyncReport {
+  /** Aliases whose meaning changed, or that are new or gone. */
+  changed: string[]
+  /** What `on-change` did to requests in flight, by request key. */
+  requests: Array<{ key: string; workflow: string; outcome: 'kept' | 'restarted' | 'withdrawn' }>
+}
+
+/**
+ * Stores the workflows and applies each changed one's `on-change` to the
+ * requests in flight under it: `keep` leaves them on the version they started
+ * with, `restart` starts them again from the first stage of the new one, and
+ * `withdraw` ends them. A workflow that is gone cannot be restarted under, so
+ * its requests are kept or withdrawn as it said.
+ */
+export async function syncWorkflows(
+  db: Db,
+  workflows: readonly StoredWorkflow[],
+): Promise<WorkflowSyncReport> {
+  const report: WorkflowSyncReport = { changed: [], requests: [] }
+  const before = await writeWorkflows(db, workflows)
+  const identity = (w: SchemaWorkflow) => w.key ?? w.alias
+  const previous = new Map(before.map((s) => [identity(s.workflow), s]))
+  const current = new Map(workflows.map((s) => [identity(s.workflow), s]))
+  const requests = new ApprovalRepository(db)
+  for (const id of new Set([...previous.keys(), ...current.keys()])) {
+    const was = previous.get(id)
+    const now = current.get(id)
+    if (was && now && was.version === now.version) continue
+    report.changed.push((now ?? was)?.workflow.alias ?? id)
+    const rule = (now ?? was)?.workflow.onChange ?? 'keep'
+    for (const request of await requests.waitingUnder(id)) {
+      if (request.workflowVersion === now?.version) continue
+      if (rule === 'keep') {
+        report.requests.push({ key: request.key, workflow: id, outcome: 'kept' })
+        continue
+      }
+      if (rule === 'restart' && now) {
+        await requests.rebase(request.id, now.workflow, now.version)
+        for (const stage of startStages(now.workflow)) await requests.addStep(request.id, stage)
+        await requests.record(request.id, { kind: 'restarted', comment: 'the workflow changed' })
+        report.requests.push({ key: request.key, workflow: id, outcome: 'restarted' })
+        continue
+      }
+      await requests.setState(request.id, 'withdrawn')
+      await requests.record(request.id, {
+        kind: 'withdrawn',
+        comment: now ? 'the workflow changed' : 'the workflow was removed',
+      })
+      report.requests.push({ key: request.key, workflow: id, outcome: 'withdrawn' })
+    }
+  }
+  return report
+}