@crombolo/data 0.0.0-stage → 0.10.0

package/src/schema/seed.ts

@@ -0,0 +1,298 @@
+/**
+ * Install seed data, mirroring Umbraco's DatabaseDataCreator.
+ *
+ * Password hashing is injected rather than imported so this package stays free of
+ * a dependency on @crombolo/auth.
+ */
+import type { Db } from '../database.ts'
+import { DbDate } from '../dialect.ts'
+
+const ELEMENT_EDIT = [
+  'Umb.Element.Create',
+  'Umb.Element.Update',
+  'Umb.Element.Delete',
+  'Umb.Element.Move',
+  'Umb.Element.Duplicate',
+  'Umb.Element.Publish',
+  'Umb.Element.Unpublish',
+  'Umb.Element.Read',
+  'Umb.Element.Rollback',
+  'Umb.ElementContainer.Create',
+  'Umb.ElementContainer.Update',
+  'Umb.ElementContainer.Delete',
+  'Umb.ElementContainer.Move',
+  'Umb.ElementContainer.Read',
+]
+
+/**
+ * The permission verbs each built-in group is installed with — Umbraco's
+ * `DatabaseDataCreator.CreateUserGroup2PermissionData`, verbatim, including the
+ * legacy single-character letters it still seeds. The backoffice reads these
+ * as the user's fallback permissions; without them it hides every
+ * permission-gated action, Create included.
+ */
+/** Everything about forms, which only an administrator gets by default. */
+const FORM_FULL = [
+  'Crombolo.Form.Read',
+  'Crombolo.Form.Manage',
+  'Crombolo.FormEntry.Read',
+  'Crombolo.FormEntry.Manage',
+  'Crombolo.FormEntry.Sensitive',
+] as const
+
+export const BUILT_IN_GROUP_PERMISSIONS: Record<string, readonly string[]> = {
+  admin: [
+    'Umb.Document.Create',
+    'Umb.Document.Update',
+    'Umb.Document.Delete',
+    'Umb.Document.Move',
+    'Umb.Document.Duplicate',
+    'Umb.Document.Sort',
+    'Umb.Document.Rollback',
+    'Umb.Document.PublicAccess',
+    'Umb.Document.CultureAndHostnames',
+    'Umb.Document.Publish',
+    'Umb.Document.Permissions',
+    'Umb.Document.Unpublish',
+    'Umb.Document.Read',
+    'Umb.Document.CreateBlueprint',
+    'Umb.Document.Notifications',
+    ':',
+    '5',
+    '7',
+    'T',
+    'Umb.Document.PropertyValue.Read',
+    'Umb.Document.PropertyValue.Write',
+    ...FORM_FULL,
+    ...ELEMENT_EDIT,
+  ],
+  editor: [
+    'Umb.Document.Create',
+    'Umb.Document.Update',
+    'Umb.Document.Delete',
+    'Umb.Document.Move',
+    'Umb.Document.Duplicate',
+    'Umb.Document.Sort',
+    'Umb.Document.Rollback',
+    'Umb.Document.PublicAccess',
+    'Umb.Document.Publish',
+    'Umb.Document.Unpublish',
+    'Umb.Document.Read',
+    'Umb.Document.CreateBlueprint',
+    'Umb.Document.Notifications',
+    ':',
+    '5',
+    'T',
+    'Umb.Document.PropertyValue.Read',
+    'Umb.Document.PropertyValue.Write',
+    // An editor reads entries and acts on them, but does not design forms and
+    // does not see what a definition marks sensitive.
+    'Crombolo.Form.Read',
+    'Crombolo.FormEntry.Read',
+    'Crombolo.FormEntry.Manage',
+    ...ELEMENT_EDIT,
+  ],
+  writer: [
+    'Umb.Document.Create',
+    'Umb.Document.Update',
+    'Umb.Document.Read',
+    'Umb.Document.Notifications',
+    ':',
+    'Umb.Document.PropertyValue.Read',
+    'Umb.Document.PropertyValue.Write',
+    'Umb.Element.Create',
+    'Umb.Element.Update',
+    'Umb.Element.Read',
+    'Umb.ElementContainer.Create',
+    'Umb.ElementContainer.Update',
+    'Umb.ElementContainer.Read',
+  ],
+  // The group that exists only to carry sensitive-data access; it has no
+  // sections of its own and is added alongside another group.
+  sensitiveData: ['Crombolo.FormEntry.Sensitive'],
+  translator: [
+    'Umb.Document.Update',
+    'Umb.Document.Read',
+    'Umb.Document.PropertyValue.Read',
+    'Umb.Document.PropertyValue.Write',
+    'Umb.Element.Update',
+    'Umb.Element.Read',
+    'Umb.ElementContainer.Update',
+    'Umb.ElementContainer.Read',
+  ],
+}
+
+/**
+ * Grants each built-in group its default verbs where it lacks them. Plannable
+ * (no reads) and idempotent; used by the seed and by migration 007.
+ */
+export async function grantBuiltInPermissions(db: Db): Promise<void> {
+  for (const [alias, permissions] of Object.entries(BUILT_IN_GROUP_PERMISSIONS)) {
+    for (const permission of permissions) {
+      await db.exec(
+        `INSERT INTO user_group_permission (user_group_key, permission)
+         SELECT g.key, ? FROM user_group g
+         WHERE g.alias = ? AND NOT EXISTS (
+           SELECT 1 FROM user_group_permission p WHERE p.user_group_key = g.key AND p.permission = ?
+         )`,
+        [permission, alias, permission],
+      )
+    }
+  }
+}
+
+/** Umbraco's five built-in groups, key for key, with their seeded section access. */
+export const BUILT_IN_GROUPS = [
+  {
+    id: 1,
+    key: 'e5e7f6c8-7f9c-4b5b-8d5d-9e1e5a4f7e4d',
+    alias: 'admin',
+    name: 'Administrators',
+    icon: 'icon-medal',
+    hasAccessToAllLanguages: true,
+    sections: [
+      'content',
+      'packages',
+      'media',
+      'members',
+      'settings',
+      'users',
+      'forms',
+      'translation',
+      'library',
+    ],
+  },
+  {
+    id: 2,
+    key: '9fc2a16f-528c-46d6-a014-75bf4ec2480c',
+    alias: 'writer',
+    name: 'Writers',
+    icon: 'icon-edit',
+    hasAccessToAllLanguages: true,
+    sections: ['content', 'library'],
+  },
+  {
+    id: 3,
+    key: '44dc260e-b4d4-4dd9-9081-eec5598f1641',
+    alias: 'editor',
+    name: 'Editors',
+    icon: 'icon-tools',
+    hasAccessToAllLanguages: true,
+    sections: ['content', 'media', 'forms', 'library'],
+  },
+  {
+    id: 4,
+    key: 'f2012e4c-d232-4bd1-8eae-4384032d97d8',
+    alias: 'translator',
+    name: 'Translators',
+    icon: 'icon-globe',
+    hasAccessToAllLanguages: true,
+    sections: ['translation'],
+  },
+  {
+    id: 5,
+    key: '8c6ad70f-d307-4e4a-af58-72c2e4e9439d',
+    alias: 'sensitiveData',
+    name: 'Sensitive data',
+    icon: 'icon-lock',
+    hasAccessToAllLanguages: false,
+    sections: [],
+  },
+] as const
+
+/** Umbraco's super user: the installer's administrator, whom only they can see in the user lists. */
+export const SUPER_USER_KEY = '1e70f841-c261-413b-abb2-2d68cdb96094'
+
+export interface SeedAdmin {
+  name: string
+  login: string
+  email: string
+  password: string
+}
+
+export interface SeedOptions {
+  admin: SeedAdmin
+  hashPassword: (password: string) => Promise<string>
+  passwordConfig: string
+}
+
+async function tableIsEmpty(db: Db, table: string): Promise<boolean> {
+  const rows = await db.query<{ n: number }>(`SELECT COUNT(*) AS n FROM ${table}`)
+  return Number(rows[0]?.n ?? 0) === 0
+}
+
+/** Idempotent: does nothing when the identity tables already hold data. */
+export async function seedIdentity(db: Db, options: SeedOptions): Promise<boolean> {
+  if (!(await tableIsEmpty(db, 'user_group'))) return false
+
+  const now = DbDate.toDb(new Date())
+  const bool = (value: boolean) => db.dialect.boolValue(value)
+
+  for (const group of BUILT_IN_GROUPS) {
+    await db.exec(
+      `INSERT INTO user_group
+         (id, key, alias, name, icon, has_access_to_all_languages,
+          start_content_id, start_media_id, start_element_id, create_date, update_date)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        group.id,
+        group.key,
+        group.alias,
+        group.name,
+        group.icon,
+        bool(group.hasAccessToAllLanguages),
+        -1,
+        -1,
+        -1,
+        now,
+        now,
+      ],
+    )
+    for (const section of group.sections) {
+      await db.exec('INSERT INTO user_group_section (user_group_id, app_alias) VALUES (?, ?)', [
+        group.id,
+        section,
+      ])
+    }
+  }
+  const sync = db.dialect.syncIdentity('user_group')
+  if (sync) await db.exec(sync)
+  await grantBuiltInPermissions(db)
+
+  await db.exec(
+    `INSERT INTO user_account
+       (key, user_name, login, email, password_hash, password_config, security_stamp, language,
+        kind, is_locked_out, is_approved, failed_login_attempts, create_date, update_date)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      SUPER_USER_KEY,
+      options.admin.name,
+      options.admin.login,
+      options.admin.email,
+      await options.hashPassword(options.admin.password),
+      options.passwordConfig,
+      crypto.randomUUID(),
+      'en-US',
+      0,
+      bool(false),
+      bool(true),
+      0,
+      now,
+      now,
+    ],
+  )
+
+  const created = await db.query<{ id: number }>('SELECT id FROM user_account WHERE login = ?', [
+    options.admin.login,
+  ])
+  const userId = Number(created[0]?.id)
+
+  // Umbraco puts the super user in Administrators and Sensitive data.
+  for (const groupId of [1, 5]) {
+    await db.exec('INSERT INTO user_group_member (user_id, user_group_id) VALUES (?, ?)', [
+      userId,
+      groupId,
+    ])
+  }
+  return true
+}

