@crombolo/data 0.0.0-stage → 0.10.0

package/src/schema/identity.ts

@@ -0,0 +1,176 @@
+/**
+ * Migration 001 — back-office identity.
+ *
+ * Table and column names follow docs/data-model.md: Umbraco's relational
+ * model with snake_case names. `user` is reserved in Postgres, hence
+ * `user_account`.
+ */
+import type { Db } from '../database.ts'
+import { INITIAL_STATE, type Migration } from '../migrations.ts'
+
+export const STATE_IDENTITY = '{6f1d4a8e-0001-4c21-9d3a-8b1e5c7a2f01}'
+
+export const identityMigration: Migration = {
+  from: INITIAL_STATE,
+  to: STATE_IDENTITY,
+  name: 'CreateIdentityTables',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+
+    await db.exec(
+      `CREATE TABLE user_account (
+         id ${t.identity},
+         key ${t.uuid} NOT NULL UNIQUE,
+         user_name ${t.textCi} NOT NULL,
+         login ${t.textCi} NOT NULL,
+         email ${t.textCi} NOT NULL,
+         password_hash ${t.text},
+         password_config ${t.text},
+         security_stamp ${t.text},
+         language ${t.varchar(14)},
+         avatar ${t.text},
+         kind ${t.integer} NOT NULL,
+         is_disabled ${t.boolean} NOT NULL,
+         is_approved ${t.boolean} NOT NULL,
+         failed_login_attempts ${t.integer} NOT NULL,
+         last_login_date ${t.timestamp},
+         last_lockout_date ${t.timestamp},
+         last_password_change_date ${t.timestamp},
+         invited_date ${t.timestamp},
+         email_confirmed_date ${t.timestamp},
+         create_date ${t.timestamp} NOT NULL,
+         update_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec('CREATE UNIQUE INDEX ux_user_account_login ON user_account (login)')
+
+    await db.exec(
+      `CREATE TABLE user_group (
+         id ${t.identity},
+         key ${t.uuid} NOT NULL UNIQUE,
+         alias ${t.textCi} NOT NULL UNIQUE,
+         name ${t.textCi} NOT NULL,
+         description ${t.text},
+         icon ${t.text},
+         has_access_to_all_languages ${t.boolean} NOT NULL,
+         start_content_id ${t.integer},
+         start_media_id ${t.integer},
+         start_element_id ${t.integer},
+         create_date ${t.timestamp} NOT NULL,
+         update_date ${t.timestamp} NOT NULL
+       )`,
+    )
+
+    await db.exec(
+      `CREATE TABLE user_group_member (
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         user_group_id ${t.integer} NOT NULL REFERENCES user_group (id),
+         PRIMARY KEY (user_id, user_group_id)
+       )`,
+    )
+
+    await db.exec(
+      `CREATE TABLE user_group_section (
+         user_group_id ${t.integer} NOT NULL REFERENCES user_group (id),
+         app_alias ${t.varchar(50)} NOT NULL,
+         PRIMARY KEY (user_group_id, app_alias)
+       )`,
+    )
+
+    // Keyed by the group's key, not its id, exactly as Umbraco does.
+    await db.exec(
+      `CREATE TABLE user_group_permission (
+         id ${t.identity},
+         user_group_key ${t.uuid} NOT NULL REFERENCES user_group (key),
+         permission ${t.varchar(255)} NOT NULL
+       )`,
+    )
+
+    await db.exec(
+      `CREATE TABLE user_group_granular_permission (
+         id ${t.identity},
+         user_group_key ${t.uuid} NOT NULL REFERENCES user_group (key),
+         unique_id ${t.uuid},
+         permission ${t.varchar(255)} NOT NULL,
+         context ${t.varchar(50)} NOT NULL
+       )`,
+    )
+
+    await db.exec(
+      `CREATE TABLE user_start_node (
+         id ${t.identity},
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         start_node ${t.integer} NOT NULL,
+         start_node_type ${t.integer} NOT NULL
+       )`,
+    )
+    await db.exec(
+      'CREATE UNIQUE INDEX ux_user_start_node ON user_start_node (start_node_type, start_node, user_id)',
+    )
+
+    /**
+     * A browser session established by the login endpoint. It exists so the
+     * authorize endpoint can identify the user without re-prompting, which is
+     * how Umbraco's cookie-then-authorization-code flow works.
+     */
+    await db.exec(
+      `CREATE TABLE user_login_session (
+         session_id ${t.uuid} PRIMARY KEY,
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         logged_in_utc ${t.timestamp} NOT NULL,
+         last_validated_utc ${t.timestamp} NOT NULL,
+         logged_out_utc ${t.timestamp},
+         ip_address ${t.text}
+       )`,
+    )
+    await db.exec(
+      'CREATE INDEX ix_user_login_session_validated ON user_login_session (last_validated_utc)',
+    )
+
+    /**
+     * Single-use authorization codes. Only the hash is stored: a code is a
+     * bearer credential, so a database read must not yield a usable one.
+     */
+    await db.exec(
+      `CREATE TABLE auth_code (
+         code_hash ${t.text} PRIMARY KEY,
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         session_id ${t.uuid} NOT NULL,
+         client_id ${t.varchar(255)} NOT NULL,
+         redirect_uri ${t.text} NOT NULL,
+         code_challenge ${t.text} NOT NULL,
+         code_challenge_method ${t.varchar(10)} NOT NULL,
+         scope ${t.text} NOT NULL,
+         expires_at ${t.timestamp} NOT NULL,
+         consumed_at ${t.timestamp},
+         create_date ${t.timestamp} NOT NULL
+       )`,
+    )
+
+    /**
+     * Reference tokens. Umbraco issues opaque, server-side tokens rather than
+     * JWTs, so validation is a database lookup and revocation is immediate.
+     * `parent_id` chains a refreshed token to the one it replaced so a whole
+     * chain can be revoked on reuse.
+     */
+    await db.exec(
+      `CREATE TABLE auth_token (
+         id ${t.identity},
+         token_hash ${t.text} NOT NULL UNIQUE,
+         token_type ${t.varchar(20)} NOT NULL,
+         user_id ${t.integer} NOT NULL REFERENCES user_account (id),
+         session_id ${t.uuid} NOT NULL,
+         client_id ${t.varchar(255)} NOT NULL,
+         scope ${t.text} NOT NULL,
+         expires_at ${t.timestamp} NOT NULL,
+         create_date ${t.timestamp} NOT NULL,
+         revoked_at ${t.timestamp},
+         parent_id ${t.integer}
+       )`,
+    )
+    await db.exec('CREATE INDEX ix_auth_token_session ON auth_token (session_id)')
+    await db.exec('CREATE INDEX ix_auth_token_expires ON auth_token (expires_at)')
+  },
+}

package/src/schema/log-viewer.ts

@@ -0,0 +1,68 @@
+/**
+ * Migration 012 — the log viewer's saved searches (Umbraco's
+ * `umbracoLogViewerQuery`), seeded with Umbraco's installer searches. Two of
+ * those ask about Umbraco's own namespaces and message templates; here they ask
+ * the same of crombolo's. The two about Umbraco's `SortedComponentTypes`
+ * property, which nothing here logs, are left out.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_USERS_LOCALISATION } from './users-localisation.ts'
+
+export const STATE_LOG_VIEWER = '{6f1d4a8e-0012-4c21-9d3a-8b1e5c7a2f12}'
+
+export const DEFAULT_LOG_SEARCHES: ReadonlyArray<{ name: string; query: string }> = [
+  {
+    name: 'Find all logs where the Level is NOT Verbose and NOT Debug',
+    query: "Not(@Level='Verbose') and Not(@Level='Debug')",
+  },
+  {
+    name: 'Find all logs that has an exception property (Warning, Error & Fatal with Exceptions)',
+    query: 'Has(@Exception)',
+  },
+  { name: "Find all logs that have the property 'Duration'", query: 'Has(Duration)' },
+  {
+    name: "Find all logs that have the property 'Duration' and the duration is greater than 1000ms",
+    query: 'Has(Duration) and Duration > 1000',
+  },
+  {
+    name: "Find all logs that are within the namespace 'crombolo.schema'",
+    query: "StartsWith(SourceContext, 'crombolo.schema')",
+  },
+  {
+    name: 'Find all logs that use a specific log message template',
+    query: "@MessageTemplate = 'Operation {operationId} ({method} {path}) is not implemented'",
+  },
+  {
+    name: 'Find all logs that the message has localhost in it with SQL like',
+    query: "@Message like '%localhost%'",
+  },
+  {
+    name: "Find all logs that the message that starts with 'end' in it with SQL like",
+    query: "@Message like 'end%'",
+  },
+]
+
+export const logViewerMigration: Migration = {
+  from: STATE_USERS_LOCALISATION,
+  to: STATE_LOG_VIEWER,
+  name: 'AddLogViewerSavedSearches',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    // The name is matched exactly, case and all, as Umbraco matches it
+    await db.exec(
+      `CREATE TABLE log_viewer_query (
+         id ${t.identity},
+         name ${t.text} NOT NULL UNIQUE,
+         query ${t.text} NOT NULL
+       )`,
+    )
+    for (const search of DEFAULT_LOG_SEARCHES)
+      await db.exec('INSERT INTO log_viewer_query (name, query) VALUES (?, ?)', [
+        search.name,
+        search.query,
+      ])
+  },
+}

package/src/schema/member-property-type.ts

@@ -0,0 +1,30 @@
+/**
+ * Migration 008 — `member_property_type`: what a member may see and edit of
+ * each member-type property, and whether it is sensitive. Umbraco's
+ * `cmsMemberType` (`propertytypeId`, `memberCanEdit`, `viewOnProfile`,
+ * `isSensitive`), snake-cased.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_GROUP_PERMISSIONS } from './group-permissions.ts'
+
+export const STATE_MEMBER_PROPERTY_TYPE = '{6f1d4a8e-0008-4c21-9d3a-8b1e5c7a2f08}'
+
+export const memberPropertyTypeMigration: Migration = {
+  from: STATE_GROUP_PERMISSIONS,
+  to: STATE_MEMBER_PROPERTY_TYPE,
+  name: 'AddMemberPropertyType',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+    await db.exec(
+      `CREATE TABLE member_property_type (
+         property_type_id ${t.integer} PRIMARY KEY REFERENCES property_type (id),
+         member_can_edit ${t.boolean} NOT NULL,
+         member_can_view ${t.boolean} NOT NULL,
+         is_sensitive ${t.boolean} NOT NULL
+       )`,
+    )
+  },
+}

package/src/schema/members.ts

@@ -0,0 +1,97 @@
+/**
+ * Migration 013 — members and the identities they sign in with.
+ *
+ * A member is a node facet, exactly like a document: `node` + `content` +
+ * `content_version` + `member`, so member types, properties and versioning are
+ * the machinery that already exists. Member groups are plain `node` rows with
+ * the MemberGroup object type — no table of their own — and `member_group_member`
+ * is the membership between them (Umbraco's `cmsMember2MemberGroup`).
+ *
+ * `external_login` is deliberately polymorphic: `user_or_member_key` serves
+ * back-office users and members alike, as Umbraco's does, so federation added
+ * for one works for the other.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_LOG_VIEWER } from './log-viewer.ts'
+
+export const STATE_MEMBERS = '{6f1d4a8e-0013-4c21-9d3a-8b1e5c7a2f13}'
+
+export const membersMigration: Migration = {
+  from: STATE_LOG_VIEWER,
+  to: STATE_MEMBERS,
+  name: 'AddMembers',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+
+    // Umbraco's `cmsMember`, snake-cased. The password columns stay nullable:
+    // a member who only ever signs in through a provider has no password.
+    await db.exec(
+      `CREATE TABLE member (
+         node_id ${t.integer} PRIMARY KEY REFERENCES content (node_id),
+         email ${t.textCi} NOT NULL,
+         login_name ${t.textCi} NOT NULL,
+         password ${t.text},
+         password_config ${t.text},
+         security_stamp_token ${t.text},
+         email_confirmed_date ${t.timestamp},
+         failed_password_attempts ${t.integer} NOT NULL,
+         is_locked_out ${t.boolean} NOT NULL,
+         is_approved ${t.boolean} NOT NULL,
+         last_login_date ${t.timestamp},
+         last_lockout_date ${t.timestamp},
+         last_password_change_date ${t.timestamp}
+       )`,
+    )
+    await db.exec('CREATE UNIQUE INDEX ux_member_login ON member (login_name)')
+    await db.exec('CREATE INDEX ix_member_email ON member (email)')
+
+    await db.exec(
+      `CREATE TABLE member_group_member (
+         member_id ${t.integer} NOT NULL REFERENCES member (node_id),
+         member_group_id ${t.integer} NOT NULL REFERENCES node (id),
+         PRIMARY KEY (member_id, member_group_id)
+       )`,
+    )
+    await db.exec(
+      'CREATE INDEX ix_member_group_member_group ON member_group_member (member_group_id)',
+    )
+
+    await db.exec(
+      `CREATE TABLE external_login (
+         id ${t.identity},
+         user_or_member_key ${t.text} NOT NULL,
+         login_provider ${t.textCi} NOT NULL,
+         provider_key ${t.text} NOT NULL,
+         create_date ${t.timestamp} NOT NULL,
+         user_data ${t.text}
+       )`,
+    )
+    // One identity per provider per principal, and the sign-in lookup is by
+    // the provider's own key.
+    await db.exec(
+      `CREATE UNIQUE INDEX ux_external_login_provider_principal
+         ON external_login (login_provider, user_or_member_key)`,
+    )
+    await db.exec(
+      `CREATE INDEX ix_external_login_provider_key
+         ON external_login (login_provider, provider_key)`,
+    )
+
+    await db.exec(
+      `CREATE TABLE external_login_token (
+         id ${t.identity},
+         external_login_id ${t.integer} NOT NULL REFERENCES external_login (id),
+         name ${t.textCi} NOT NULL,
+         value ${t.text} NOT NULL,
+         create_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec(
+      `CREATE UNIQUE INDEX ux_external_login_token_name
+         ON external_login_token (external_login_id, name)`,
+    )
+  },
+}

package/src/schema/plan.ts

@@ -0,0 +1,77 @@
+/**
+ * The migration chain. Append new migrations; never edit a released one.
+ *
+ * Every step here declares `release: '0.3.0'`, because 0.3.0 is the first release
+ * there has ever been: nothing was published before the repository was split, so
+ * none of these shipped in any earlier version, whatever the numbers said while
+ * they were being written.
+ *
+ * `release` is compared between a contract and the expand it removes — a
+ * contract may only take away what an *earlier* release added — and a contract
+ * 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 { assistantMigration } from './assistant.ts'
+import { bundleComponentsMigration } from './bundle-components.ts'
+import { bundlePackageMigration } from './bundle-package.ts'
+import { bundlesRenameMigration } from './bundles-rename.ts'
+import { changeReportMigration } from './change-report.ts'
+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 { elementsMigration } from './elements.ts'
+import { formPermissionPrefixMigration } from './form-permission-prefix.ts'
+import { formPermissionsMigration } from './form-permissions.ts'
+import { formWorkflowsMigration } from './form-workflows.ts'
+import { formsMigration } from './forms.ts'
+import { groupPermissionsMigration } from './group-permissions.ts'
+import { identityMigration } from './identity.ts'
+import { logViewerMigration } from './log-viewer.ts'
+import { memberPropertyTypeMigration } from './member-property-type.ts'
+import { membersMigration } from './members.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 { serverRoleMigration } from './server-role.ts'
+import { sinceVersionMigration } from './since-version.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'
+
+export const cromboloPlan = new MigrationPlan([
+  identityMigration,
+  contentMigration,
+  valuesMigration,
+  sinceVersionMigration,
+  upgradeReportMigration,
+  recycleBinMigration,
+  groupPermissionsMigration,
+  memberPropertyTypeMigration,
+  richTextUiMigration,
+  contentEditingMigration,
+  usersLocalisationMigration,
+  logViewerMigration,
+  membersMigration,
+  publicAccessMigration,
+  redirectsMigration,
+  elementsMigration,
+  assistantMigration,
+  changeReportMigration,
+  transferRunsMigration,
+  clientIdPrefixMigration,
+  serverRoleMigration,
+  createdPackagesMigration,
+  formsMigration,
+  formWorkflowsMigration,
+  formPermissionsMigration,
+  formPermissionPrefixMigration,
+  bundlesRenameMigration,
+  bundleComponentsMigration,
+  bundlePackageMigration,
+  transferRunPackageMigration,
+])

package/src/schema/public-access.ts

@@ -0,0 +1,56 @@
+/**
+ * Migration 014 — public access: which pages are protected, and by what.
+ *
+ * Umbraco's `umbracoAccess` + `umbracoAccessRule`, snake-cased. One entry per
+ * protected branch root, naming the page to show a caller who is not signed in
+ * (`login_node_id`) and the page to show one who is signed in but not allowed
+ * (`error_node_id`). The rules are values, not foreign keys — a member group's
+ * **name** or a member's **username**, exactly as Umbraco stores them — because
+ * a rule is evaluated against the claims a signed-in member carries, and renaming
+ * the group is what breaks the rule, not deleting a row.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_MEMBERS } from './members.ts'
+
+export const STATE_PUBLIC_ACCESS = '{6f1d4a8e-0014-4c21-9d3a-8b1e5c7a2f14}'
+
+export const publicAccessMigration: Migration = {
+  from: STATE_MEMBERS,
+  to: STATE_PUBLIC_ACCESS,
+  name: 'AddPublicAccess',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+
+    await db.exec(
+      `CREATE TABLE public_access (
+         id ${t.identity},
+         key ${t.text} NOT NULL,
+         node_id ${t.integer} NOT NULL REFERENCES node (id),
+         login_node_id ${t.integer} NOT NULL REFERENCES node (id),
+         error_node_id ${t.integer} NOT NULL REFERENCES node (id),
+         create_date ${t.timestamp} NOT NULL,
+         update_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    // One entry per protected page, and the render path looks an entry up by node.
+    await db.exec('CREATE UNIQUE INDEX ux_public_access_node ON public_access (node_id)')
+    await db.exec('CREATE UNIQUE INDEX ux_public_access_key ON public_access (key)')
+
+    await db.exec(
+      `CREATE TABLE public_access_rule (
+         id ${t.identity},
+         public_access_id ${t.integer} NOT NULL REFERENCES public_access (id),
+         rule_type ${t.varchar(255)} NOT NULL,
+         rule_value ${t.textCi} NOT NULL,
+         create_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec(
+      `CREATE UNIQUE INDEX ux_public_access_rule
+         ON public_access_rule (public_access_id, rule_type, rule_value)`,
+    )
+  },
+}

package/src/schema/recycle-bin.ts

@@ -0,0 +1,21 @@
+/**
+ * Migration 006 — `document.original_parent_id`: where a trashed document came
+ * from, so the recycle bin can say so and a restore can put it back.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_UPGRADE_REPORT } from './upgrade-report.ts'
+
+export const STATE_RECYCLE_BIN = '{6f1d4a8e-0006-4c21-9d3a-8b1e5c7a2f06}'
+
+export const recycleBinMigration: Migration = {
+  from: STATE_UPGRADE_REPORT,
+  to: STATE_RECYCLE_BIN,
+  name: 'AddRecycleBinOriginalParent',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    await schemaOps(db).addColumn('document', 'original_parent_id', db.dialect.types.integer)
+  },
+}

package/src/schema/redirects.ts

@@ -0,0 +1,57 @@
+/**
+ * Migration 015 — redirects: the URLs a page used to answer on.
+ *
+ * Umbraco's `umbracoRedirectUrl` holds one row per retired route, always pointing
+ * at a document, and resolves a duplicate by taking the most recent. This table
+ * widens it in two ways, both needed by redirects a site declares in code rather
+ * than earns by being renamed: a rule may match a subtree or a regular expression
+ * as well as one exact route, and it may point at a path or an external URL as
+ * well as at a document.
+ *
+ * `root_key` scopes a rule to the document a hostname roots, as Umbraco scopes a
+ * route by the node id its domain sits on — so renaming the hostname leaves every
+ * redirect below it working. `match_hash` is a digest of everything a rule matches
+ * on: a unique index cannot dedupe over nullable columns, since NULL never equals
+ * NULL in either dialect, and a pattern is too long to index directly. Umbraco
+ * indexes a hash of the URL for the same two reasons.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_PUBLIC_ACCESS } from './public-access.ts'
+
+export const STATE_REDIRECTS = '{6f1d4a8e-0015-4b73-a2c5-91e4d7b3086a}'
+
+export const redirectsMigration: Migration = {
+  from: STATE_PUBLIC_ACCESS,
+  to: STATE_REDIRECTS,
+  name: 'AddRedirectUrl',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+
+    await db.exec(
+      `CREATE TABLE redirect_url (
+         id ${t.identity},
+         key ${t.text} NOT NULL,
+         source ${t.varchar(16)} NOT NULL,
+         match_kind ${t.varchar(16)} NOT NULL,
+         pattern ${t.text} NOT NULL,
+         root_key ${t.text} NULL,
+         culture ${t.varchar(32)} NULL,
+         target_kind ${t.varchar(16)} NOT NULL,
+         target ${t.text} NOT NULL,
+         status_code ${t.integer} NOT NULL,
+         sort_order ${t.integer} NOT NULL,
+         match_hash ${t.varchar(64)} NOT NULL,
+         create_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec('CREATE UNIQUE INDEX ux_redirect_url_key ON redirect_url (key)')
+    // One rule per thing matched: registering a route a page already gave up
+    // replaces where it points rather than stacking another row behind it.
+    await db.exec('CREATE UNIQUE INDEX ux_redirect_url_match ON redirect_url (match_hash)')
+    // The dashboard lists by recency, and the Info tab lists by document.
+    await db.exec('CREATE INDEX ix_redirect_url_target ON redirect_url (target_kind, target)')
+  },
+}

package/src/schema/rich-text-ui.ts

@@ -0,0 +1,34 @@
+/**
+ * Migration 009 — the rich text data type's editor UI. Databases seeded
+ * before this carry `Umb.PropertyEditorUi.RichText`, which the backoffice does
+ * not register ("The configured property editor UI could not be found");
+ * Umbraco seeds `Umb.PropertyEditorUi.Tiptap` with its configuration. Only a
+ * row still carrying the wrong alias is changed; a customised one is left.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { RICH_TEXT_CONFIG } from './content-seed.ts'
+import { STATE_MEMBER_PROPERTY_TYPE } from './member-property-type.ts'
+
+export const STATE_RICH_TEXT_UI = '{6f1d4a8e-0009-4c21-9d3a-8b1e5c7a2f09}'
+
+export const richTextUiMigration: Migration = {
+  from: STATE_MEMBER_PROPERTY_TYPE,
+  to: STATE_RICH_TEXT_UI,
+  name: 'FixRichTextEditorUi',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    await db.exec(
+      `UPDATE data_type SET editor_ui_alias = ?, config = ?
+       WHERE editor_ui_alias = ?
+         AND node_id = (SELECT id FROM node WHERE unique_id = ?)`,
+      [
+        'Umb.PropertyEditorUi.Tiptap',
+        JSON.stringify(RICH_TEXT_CONFIG),
+        'Umb.PropertyEditorUi.RichText',
+        'ca90c950-0aff-4e72-b976-a30b1ac57dad',
+      ],
+    )
+  },
+}