@crombolo/data 0.10.0 → 0.12.1

package/src/repositories/webhooks.ts

@@ -0,0 +1,299 @@
+/**
+ * Webhooks kept in this environment, and the delivery queue and log every
+ * webhook and bundle event handler shares. docs/webhooks.md.
+ *
+ * A delivery is claimed with `UPDATE … WHERE state = 'pending' … RETURNING`, as
+ * form workflows are, so on a cluster exactly one node delivers each.
+ */
+import { randomUUID } from 'node:crypto'
+import type { Db } from '../database.ts'
+import { DbDate, fromDbBool } from '../dialect.ts'
+
+export interface WebhookRow {
+  key: string
+  name: string | null
+  description: string | null
+  url: string
+  enabled: boolean
+  events: string[]
+  contentTypeKeys: string[]
+  /** The headers as one sealed value; the server holds the key that opens it. */
+  sealedHeaders: string | null
+}
+
+const parseList = (value: unknown): string[] => {
+  try {
+    const parsed = JSON.parse(String(value ?? '[]')) as unknown
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : []
+  } catch {
+    return []
+  }
+}
+
+export class WebhookRepository {
+  #db: Db
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  async all(): Promise<WebhookRow[]> {
+    const rows = await this.#db.query(
+      'SELECT key, name, description, url, enabled, events, content_type_keys, headers FROM webhook ORDER BY create_date, key',
+    )
+    return rows.map((row) => ({
+      key: String(row.key),
+      name: (row.name as string | null) ?? null,
+      description: (row.description as string | null) ?? null,
+      url: String(row.url),
+      enabled: fromDbBool(row.enabled),
+      events: parseList(row.events),
+      contentTypeKeys: parseList(row.content_type_keys),
+      sealedHeaders: (row.headers as string | null) ?? null,
+    }))
+  }
+
+  async byKey(key: string): Promise<WebhookRow | undefined> {
+    return (await this.all()).find((row) => row.key === key.toLowerCase())
+  }
+
+  async save(webhook: WebhookRow): Promise<void> {
+    const now = DbDate.toDb(new Date())
+    const values = [
+      webhook.name,
+      webhook.description,
+      webhook.url,
+      this.#db.dialect.boolValue(webhook.enabled),
+      JSON.stringify(webhook.events),
+      JSON.stringify(webhook.contentTypeKeys),
+      webhook.sealedHeaders,
+      now,
+    ]
+    const updated = await this.#db.query(
+      `UPDATE webhook SET name = ?, description = ?, url = ?, enabled = ?, events = ?,
+              content_type_keys = ?, headers = ?, update_date = ?
+        WHERE key = ? RETURNING key`,
+      [...values, webhook.key.toLowerCase()],
+    )
+    if (updated.length > 0) return
+    await this.#db.exec(
+      `INSERT INTO webhook (name, description, url, enabled, events, content_type_keys, headers,
+                            update_date, key, create_date)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [...values, webhook.key.toLowerCase(), now],
+    )
+  }
+
+  async remove(key: string): Promise<boolean> {
+    const rows = await this.#db.query('DELETE FROM webhook WHERE key = ? RETURNING key', [
+      key.toLowerCase(),
+    ])
+    return rows.length > 0
+  }
+}
+
+export type WebhookDeliveryState = 'pending' | 'running' | 'done' | 'failed'
+
+export interface WebhookDelivery {
+  id: string
+  /** A webhook's key, or `bundle:<id>` for a bundle's handler. */
+  subscriber: string
+  eventAlias: string
+  payload: unknown
+  state: WebhookDeliveryState
+  attempts: number
+  lastError: string | null
+  runAfter: Date
+  createDate: Date
+}
+
+export interface WebhookLogEntry {
+  key: string
+  deliveryId: string
+  subscriber: string
+  eventAlias: string
+  url: string
+  statusCode: number | null
+  success: boolean
+  exception: boolean
+  retryCount: number
+  requestHeaders: string
+  requestBody: string
+  responseHeaders: string
+  responseBody: string
+  date: Date
+}
+
+const DELIVERY_COLUMNS =
+  'id, subscriber, event_alias, payload, state, attempts, last_error, run_after, create_date'
+
+const hydrateDelivery = (row: Record<string, unknown>): WebhookDelivery => {
+  let payload: unknown = null
+  try {
+    payload = JSON.parse(String(row.payload))
+  } catch {
+    payload = null
+  }
+  return {
+    id: String(row.id),
+    subscriber: String(row.subscriber),
+    eventAlias: String(row.event_alias),
+    payload,
+    state: String(row.state) as WebhookDeliveryState,
+    attempts: Number(row.attempts),
+    lastError: (row.last_error as string | null) ?? null,
+    runAfter: DbDate.fromDb(row.run_after) ?? new Date(0),
+    createDate: DbDate.fromDb(row.create_date) ?? new Date(0),
+  }
+}
+
+/** Bodies and headers are kept to what a person will read, not what a server sent. */
+const clip = (value: string) => value.slice(0, 10_000)
+
+export class WebhookDeliveryRepository {
+  #db: Db
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  async enqueue(
+    deliveries: ReadonlyArray<{ subscriber: string; eventAlias: string; payload: unknown }>,
+    now = new Date(),
+  ): Promise<string[]> {
+    const ids: string[] = []
+    for (const delivery of deliveries) {
+      const id = randomUUID()
+      await this.#db.exec(
+        `INSERT INTO webhook_delivery (${DELIVERY_COLUMNS}, update_date)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          id,
+          delivery.subscriber,
+          delivery.eventAlias,
+          JSON.stringify(delivery.payload),
+          'pending',
+          0,
+          null,
+          DbDate.toDb(now),
+          DbDate.toDb(now),
+          DbDate.toDb(now),
+        ],
+      )
+      ids.push(id)
+    }
+    return ids
+  }
+
+  async due(now = new Date(), limit = 25): Promise<WebhookDelivery[]> {
+    const rows = await this.#db.query(
+      `SELECT ${DELIVERY_COLUMNS} FROM webhook_delivery WHERE state = ? AND run_after <= ?
+        ORDER BY run_after, create_date LIMIT ?`,
+      ['pending', DbDate.toDb(now), limit],
+    )
+    return rows.map(hydrateDelivery)
+  }
+
+  /** Takes a delivery, or finds another node already has. */
+  async claim(id: string): Promise<WebhookDelivery | undefined> {
+    const rows = await this.#db.query(
+      `UPDATE webhook_delivery SET state = ?, attempts = attempts + 1, update_date = ?
+        WHERE id = ? AND state = ? RETURNING ${DELIVERY_COLUMNS}`,
+      ['running', DbDate.toDb(new Date()), id, 'pending'],
+    )
+    return rows[0] ? hydrateDelivery(rows[0]) : undefined
+  }
+
+  async succeed(id: string): Promise<void> {
+    await this.#db.exec(
+      'UPDATE webhook_delivery SET state = ?, last_error = NULL, update_date = ? WHERE id = ?',
+      ['done', DbDate.toDb(new Date()), id],
+    )
+  }
+
+  /** `retryAt` puts it back in the queue; without one it has failed for good. */
+  async fail(id: string, error: string, retryAt?: Date): Promise<void> {
+    await this.#db.exec(
+      'UPDATE webhook_delivery SET state = ?, last_error = ?, run_after = ?, update_date = ? WHERE id = ?',
+      [
+        retryAt ? 'pending' : 'failed',
+        error.slice(0, 2000),
+        DbDate.toDb(retryAt ?? new Date()),
+        DbDate.toDb(new Date()),
+        id,
+      ],
+    )
+  }
+
+  async byId(id: string): Promise<WebhookDelivery | undefined> {
+    const rows = await this.#db.query(
+      `SELECT ${DELIVERY_COLUMNS} FROM webhook_delivery WHERE id = ?`,
+      [id],
+    )
+    return rows[0] ? hydrateDelivery(rows[0]) : undefined
+  }
+
+  async log(entry: Omit<WebhookLogEntry, 'key' | 'date'>, date = new Date()): Promise<void> {
+    await this.#db.exec(
+      `INSERT INTO webhook_log (key, delivery_id, subscriber, event_alias, url, status_code, success,
+         exception, retry_count, request_headers, request_body, response_headers, response_body, log_date)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        randomUUID(),
+        entry.deliveryId,
+        entry.subscriber,
+        entry.eventAlias,
+        entry.url,
+        entry.statusCode,
+        this.#db.dialect.boolValue(entry.success),
+        this.#db.dialect.boolValue(entry.exception),
+        entry.retryCount,
+        clip(entry.requestHeaders),
+        clip(entry.requestBody),
+        clip(entry.responseHeaders),
+        clip(entry.responseBody),
+        DbDate.toDb(date),
+      ],
+    )
+  }
+
+  /** The log, newest first; one subscriber's when named. */
+  async logs(options: {
+    subscriber?: string
+    skip: number
+    take: number
+  }): Promise<{ total: number; items: WebhookLogEntry[] }> {
+    const where = options.subscriber ? 'WHERE subscriber = ?' : ''
+    const params = options.subscriber ? [options.subscriber] : []
+    const total = await this.#db.query<{ n: number }>(
+      `SELECT COUNT(*) AS n FROM webhook_log ${where}`,
+      params,
+    )
+    const rows = await this.#db.query(
+      `SELECT key, delivery_id, subscriber, event_alias, url, status_code, success, exception,
+              retry_count, request_headers, request_body, response_headers, response_body, log_date
+         FROM webhook_log ${where} ORDER BY log_date DESC, retry_count DESC, key LIMIT ? OFFSET ?`,
+      [...params, options.take, options.skip],
+    )
+    return {
+      total: Number(total[0]?.n ?? 0),
+      items: rows.map((row) => ({
+        key: String(row.key),
+        deliveryId: String(row.delivery_id),
+        subscriber: String(row.subscriber),
+        eventAlias: String(row.event_alias),
+        url: String(row.url),
+        statusCode:
+          row.status_code === null || row.status_code === undefined
+            ? null
+            : Number(row.status_code),
+        success: fromDbBool(row.success),
+        exception: fromDbBool(row.exception),
+        retryCount: Number(row.retry_count),
+        requestHeaders: String(row.request_headers),
+        requestBody: String(row.request_body),
+        responseHeaders: String(row.response_headers),
+        responseBody: String(row.response_body),
+        date: DbDate.fromDb(row.log_date) ?? new Date(0),
+      })),
+    }
+  }
+}

package/src/schema/audit-log.ts

@@ -0,0 +1,45 @@
+/**
+ * Migration 033 — the audit log. docs/audit-log.md.
+ *
+ * `audit_entry` records who did what, when and from where: every backoffice
+ * change, every sign-in and failed sign-in, and what the command line and the
+ * background jobs changed. Names are copied in when an entry is written, so an
+ * entry still reads after its user or item is gone. It starts empty: history from
+ * before this migration stays in the content versions it came from.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_PROPERTY_SEARCHABLE } from './property-searchable.ts'
+
+export const STATE_AUDIT_LOG = '{6f1d4a8e-0033-4c1a-9e7d-3a5b8c2d4e33}'
+
+export const auditLogMigration: Migration = {
+  from: STATE_PROPERTY_SEARCHABLE,
+  to: STATE_AUDIT_LOG,
+  name: 'AddAuditLog',
+  kind: 'expand',
+  release: '0.10.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    await db.exec(
+      `CREATE TABLE audit_entry (
+         id ${t.identity},
+         occurred_at ${t.timestamp} NOT NULL,
+         category ${t.varchar(32)} NOT NULL,
+         action ${t.varchar(64)} NOT NULL,
+         user_key ${t.uuid},
+         user_name ${t.varchar(255)},
+         entity_type ${t.varchar(64)},
+         entity_key ${t.varchar(255)},
+         entity_name ${t.varchar(255)},
+         source ${t.varchar(16)} NOT NULL,
+         ip_address ${t.varchar(64)},
+         forwarded_for ${t.varchar(255)},
+         detail ${t.text}
+       )`,
+    )
+    await db.exec('CREATE INDEX ix_audit_entry_occurred ON audit_entry (occurred_at)')
+    await db.exec('CREATE INDEX ix_audit_entry_entity ON audit_entry (entity_key, occurred_at)')
+    await db.exec('CREATE INDEX ix_audit_entry_user ON audit_entry (user_key, occurred_at)')
+  },
+}

package/src/schema/delivery-member-tokens.ts

@@ -0,0 +1,40 @@
+/**
+ * Migration 037 — the Delivery API's member tokens (story 050):
+ * authorization codes, access and refresh tokens, each stored as the SHA-256
+ * of what the client holds, never the token itself. docs/delivery-api.md,
+ * "Member sign-in".
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_TRANSFER_ANSWERS } from './transfer-answers.ts'
+
+export const STATE_DELIVERY_MEMBER_TOKENS = '{7d3b9e2c-0037-4a51-b8f6-2c4e1a9d5b37}'
+
+export const deliveryMemberTokensMigration: Migration = {
+  from: STATE_TRANSFER_ANSWERS,
+  to: STATE_DELIVERY_MEMBER_TOKENS,
+  name: 'AddDeliveryMemberTokens',
+  kind: 'expand',
+  release: '0.12.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    await db.exec(
+      `CREATE TABLE delivery_member_token (
+         hash ${t.varchar(64)} NOT NULL,
+         kind ${t.varchar(16)} NOT NULL,
+         member_key ${t.varchar(64)} NOT NULL,
+         client_id ${t.varchar(255)} NOT NULL,
+         scopes ${t.varchar(255)} NOT NULL,
+         redirect_uri ${t.text},
+         code_challenge ${t.varchar(128)},
+         expires_at ${t.timestamp} NOT NULL,
+         redeemed_at ${t.timestamp},
+         create_date ${t.timestamp} NOT NULL,
+         PRIMARY KEY (hash)
+       )`,
+    )
+    await db.exec(
+      'CREATE INDEX ix_delivery_member_token_member ON delivery_member_token (member_key)',
+    )
+  },
+}

package/src/schema/diagnostics.ts

@@ -0,0 +1,28 @@
+/**
+ * Migration 034 — diagnostics and choice sources. docs/diagnostics.md, docs/forms.md.
+ *
+ * `server.crombolo_version` is the Crombolo release each node runs, beside the
+ * schema set version `server.version` already holds, so the cluster health check
+ * can say when nodes disagree. `form_entry_value.label` is the option label a
+ * visitor saw for a choice drawn from a source, so an entry still reads after the
+ * node or dictionary item behind it is renamed or removed.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_AUDIT_LOG } from './audit-log.ts'
+
+export const STATE_DIAGNOSTICS = '{6f1d4a8e-0034-4c1a-9e7d-3a5b8c2d4e34}'
+
+export const diagnosticsMigration: Migration = {
+  from: STATE_AUDIT_LOG,
+  to: STATE_DIAGNOSTICS,
+  name: 'AddNodeVersionAndChoiceLabel',
+  kind: 'expand',
+  release: '0.12.0',
+  async up(db: Db) {
+    const ops = schemaOps(db)
+    await ops.addColumn('server', 'crombolo_version', db.dialect.types.varchar(64))
+    await ops.addColumn('form_entry_value', 'label', db.dialect.types.text)
+  },
+}

package/src/schema/plan.ts

@@ -13,6 +13,7 @@
  */
 import { MigrationPlan } from '../migrations.ts'
 import { assistantMigration } from './assistant.ts'
+import { auditLogMigration } from './audit-log.ts'
 import { bundleComponentsMigration } from './bundle-components.ts'
 import { bundlePackageMigration } from './bundle-package.ts'
 import { bundlesRenameMigration } from './bundles-rename.ts'
@@ -21,6 +22,8 @@ import { clientIdPrefixMigration } from './client-id-prefix.ts'
 import { contentMigration } from './content.ts'
 import { contentEditingMigration } from './content-editing.ts'
 import { createdPackagesMigration } from './created-packages.ts'
+import { deliveryMemberTokensMigration } from './delivery-member-tokens.ts'
+import { diagnosticsMigration } from './diagnostics.ts'
 import { elementsMigration } from './elements.ts'
 import { formPermissionPrefixMigration } from './form-permission-prefix.ts'
 import { formPermissionsMigration } from './form-permissions.ts'
@@ -31,17 +34,21 @@ import { identityMigration } from './identity.ts'
 import { logViewerMigration } from './log-viewer.ts'
 import { memberPropertyTypeMigration } from './member-property-type.ts'
 import { membersMigration } from './members.ts'
+import { propertySearchableMigration } from './property-searchable.ts'
 import { publicAccessMigration } from './public-access.ts'
 import { recycleBinMigration } from './recycle-bin.ts'
 import { redirectsMigration } from './redirects.ts'
 import { richTextUiMigration } from './rich-text-ui.ts'
+import { searchIndexMigration } from './search-index.ts'
 import { serverRoleMigration } from './server-role.ts'
 import { sinceVersionMigration } from './since-version.ts'
+import { transferAnswersMigration } from './transfer-answers.ts'
 import { transferRunPackageMigration } from './transfer-run-package.ts'
 import { transferRunsMigration } from './transfer-runs.ts'
 import { upgradeReportMigration } from './upgrade-report.ts'
 import { usersLocalisationMigration } from './users-localisation.ts'
 import { valuesMigration } from './values.ts'
+import { webhooksMigration } from './webhooks.ts'
 
 export const cromboloPlan = new MigrationPlan([
   identityMigration,
@@ -74,4 +81,11 @@ export const cromboloPlan = new MigrationPlan([
   bundleComponentsMigration,
   bundlePackageMigration,
   transferRunPackageMigration,
+  searchIndexMigration,
+  propertySearchableMigration,
+  auditLogMigration,
+  diagnosticsMigration,
+  webhooksMigration,
+  transferAnswersMigration,
+  deliveryMemberTokensMigration,
 ])

package/src/schema/property-searchable.ts

@@ -0,0 +1,29 @@
+/**
+ * Migration 032 — a property can be kept out of backoffice search.
+ *
+ * `searchable = false` on a property in the schema files. Stored on the
+ * property type, because the backoffice writes those files back from the
+ * database and its save carries no such flag, so the column is what a save
+ * preserves. Every existing property stays searchable. docs/search.md.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_SEARCH_INDEX } from './search-index.ts'
+
+export const STATE_PROPERTY_SEARCHABLE = '{6f1d4a8e-0032-4b7e-8a2c-5d9f1e3b6c32}'
+
+export const propertySearchableMigration: Migration = {
+  from: STATE_SEARCH_INDEX,
+  to: STATE_PROPERTY_SEARCHABLE,
+  name: 'AddPropertySearchable',
+  kind: 'expand',
+  release: '0.10.0',
+  async up(db: Db) {
+    await schemaOps(db).addColumn(
+      'property_type',
+      'searchable',
+      `${db.dialect.types.boolean} NOT NULL DEFAULT ${db.dialect.name === 'postgres' ? 'TRUE' : '1'}`,
+    )
+  },
+}

package/src/schema/search-index.ts

@@ -0,0 +1,92 @@
+/**
+ * Migration 031 — the backoffice search index. docs/search.md.
+ *
+ * `search_document` holds one row per item and culture: its name and the text of
+ * its current values, folded to lowercase without diacritics. SQLite matches it
+ * through an FTS5 table kept in step by triggers; Postgres through a generated
+ * `tsvector` column. Both use language-neutral word splitting, so the two
+ * dialects find the same things.
+ *
+ * `search_index_queue` is what a write leaves for the indexer: a node id and a
+ * generation, bumped each time the node is queued again, so a row re-queued
+ * while it was being indexed survives the indexer's delete. Every existing
+ * page, media item and member is queued here, which is the backfill.
+ */
+import { ObjectTypes } from '@crombolo/core'
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_TRANSFER_RUN_PACKAGE } from './transfer-run-package.ts'
+
+export const STATE_SEARCH_INDEX = '{6f1d4a8e-0031-4f3a-9c6d-2b8e5a1f7d31}'
+
+export const searchIndexMigration: Migration = {
+  from: STATE_TRANSFER_RUN_PACKAGE,
+  to: STATE_SEARCH_INDEX,
+  name: 'AddSearchIndex',
+  kind: 'expand',
+  release: '0.10.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    const postgres = db.dialect.name === 'postgres'
+    await db.exec(
+      `CREATE TABLE search_document (
+         id ${t.identity},
+         node_id ${t.integer} NOT NULL REFERENCES node (id) ON DELETE CASCADE,
+         culture ${t.varchar(14)} NOT NULL,
+         name ${t.text} NOT NULL,
+         body ${t.text} NOT NULL,
+         fields ${t.json} NOT NULL,
+         field_count ${t.integer} NOT NULL,
+         indexed_at ${t.timestamp} NOT NULL${
+           postgres
+             ? `,
+         terms tsvector GENERATED ALWAYS AS (
+           setweight(to_tsvector('simple', name), 'A') || setweight(to_tsvector('simple', body), 'B')
+         ) STORED`
+             : ''
+         },
+         UNIQUE (node_id, culture)
+       )`,
+    )
+    if (postgres) {
+      await db.exec('CREATE INDEX ix_search_document_terms ON search_document USING GIN (terms)')
+    } else {
+      await db.exec(
+        `CREATE VIRTUAL TABLE search_document_fts USING fts5(
+           name, body, content='search_document', content_rowid='id',
+           tokenize='unicode61 remove_diacritics 2'
+         )`,
+      )
+      await db.exec(
+        `CREATE TRIGGER search_document_ai AFTER INSERT ON search_document BEGIN
+           INSERT INTO search_document_fts (rowid, name, body) VALUES (new.id, new.name, new.body);
+         END`,
+      )
+      await db.exec(
+        `CREATE TRIGGER search_document_ad AFTER DELETE ON search_document BEGIN
+           INSERT INTO search_document_fts (search_document_fts, rowid, name, body)
+           VALUES ('delete', old.id, old.name, old.body);
+         END`,
+      )
+      await db.exec(
+        `CREATE TRIGGER search_document_au AFTER UPDATE ON search_document BEGIN
+           INSERT INTO search_document_fts (search_document_fts, rowid, name, body)
+           VALUES ('delete', old.id, old.name, old.body);
+           INSERT INTO search_document_fts (rowid, name, body) VALUES (new.id, new.name, new.body);
+         END`,
+      )
+    }
+    await db.exec(
+      `CREATE TABLE search_index_queue (
+         node_id ${t.integer} PRIMARY KEY REFERENCES node (id) ON DELETE CASCADE,
+         generation ${t.integer} NOT NULL,
+         queued_at ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec(
+      `INSERT INTO search_index_queue (node_id, generation, queued_at)
+       SELECT id, 1, ${db.dialect.now()} FROM node WHERE node_object_type IN (?, ?, ?)`,
+      [ObjectTypes.Document, ObjectTypes.Media, ObjectTypes.Member],
+    )
+  },
+}