package/src/schema/server-role.ts

@@ -0,0 +1,21 @@
+/**
+ * `server.role`: what each registered node serves, so the cluster can be read
+ * back by role — which nodes are answering the public site, which the editor.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_CLIENT_ID_PREFIX } from './client-id-prefix.ts'
+
+export const STATE_SERVER_ROLE = '{6f1d4a8e-0021-4c21-9d3a-8b1e5c7a2f21}'
+
+export const serverRoleMigration: Migration = {
+  from: STATE_CLIENT_ID_PREFIX,
+  to: STATE_SERVER_ROLE,
+  name: 'AddServerRole',
+  kind: 'expand',
+  release: '0.4.0',
+  async up(db: Db) {
+    await schemaOps(db).addColumn('server', 'role', db.dialect.types.varchar(20))
+  },
+}

package/src/schema/since-version.ts

@@ -0,0 +1,26 @@
+/**
+ * Migration 004 — `since_version`: the version a file says an element goes
+ * live in, kept beside `since_state_id` (the deployment that created the row)
+ * so "is this pending on my node" is one comparison. docs/09, "since".
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_VALUES } from './values.ts'
+
+export const STATE_SINCE_VERSION = '{6f1d4a8e-0004-4c21-9d3a-8b1e5c7a2f04}'
+
+export const sinceVersionMigration: Migration = {
+  from: STATE_VALUES,
+  to: STATE_SINCE_VERSION,
+  name: 'AddSinceVersion',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const ops = schemaOps(db)
+    const type = db.dialect.types.varchar(50)
+    await ops.addColumn('content_type', 'since_version', type)
+    await ops.addColumn('property_type', 'since_version', type)
+    await ops.addColumn('data_type', 'since_version', type)
+  },
+}

package/src/schema/transfer-run-package.ts

@@ -0,0 +1,27 @@
+/**
+ * Migration 030 — a transfer run records the package it applied.
+ *
+ * A bundle's content arrives inside an npm package, so the run names the
+ * package and the version that brought it. That is what tells the Installed
+ * view whether a dependency's content has been applied here, and which release
+ * of it. Nullable, because a run before this one has no package to name.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_BUNDLE_PACKAGE } from './bundle-package.ts'
+
+export const STATE_TRANSFER_RUN_PACKAGE = '{6f1d4a8e-0030-4d2b-8e5c-7a1f9b3d6e30}'
+
+export const transferRunPackageMigration: Migration = {
+  from: STATE_BUNDLE_PACKAGE,
+  to: STATE_TRANSFER_RUN_PACKAGE,
+  name: 'AddTransferRunPackage',
+  kind: 'expand',
+  release: '0.10.0',
+  async up(db: Db) {
+    const ops = schemaOps(db)
+    await ops.addColumn('content_transfer_run', 'package_name', db.dialect.types.varchar(214))
+    await ops.addColumn('content_transfer_run', 'package_version', db.dialect.types.varchar(64))
+  },
+}

package/src/schema/transfer-runs.ts

@@ -0,0 +1,71 @@
+/**
+ * Migration 019 — what a content import did, so reverting it is deterministic.
+ *
+ * You could try to find an import in the event log afterwards, by kind and
+ * timestamp. It would not work: nothing distinguishes one run's `save` events
+ * from an editor's concurrent save in the same second, and once a node exists
+ * there is no way to recover that the import is what created it. Both facts are
+ * needed to put the site back, so they are recorded as the run happens.
+ *
+ * `content_transfer_change` holds, per node, the event the node was at before
+ * the run and the published event it was serving — which is exactly what
+ * "restore the previously-live state" means. Shape follows
+ * `assistant_changeset`/`assistant_change`: a header with its items.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_CHANGE_REPORT } from './change-report.ts'
+
+export const STATE_TRANSFER_RUNS = '{6f1d4a8e-0019-4b7d-8e41-6c2a9f3d5e84}'
+
+export const transferRunsMigration: Migration = {
+  from: STATE_CHANGE_REPORT,
+  to: STATE_TRANSFER_RUNS,
+  name: 'AddContentTransferRuns',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+
+    await db.exec(
+      `CREATE TABLE content_transfer_run (
+         id ${t.varchar(64)} NOT NULL,
+         bundle_id ${t.varchar(64)} NOT NULL,
+         bundle_label ${t.varchar(255)},
+         direction ${t.varchar(16)} NOT NULL,
+         reverts_run_id ${t.varchar(64)},
+         schema_state_id ${t.integer} NOT NULL,
+         started_at ${t.timestamp} NOT NULL,
+         finished_at ${t.timestamp},
+         applied_by ${t.varchar(255)},
+         node_count ${t.integer} NOT NULL,
+         status ${t.varchar(16)} NOT NULL,
+         PRIMARY KEY (id)
+       )`,
+    )
+    // `content runs` lists them newest first.
+    await db.exec(
+      'CREATE INDEX ix_content_transfer_run_started ON content_transfer_run (started_at)',
+    )
+
+    await db.exec(
+      `CREATE TABLE content_transfer_change (
+         id ${t.identity},
+         run_id ${t.varchar(64)} NOT NULL,
+         node_key ${t.varchar(255)} NOT NULL,
+         kind ${t.varchar(16)} NOT NULL,
+         action ${t.varchar(16)} NOT NULL,
+         before_event_id ${t.integer},
+         before_published_event_id ${t.integer},
+         event_id ${t.integer}
+       )`,
+    )
+    await db.exec(
+      'CREATE UNIQUE INDEX ux_content_transfer_change_node ON content_transfer_change (run_id, node_key)',
+    )
+    // Revert asks "has a later run touched this node?", which is a scan by node.
+    await db.exec(
+      'CREATE INDEX ix_content_transfer_change_node ON content_transfer_change (node_key)',
+    )
+  },
+}

package/src/schema/upgrade-report.ts

@@ -0,0 +1,43 @@
+/**
+ * Migration 005 — `upgrade_report`: the pre-upgrade check's findings, in a
+ * stable shape the backoffice dashboard reads whatever version is live.
+ * docs/packaging-and-upgrades.md, "The upgrade dashboard ships in the first release".
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_SINCE_VERSION } from './since-version.ts'
+
+export const STATE_UPGRADE_REPORT = '{6f1d4a8e-0005-4c21-9d3a-8b1e5c7a2f05}'
+
+export const upgradeReportMigration: Migration = {
+  from: STATE_SINCE_VERSION,
+  to: STATE_UPGRADE_REPORT,
+  name: 'AddUpgradeReport',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    await db.exec(
+      `CREATE TABLE upgrade_report (
+         id ${t.identity},
+         run_id ${t.varchar(64)} NOT NULL,
+         kind ${t.varchar(20)} NOT NULL,
+         code ${t.varchar(64)} NOT NULL,
+         subject_type ${t.varchar(32)} NOT NULL,
+         subject_key ${t.varchar(255)} NOT NULL,
+         subject_name ${t.varchar(255)},
+         property_alias ${t.varchar(255)},
+         culture ${t.varchar(14)},
+         message ${t.text} NOT NULL,
+         link ${t.text},
+         status ${t.varchar(20)} NOT NULL,
+         first_seen ${t.timestamp} NOT NULL,
+         last_seen ${t.timestamp} NOT NULL,
+         resolved_at ${t.timestamp}
+       )`,
+    )
+    await db.exec(
+      'CREATE INDEX ix_upgrade_report_subject ON upgrade_report (code, subject_key, property_alias, culture)',
+    )
+  },
+}

package/src/schema/users-localisation.ts

@@ -0,0 +1,85 @@
+/**
+ * Migration 011 — what users and localisation store beyond identity: a group's
+ * languages (`umbracoUserGroup2Language`), per-user key/value data
+ * (`umbracoUserData`), single-use tokens for invites and password resets, API
+ * users' client credentials, and dictionary items with their translations
+ * (`cmsDictionary`, `cmsLanguageText`), snake-cased. It also renames
+ * `user_account.is_disabled` to `is_locked_out`, which is what it always meant:
+ * a disabled user is one that is not approved, as in Umbraco. And each culture
+ * of a document records the publish event and name it was last published with,
+ * so publishing one culture leaves the others as they were published.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_CONTENT_EDITING } from './content-editing.ts'
+
+export const STATE_USERS_LOCALISATION = '{6f1d4a8e-0011-4c21-9d3a-8b1e5c7a2f11}'
+
+export const usersLocalisationMigration: Migration = {
+  from: STATE_CONTENT_EDITING,
+  to: STATE_USERS_LOCALISATION,
+  name: 'AddUserAndLocalisationTables',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    // The seed inserted the built-in groups with explicit ids, which left
+    // Postgres' identity where the next group would collide with them
+    const sync = db.dialect.syncIdentity('user_group')
+    if (sync) await db.exec(sync)
+    const ops = schemaOps(db)
+    await ops.renameColumn('user_account', 'is_disabled', 'is_locked_out')
+    await ops.addColumn('document_culture_variation', 'published_event_id', t.integer)
+    await ops.addColumn('document_culture_variation', 'published_name', t.varchar(255))
+    await db.exec(
+      `CREATE TABLE user_group_language (
+         user_group_id ${t.integer} NOT NULL REFERENCES user_group (id),
+         language_id ${t.integer} NOT NULL REFERENCES language (id),
+         PRIMARY KEY (user_group_id, language_id)
+       )`,
+    )
+    await db.exec(
+      `CREATE TABLE user_data (
+         key ${t.uuid} PRIMARY KEY,
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         data_group ${t.varchar(255)} NOT NULL,
+         identifier ${t.varchar(255)} NOT NULL,
+         value ${t.text} NOT NULL
+       )`,
+    )
+    await db.exec('CREATE UNIQUE INDEX ux_user_data ON user_data (user_id, data_group, identifier)')
+    await db.exec(
+      `CREATE TABLE user_token (
+         token_hash ${t.varchar(128)} PRIMARY KEY,
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         purpose ${t.varchar(20)} NOT NULL,
+         expires_at ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec(
+      `CREATE TABLE user_client_credential (
+         client_id ${t.varchar(255)} PRIMARY KEY,
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         secret_hash ${t.text} NOT NULL,
+         create_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec(
+      `CREATE TABLE dictionary_item (
+         id ${t.identity},
+         key ${t.uuid} NOT NULL UNIQUE,
+         parent_key ${t.uuid} NULL REFERENCES dictionary_item (key),
+         item_key ${t.textCi} NOT NULL UNIQUE
+       )`,
+    )
+    await db.exec(
+      `CREATE TABLE dictionary_text (
+         dictionary_key ${t.uuid} NOT NULL REFERENCES dictionary_item (key),
+         language_id ${t.integer} NOT NULL REFERENCES language (id),
+         value ${t.text} NOT NULL,
+         PRIMARY KEY (dictionary_key, language_id)
+       )`,
+    )
+  },
+}

package/src/schema/values.ts

@@ -0,0 +1,108 @@
+/**
+ * Migration 003 — the append-only value layer, schema state, and the columns
+ * schema-as-code needs.
+ *
+ * Pre-1.0, so this replaces `property_data` outright; after 1.0 a change of this
+ * shape would be an expand followed by a contract in a later major.
+ */
+import type { Db } from '../database.ts'
+import { DbDate } from '../dialect.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_CONTENT } from './content.ts'
+
+export const STATE_VALUES = '{6f1d4a8e-0003-4c21-9d3a-8b1e5c7a2f03}'
+
+export const valuesMigration: Migration = {
+  from: STATE_CONTENT,
+  to: STATE_VALUES,
+  name: 'CreateAppendOnlyValues',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+
+    /**
+     * One row per sync or upgrade. `current` is what nodes gate writes on;
+     * `prepared` is what `upgrade check --fix` creates elements under so they
+     * are pending for everyone without blocking anyone.
+     */
+    await db.exec(
+      `CREATE TABLE schema_state (
+         id ${t.identity},
+         version ${t.varchar(50)} NOT NULL,
+         revision ${t.varchar(50)} NOT NULL,
+         hash ${t.varchar(64)},
+         status ${t.varchar(10)} NOT NULL,
+         synced_at ${t.timestamp} NOT NULL,
+         synced_by ${t.varchar(255)}
+       )`,
+    )
+    await db.exec(
+      `INSERT INTO schema_state (version, revision, hash, status, synced_at, synced_by)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      ['0', '0', null, 'current', DbDate.toDb(new Date()), 'install'],
+    )
+
+    /** The event kind: save | publish | rollback | migrate. */
+    await db.exec(`ALTER TABLE content_version ADD COLUMN kind ${t.varchar(10)}`)
+
+    await db.exec(
+      `CREATE TABLE property_value (
+         id ${t.identity},
+         node_id ${t.integer} NOT NULL REFERENCES node (id),
+         property_type_id ${t.integer} NOT NULL REFERENCES property_type (id),
+         language_id ${t.integer} REFERENCES language (id),
+         segment ${t.varchar(256)},
+         event_id ${t.integer} NOT NULL REFERENCES content_version (id),
+         schema_state_id ${t.integer} NOT NULL REFERENCES schema_state (id),
+         is_current ${t.boolean} NOT NULL,
+         int_value ${t.integer},
+         decimal_value ${t.numeric},
+         date_value ${t.timestamp},
+         varchar_value ${t.varchar(512)},
+         text_value ${t.text},
+         sortable_value ${t.varchar(512)}
+       )`,
+    )
+    // The one index that serves the draft read, the as-of reads and the
+    // per-key "latest" lookups.
+    await db.exec(
+      `CREATE INDEX ix_property_value_key ON property_value
+         (node_id, property_type_id, language_id, segment, id DESC)`,
+    )
+    await db.exec('CREATE INDEX ix_property_value_event ON property_value (event_id)')
+    await db.exec('CREATE INDEX ix_property_value_current ON property_value (node_id, is_current)')
+
+    await db.exec('DROP TABLE property_data')
+
+    // Schema-as-code references data types by alias; Umbraco has only a key and a name.
+    await db.exec(`ALTER TABLE data_type ADD COLUMN alias ${t.textCi}`)
+
+    // Schema-as-code: the deployment that introduced an element, and retirement.
+    for (const table of ['content_type', 'property_type', 'data_type']) {
+      await db.exec(
+        `ALTER TABLE ${table} ADD COLUMN since_state_id ${t.integer} REFERENCES schema_state (id)`,
+      )
+      await db.exec(`ALTER TABLE ${table} ADD COLUMN retired_at ${t.timestamp}`)
+    }
+
+    // Multi-node plumbing: node identity and the polled change log.
+    await db.exec(
+      `CREATE TABLE server (
+         node_id ${t.varchar(255)} PRIMARY KEY,
+         version ${t.varchar(50)},
+         revision ${t.varchar(50)},
+         last_seen ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec(
+      `CREATE TABLE cache_instruction (
+         id ${t.identity},
+         kind ${t.varchar(50)} NOT NULL,
+         payload ${t.text},
+         created_at ${t.timestamp} NOT NULL,
+         created_by ${t.varchar(255)}
+       )`,
+    )
+  },
+}