package/src/schema/seed.ts

@@ -211,7 +211,8 @@ export interface SeedAdmin {
 }
 
 export interface SeedOptions {
-  admin: SeedAdmin
+  /** Omitted, the site is left for its owner to set up from the browser. */
+  admin?: SeedAdmin
   hashPassword: (password: string) => Promise<string>
   passwordConfig: string
 }
@@ -259,6 +260,17 @@ export async function seedIdentity(db: Db, options: SeedOptions): Promise<boolea
   if (sync) await db.exec(sync)
   await grantBuiltInPermissions(db)
 
+  if (options.admin) await insertSuperUser(db, { ...options, admin: options.admin })
+  return true
+}
+
+/** Creates Umbraco's super user, in Administrators and Sensitive data. */
+export async function insertSuperUser(
+  db: Db,
+  options: SeedOptions & { admin: SeedAdmin },
+): Promise<void> {
+  const now = DbDate.toDb(new Date())
+  const bool = (value: boolean) => db.dialect.boolValue(value)
   await db.exec(
     `INSERT INTO user_account
        (key, user_name, login, email, password_hash, password_config, security_stamp, language,
@@ -294,5 +306,4 @@ export async function seedIdentity(db: Db, options: SeedOptions): Promise<boolea
       groupId,
     ])
   }
-  return true
 }

package/src/schema/transfer-answers.ts

@@ -0,0 +1,50 @@
+/**
+ * Migration 036 — a pending import and its answers, so a content transfer's
+ * conflicts can be answered in the backoffice. docs/content-transfer.md.
+ *
+ * `transfer_pending` is the last check of each bundle: where it was found and
+ * what the check was asked to do, so the dashboard can run the same import.
+ * `transfer_answer` holds the choices made there, one per node and property
+ * handle, as `resolutions.json` would.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_WEBHOOKS } from './webhooks.ts'
+
+export const STATE_TRANSFER_ANSWERS = '{2c8e5b1a-0036-4f3d-8a6e-9d1c4b7a2e36}'
+
+export const transferAnswersMigration: Migration = {
+  from: STATE_WEBHOOKS,
+  to: STATE_TRANSFER_ANSWERS,
+  name: 'AddTransferAnswers',
+  kind: 'expand',
+  release: '0.12.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    await db.exec(
+      `CREATE TABLE transfer_pending (
+         bundle_id ${t.varchar(64)} NOT NULL,
+         label ${t.varchar(255)},
+         target ${t.text} NOT NULL,
+         target_kind ${t.varchar(16)} NOT NULL,
+         under_target ${t.text},
+         publish ${t.boolean} NOT NULL,
+         allow_missing_blobs ${t.boolean} NOT NULL,
+         checked_at ${t.timestamp} NOT NULL,
+         checked_by ${t.varchar(255)},
+         PRIMARY KEY (bundle_id)
+       )`,
+    )
+    await db.exec(
+      `CREATE TABLE transfer_answer (
+         bundle_id ${t.varchar(64)} NOT NULL,
+         node_key ${t.varchar(64)} NOT NULL,
+         handle ${t.varchar(255)} NOT NULL,
+         resolution ${t.varchar(16)} NOT NULL,
+         answered_by ${t.varchar(255)},
+         answered_at ${t.timestamp} NOT NULL,
+         PRIMARY KEY (bundle_id, node_key, handle)
+       )`,
+    )
+  },
+}