@crombolo/data 0.0.0-stage → 0.10.0

package/src/schema/assistant.ts

@@ -0,0 +1,74 @@
+/**
+ * Migration 017 — changesets: what the assistant has proposed and nobody has
+ * approved yet.
+ *
+ * The assistant never writes to the CMS. It appends to a changeset, and a person
+ * approves each item, so the proposal has to outlive the conversation that
+ * produced it: a changeset raised over MCP by an agent in a terminal is reviewed
+ * in the backoffice by a user in a browser, in another process.
+ *
+ * `body` holds the Management API request the approval will dispatch, as JSON, so
+ * an approved item needs no translation — the proposal *is* a prepared request,
+ * and applying it takes the same authorised path as the editor's own Save.
+ * `baseline` is what the entity looked like when the proposal was made; apply
+ * refuses when it no longer matches, rather than overwriting someone's work.
+ *
+ * The tables are created whether or not the assistant is configured, and sit
+ * empty when it is not. A migration conditional on configuration would make
+ * schema state depend on a config file, which the upgrade plan cannot express.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_ELEMENTS } from './elements.ts'
+
+export const STATE_ASSISTANT = '{6f1d4a8e-0017-4c92-8f3b-2a7e5d1c4b80}'
+
+export const assistantMigration: Migration = {
+  from: STATE_ELEMENTS,
+  to: STATE_ASSISTANT,
+  name: 'AddAssistantChangesets',
+  kind: 'expand',
+  release: '0.3.0',
+  async up(db: Db) {
+    const t = db.dialect.types
+
+    await db.exec(
+      `CREATE TABLE assistant_changeset (
+         id ${t.identity},
+         key ${t.text} NOT NULL,
+         user_key ${t.text} NOT NULL,
+         title ${t.text} NOT NULL,
+         origin ${t.varchar(16)} NOT NULL,
+         create_date ${t.timestamp} NOT NULL,
+         update_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec('CREATE UNIQUE INDEX ux_assistant_changeset_key ON assistant_changeset (key)')
+    // The drawer lists the signed-in user's own changesets, most recent first.
+    await db.exec(
+      'CREATE INDEX ix_assistant_changeset_user ON assistant_changeset (user_key, update_date)',
+    )
+
+    await db.exec(
+      `CREATE TABLE assistant_change (
+         id ${t.identity},
+         key ${t.text} NOT NULL,
+         changeset_key ${t.text} NOT NULL,
+         sort_order ${t.integer} NOT NULL,
+         kind ${t.varchar(32)} NOT NULL,
+         summary ${t.text} NOT NULL,
+         status ${t.varchar(16)} NOT NULL,
+         params ${t.text} NOT NULL,
+         body ${t.text} NOT NULL,
+         baseline ${t.text} NULL,
+         problems ${t.text} NOT NULL,
+         error ${t.text} NULL,
+         create_date ${t.timestamp} NOT NULL
+       )`,
+    )
+    await db.exec('CREATE UNIQUE INDEX ux_assistant_change_key ON assistant_change (key)')
+    await db.exec(
+      'CREATE INDEX ix_assistant_change_changeset ON assistant_change (changeset_key, sort_order)',
+    )
+  },
+}

package/src/schema/built-in-content-types.ts

@@ -0,0 +1,106 @@
+/**
+ * Content types this CMS ships. "Search & sharing" (`seoFields`) is a
+ * composition a site opts into with `compositions = ["seoFields"]`: the fields
+ * the head helper, the sitemap and the editor's preview read.
+ *
+ * A **system** type, like the Folder, Image and File media types: ensured at
+ * every boot, exempt from schema retirement, not deletable, alias fixed. A site
+ * may extend it with a file of the same alias and key; the shipped fields stay.
+ */
+import {
+  type ContentTypeAggregate,
+  SEO_FIELDS_PROPERTIES,
+  SYSTEM_CONTENT_TYPE_KEYS,
+  type SystemPropertyModel,
+} from '@crombolo/core'
+import type { Db } from '../database.ts'
+import { ContentTypeRepository } from '../repositories/content-types.ts'
+
+export interface BuiltInContentType {
+  key: string
+  alias: string
+  name: string
+  description: string
+  icon: string
+  tab: { key: string; name: string; alias: string }
+  properties: readonly SystemPropertyModel[]
+}
+
+export const SEO_FIELDS_TYPE: BuiltInContentType = {
+  key: SYSTEM_CONTENT_TYPE_KEYS.SeoFields,
+  alias: 'seoFields',
+  name: 'Search & sharing',
+  description: 'How a page appears in search results and when shared.',
+  icon: 'icon-search',
+  tab: { key: '3f8a1d6c-5e2b-4a07-9c84-b1e7d0f2a658', name: 'Search & sharing', alias: 'seo' },
+  properties: SEO_FIELDS_PROPERTIES,
+}
+
+export const SYSTEM_CONTENT_TYPES: readonly BuiltInContentType[] = [SEO_FIELDS_TYPE]
+
+export function systemContentTypeAggregate(def: BuiltInContentType): ContentTypeAggregate {
+  return {
+    key: def.key,
+    alias: def.alias,
+    name: def.name,
+    description: def.description,
+    icon: def.icon,
+    allowedAsRoot: false,
+    variesByCulture: false,
+    variesBySegment: false,
+    isElement: false,
+    allowedInLibrary: false,
+    collectionKey: null,
+    cleanup: {
+      preventCleanup: false,
+      keepAllVersionsNewerThanDays: null,
+      keepLatestVersionPerDayForDays: null,
+    },
+    containers: [
+      {
+        key: def.tab.key,
+        name: def.tab.name,
+        alias: def.tab.alias,
+        type: 'Tab',
+        sortOrder: 0,
+        parentKey: null,
+      },
+    ],
+    properties: def.properties.map((p, sortOrder) => ({
+      key: p.key,
+      alias: p.alias,
+      name: p.name,
+      description: p.description,
+      dataTypeKey: p.dataTypeKey,
+      containerKey: def.tab.key,
+      sortOrder,
+      variesByCulture: false,
+      variesBySegment: false,
+      mandatory: false,
+      mandatoryMessage: null,
+      regEx: null,
+      regExMessage: null,
+      labelOnTop: false,
+    })),
+    compositions: [],
+    allowedContentTypes: [],
+    allowedComponentKeys: [],
+    defaultComponentKey: null,
+    parentKey: null,
+  }
+}
+
+/**
+ * Creates any missing system content type by its fixed key; never changes one
+ * that exists. Idempotent; runs at every boot.
+ */
+export async function ensureSystemContentTypes(db: Db): Promise<string[]> {
+  const repo = new ContentTypeRepository(db, { kind: 'document' })
+  const created: string[] = []
+  for (const def of SYSTEM_CONTENT_TYPES) {
+    if (await repo.byKey(def.key)) continue
+    await repo.save(systemContentTypeAggregate(def))
+    created.push(def.alias)
+  }
+  return created
+}

package/src/schema/built-in-media-types.ts

@@ -0,0 +1,335 @@
+/**
+ * Umbraco's seven built-in media types, verbatim from its installer
+ * (`DatabaseDataCreator`): keys, aliases, names, icons, the one group each
+ * carries, and every property with its key.
+ *
+ * Folder, Image and File are **system** media types (Umbraco's
+ * `IsSystemMediaType`): shipped with the framework, ensured at every boot, not
+ * deletable, alias fixed. Video, Audio, Article and Vector Graphics are
+ * ordinary types a site owns as files in `schema/media-types/`; `crombolo
+ * init` scaffolds them and deleting one deletes its file.
+ */
+import { type ContentTypeAggregate, normaliseUuid, SYSTEM_MEDIA_TYPE_KEYS } from '@crombolo/core'
+import type { Db } from '../database.ts'
+import { ContentTypeRepository } from '../repositories/content-types.ts'
+import { DEFAULT_DATA_TYPES } from './content-seed.ts'
+
+export interface BuiltInMediaProperty {
+  key: string
+  alias: string
+  name: string
+  /** A built-in data type alias. */
+  dataType: string
+  mandatory: boolean
+}
+
+export interface BuiltInMediaType {
+  key: string
+  alias: string
+  name: string
+  icon: string
+  /** Folder, Image and File: undeletable, alias fixed. */
+  system: boolean
+  /** A built-in data type alias for the collection view. */
+  collection?: string
+  /** Aliases; Folder allows every built-in, the ones a site has. */
+  allowChildren: string[]
+  group?: { key: string; name: string; alias: string }
+  properties: BuiltInMediaProperty[]
+}
+
+const extension = (key: string): BuiltInMediaProperty => ({
+  key,
+  alias: 'umbracoExtension',
+  name: 'File extension',
+  dataType: 'label',
+  mandatory: false,
+})
+const bytes = (key: string): BuiltInMediaProperty => ({
+  key,
+  alias: 'umbracoBytes',
+  name: 'File size',
+  dataType: 'labelBytes',
+  mandatory: false,
+})
+const pixels = (key: string, alias: 'umbracoWidth' | 'umbracoHeight'): BuiltInMediaProperty => ({
+  key,
+  alias,
+  name: alias === 'umbracoWidth' ? 'Width' : 'Height',
+  dataType: 'labelPixels',
+  mandatory: false,
+})
+
+export const BUILT_IN_MEDIA_TYPES: readonly BuiltInMediaType[] = [
+  {
+    key: SYSTEM_MEDIA_TYPE_KEYS.Folder,
+    alias: 'Folder',
+    name: 'Folder',
+    icon: 'icon-folder',
+    system: true,
+    collection: 'listViewMedia',
+    allowChildren: [
+      'Folder',
+      'Image',
+      'File',
+      'umbracoMediaVideo',
+      'umbracoMediaAudio',
+      'umbracoMediaArticle',
+      'umbracoMediaVectorGraphics',
+    ],
+    properties: [],
+  },
+  {
+    key: SYSTEM_MEDIA_TYPE_KEYS.Image,
+    alias: 'Image',
+    name: 'Image',
+    icon: 'icon-picture',
+    system: true,
+    allowChildren: [],
+    group: { key: '79ed4d07-254a-42cf-8fa9-ebe1c116a596', name: 'Image', alias: 'image' },
+    properties: [
+      {
+        key: 'b646ca8f-e469-4fc2-a48a-d4dc1aa64a53',
+        alias: 'umbracoFile',
+        name: 'Image',
+        dataType: 'imageCropper',
+        mandatory: true,
+      },
+      pixels('a68d453b-1f62-44f4-9f71-0b6bbd43c355', 'umbracoWidth'),
+      pixels('854087f6-648b-40ed-bc98-b8a9789e80b9', 'umbracoHeight'),
+      bytes('bd4c5ace-26e3-4a8b-af1a-e8206a35fa07'),
+      extension('f7786fe8-724a-4ed0-b244-72546db32a92'),
+    ],
+  },
+  {
+    key: SYSTEM_MEDIA_TYPE_KEYS.File,
+    alias: 'File',
+    name: 'File',
+    icon: 'icon-document',
+    system: true,
+    allowChildren: [],
+    group: { key: '50899f9c-023a-4466-b623-aba9049885fe', name: 'File', alias: 'file' },
+    properties: [
+      {
+        key: 'a0fb68f3-f427-47a6-afce-536ffa5b64e9',
+        alias: 'umbracoFile',
+        name: 'File',
+        dataType: 'upload',
+        mandatory: true,
+      },
+      extension('3531c0a3-4e0a-4324-a621-b9d3822b071f'),
+      bytes('f9527050-59bc-43e4-8fa8-1658d1319ff5'),
+    ],
+  },
+  {
+    key: 'f6c515bb-653c-4bdc-821c-987729ebe327',
+    alias: 'umbracoMediaVideo',
+    name: 'Video',
+    icon: 'icon-video',
+    system: false,
+    allowChildren: [],
+    group: { key: '2f0a61b6-cf92-4ff4-b437-751ab35eb254', name: 'Video', alias: 'video' },
+    properties: [
+      {
+        key: 'bed8ab97-d85f-44d2-a8b9-aef6893f9610',
+        alias: 'umbracoFile',
+        name: 'Video',
+        dataType: 'uploadVideo',
+        mandatory: true,
+      },
+      extension('edd2b3fd-1e57-4e57-935e-096defccdc9b'),
+      bytes('180eeecf-1f00-409e-8234-bba967e08b0a'),
+    ],
+  },
+  {
+    key: 'a5ddeee0-8fd8-4cee-a658-6f1fcdb00de3',
+    alias: 'umbracoMediaAudio',
+    name: 'Audio',
+    icon: 'icon-audio-lines',
+    system: false,
+    allowChildren: [],
+    group: { key: '335fb495-0a87-4e82-b902-30eb367b767c', name: 'Audio', alias: 'audio' },
+    properties: [
+      {
+        key: '1f48d730-f174-4684-afad-a335e59d84a0',
+        alias: 'umbracoFile',
+        name: 'Audio',
+        dataType: 'uploadAudio',
+        mandatory: true,
+      },
+      extension('1bee433f-a21a-4031-8e03-af01bb8d2de9'),
+      bytes('3cbf538a-29ab-4317-a9eb-bbcdf1a54260'),
+    ],
+  },
+  {
+    key: 'a43e3414-9599-4230-a7d3-943a21b20122',
+    alias: 'umbracoMediaArticle',
+    name: 'Article',
+    icon: 'icon-article',
+    system: false,
+    allowChildren: [],
+    group: { key: '9af3bd65-f687-4453-9518-5f180d1898ec', name: 'Article', alias: 'article' },
+    properties: [
+      {
+        key: 'e5c8c2d0-2d82-4f01-b53a-45a1d1cbf19c',
+        alias: 'umbracoFile',
+        name: 'Article',
+        dataType: 'uploadArticle',
+        mandatory: true,
+      },
+      extension('ef1b4af7-36de-45eb-8c18-a2de07319227'),
+      bytes('aab7d00c-7209-4337-be3f-a4421c8d79a0'),
+    ],
+  },
+  {
+    key: 'c4b1efcf-a9d5-41c4-9621-e9d273b52a9c',
+    alias: 'umbracoMediaVectorGraphics',
+    name: 'Vector Graphics (SVG)',
+    icon: 'icon-origami',
+    system: false,
+    allowChildren: [],
+    group: {
+      key: 'f199b4d7-9e84-439f-8531-f87d9af37711',
+      name: 'Vector Graphics',
+      alias: 'vectorGraphics',
+    },
+    properties: [
+      {
+        key: 'e2a2bdf2-971b-483e-95a1-4104cc06af26',
+        alias: 'umbracoFile',
+        name: 'Vector Graphics',
+        dataType: 'uploadVectorGraphics',
+        mandatory: true,
+      },
+      extension('0f25a89e-2eb7-49bc-a7b4-759a7e4c69f2'),
+      bytes('09a07aff-861d-4769-a2b0-c165ebd43d39'),
+      pixels('5bc7e468-c53e-41a6-a522-2723f3b94514', 'umbracoWidth'),
+      pixels('9e4c2b59-6bc6-4648-bb71-b0f45ddbc274', 'umbracoHeight'),
+    ],
+  },
+]
+
+export const SYSTEM_MEDIA_TYPES = BUILT_IN_MEDIA_TYPES.filter((t) => t.system)
+
+const dataTypeKey = (alias: string): string => {
+  const found = DEFAULT_DATA_TYPES.find((d) => d.alias === alias)
+  if (!found) throw new Error(`built-in media types reference unknown data type "${alias}"`)
+  return found.key
+}
+
+/** The aggregate for a built-in, allowing as children only the types given. */
+export function builtInMediaTypeAggregate(
+  def: BuiltInMediaType,
+  allowedChildKeys: readonly string[],
+): ContentTypeAggregate {
+  return {
+    key: def.key,
+    alias: def.alias,
+    name: def.name,
+    description: null,
+    icon: def.icon,
+    allowedAsRoot: true,
+    variesByCulture: false,
+    variesBySegment: false,
+    isElement: false,
+    allowedInLibrary: false,
+    collectionKey: def.collection ? dataTypeKey(def.collection) : null,
+    cleanup: {
+      preventCleanup: false,
+      keepAllVersionsNewerThanDays: null,
+      keepLatestVersionPerDayForDays: null,
+    },
+    containers: def.group
+      ? [
+          {
+            key: def.group.key,
+            name: def.group.name,
+            alias: def.group.alias,
+            type: 'Group',
+            sortOrder: 0,
+            parentKey: null,
+          },
+        ]
+      : [],
+    properties: def.properties.map((p, sortOrder) => ({
+      key: p.key,
+      alias: p.alias,
+      name: p.name,
+      description: null,
+      dataTypeKey: dataTypeKey(p.dataType),
+      containerKey: def.group?.key ?? null,
+      sortOrder,
+      variesByCulture: false,
+      variesBySegment: false,
+      mandatory: p.mandatory,
+      mandatoryMessage: null,
+      regEx: null,
+      regExMessage: null,
+      labelOnTop: false,
+    })),
+    compositions: [],
+    allowedContentTypes: allowedChildKeys.map((contentTypeKey, sortOrder) => ({
+      contentTypeKey,
+      sortOrder,
+    })),
+    allowedComponentKeys: [],
+    defaultComponentKey: null,
+    parentKey: null,
+  }
+}
+
+export interface EnsureMediaTypesOptions {
+  /**
+   * Link Folder to every built-in media type the site has. Skipped when the
+   * site defines Folder in a file: then the file says what Folder allows.
+   */
+  linkFolderChildren?: boolean
+}
+
+/**
+ * Creates any missing system media type (Folder, Image, File) by its fixed
+ * key; never changes one that exists. Idempotent; runs at every boot, before
+ * and after the schema sync.
+ */
+export async function ensureSystemMediaTypes(
+  db: Db,
+  options: EnsureMediaTypesOptions = {},
+): Promise<string[]> {
+  const repo = new ContentTypeRepository(db, { kind: 'media' })
+  const created: string[] = []
+  for (const def of SYSTEM_MEDIA_TYPES) {
+    if (await repo.byKey(def.key)) continue
+    const systemChildren = def.allowChildren
+      .map((alias) => SYSTEM_MEDIA_TYPES.find((s) => s.alias === alias)?.key)
+      .filter((key): key is string => key !== undefined)
+    await repo.save(builtInMediaTypeAggregate(def, systemChildren))
+    created.push(def.alias)
+  }
+  if (options.linkFolderChildren) {
+    const folderDef = BUILT_IN_MEDIA_TYPES.find((t) => t.alias === 'Folder') as BuiltInMediaType
+    const folder = await repo.byKey(folderDef.key)
+    if (folder) {
+      const allowed = new Set(
+        folder.allowedContentTypes.map((a) => normaliseUuid(a.contentTypeKey)),
+      )
+      const missing: string[] = []
+      for (const alias of folderDef.allowChildren) {
+        const def = BUILT_IN_MEDIA_TYPES.find((t) => t.alias === alias)
+        if (!def || allowed.has(def.key)) continue
+        if (await repo.byKey(def.key)) missing.push(def.key)
+      }
+      if (missing.length > 0)
+        await repo.save({
+          ...folder,
+          allowedContentTypes: [
+            ...folder.allowedContentTypes,
+            ...missing.map((contentTypeKey, i) => ({
+              contentTypeKey,
+              sortOrder: folder.allowedContentTypes.length + i,
+            })),
+          ],
+        })
+    }
+  }
+  return created
+}

package/src/schema/built-in-member-types.ts

@@ -0,0 +1,61 @@
+/**
+ * Umbraco's one built-in member type, verbatim from its installer
+ * (`DatabaseDataCreator`): alias "Member", icon `icon-user`, and no properties
+ * — since Umbraco 18 the standard property stubs are empty and everything a
+ * member always has (e-mail, username, approval, lockout) is a column on
+ * `member`, not a property.
+ *
+ * It is a **system** type, like the Folder, Image and File media types: shipped
+ * with the framework, ensured at every boot, exempt from schema retirement. A
+ * site that wants its own member types adds files under `schema/member-types/`;
+ * this one is what makes "create a member" work on a fresh install.
+ */
+import { type ContentTypeAggregate, SYSTEM_MEMBER_TYPE_KEY } from '@crombolo/core'
+import type { Db } from '../database.ts'
+import { ContentTypeRepository } from '../repositories/content-types.ts'
+
+export const SYSTEM_MEMBER_TYPE = {
+  key: SYSTEM_MEMBER_TYPE_KEY,
+  alias: 'Member',
+  name: 'Member',
+  icon: 'icon-user',
+} as const
+
+export function systemMemberTypeAggregate(): ContentTypeAggregate {
+  return {
+    key: SYSTEM_MEMBER_TYPE.key,
+    alias: SYSTEM_MEMBER_TYPE.alias,
+    name: SYSTEM_MEMBER_TYPE.name,
+    description: null,
+    icon: SYSTEM_MEMBER_TYPE.icon,
+    allowedAsRoot: true,
+    variesByCulture: false,
+    variesBySegment: false,
+    isElement: false,
+    allowedInLibrary: false,
+    collectionKey: null,
+    cleanup: {
+      preventCleanup: false,
+      keepAllVersionsNewerThanDays: null,
+      keepLatestVersionPerDayForDays: null,
+    },
+    containers: [],
+    properties: [],
+    compositions: [],
+    allowedContentTypes: [],
+    allowedComponentKeys: [],
+    defaultComponentKey: null,
+    parentKey: null,
+  }
+}
+
+/**
+ * Creates the "Member" member type if it is missing, by its fixed key; never
+ * changes one that exists. Idempotent, and run at every boot.
+ */
+export async function ensureSystemMemberTypes(db: Db): Promise<string[]> {
+  const repo = new ContentTypeRepository(db, { kind: 'member' })
+  if (await repo.byKey(SYSTEM_MEMBER_TYPE.key)) return []
+  await repo.save(systemMemberTypeAggregate())
+  return [SYSTEM_MEMBER_TYPE.alias]
+}

package/src/schema/bundle-components.ts

@@ -0,0 +1,49 @@
+/**
+ * Migration 028 — a bundle's `templates` and `partial_views` become `components`.
+ *
+ * There is one root and one kind of file on disk now (`docs/rendering.md`),
+ * so a bundle definition that still kept two lists was recording a distinction
+ * the rest of the system no longer makes. The two are merged rather than one
+ * dropped: both held component aliases, and which tree the backoffice picked
+ * one from is not worth keeping.
+ *
+ * A new migration rather than an edit to 022, for the reason 027 gives: 022 has
+ * already run on every database that exists.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_BUNDLES } from './bundles-rename.ts'
+
+export const STATE_BUNDLE_COMPONENTS = '{6f1d4a8e-0028-4a19-8c64-2f5b9d3e7a14}'
+
+/** A column holding no aliases, however it was written. */
+const EMPTY = (column: string) => `(${column} IS NULL OR ${column} IN ('', '[]'))`
+
+export const bundleComponentsMigration: Migration = {
+  from: STATE_BUNDLES,
+  to: STATE_BUNDLE_COMPONENTS,
+  name: 'MergeBundleTemplatesAndPartialViewsIntoComponents',
+  kind: 'expand',
+  release: '0.6.0',
+  async up(db: Db) {
+    const ops = schemaOps(db)
+    // Renamed rather than added, so the existing values carry over without a
+    // default and without a NOT NULL that an empty table could not satisfy.
+    await ops.renameColumn('bundle', 'templates', 'components')
+    // Both are JSON arrays of aliases, so the merge is `[a,b]` + `[c]` done as
+    // text: drop the closing bracket from one, the opening from the other.
+    // `||` is the concatenation operator in both dialects.
+    await db.exec(
+      `UPDATE bundle SET components = partial_views
+        WHERE ${EMPTY('components')} AND NOT ${EMPTY('partial_views')}`,
+    )
+    await db.exec(
+      `UPDATE bundle
+          SET components = SUBSTR(components, 1, LENGTH(components) - 1) || ',' ||
+                           SUBSTR(partial_views, 2)
+        WHERE NOT ${EMPTY('components')} AND NOT ${EMPTY('partial_views')}`,
+    )
+    await ops.dropColumn('bundle', 'partial_views')
+  },
+}

package/src/schema/bundle-package.ts

@@ -0,0 +1,27 @@
+/**
+ * Migration 029 — a created bundle records the npm package it is written as.
+ *
+ * Every bundle is an npm package (`docs/bundles.md`), so the Created view's
+ * download needs a package name and version. Umbraco's package definition has
+ * neither, so they live here, beside the columns the contract does name. Both
+ * are nullable: an unset name or version is derived when the bundle is built.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { schemaOps } from '../schema-ops.ts'
+import { STATE_BUNDLE_COMPONENTS } from './bundle-components.ts'
+
+export const STATE_BUNDLE_PACKAGE = '{6f1d4a8e-0029-4c5e-9a17-3d8b2e6f4c29}'
+
+export const bundlePackageMigration: Migration = {
+  from: STATE_BUNDLE_COMPONENTS,
+  to: STATE_BUNDLE_PACKAGE,
+  name: 'AddBundlePackageNameAndVersion',
+  kind: 'expand',
+  release: '0.10.0',
+  async up(db: Db) {
+    const ops = schemaOps(db)
+    await ops.addColumn('bundle', 'package_name', db.dialect.types.varchar(214))
+    await ops.addColumn('bundle', 'package_version', db.dialect.types.varchar(64))
+  },
+}

package/src/schema/bundles-rename.ts

@@ -0,0 +1,32 @@
+/**
+ * Migration 027 — `created_package` becomes `bundle`.
+ *
+ * The table was named after Umbraco's `umbracoCreatedPackageSchema`, which it
+ * mirrors column for column. What it holds is a bundle definition
+ * (`docs/bundles.md`), and the backoffice now says so, so the table does too.
+ *
+ * A rename rather than an edit to migration 022: 022 has already run on every
+ * database that exists, and rewriting it would leave those sites with a table
+ * the code no longer looks for and no migration to tell them so.
+ */
+import type { Db } from '../database.ts'
+import type { Migration } from '../migrations.ts'
+import { STATE_FORM_PERMISSION_PREFIX } from './form-permission-prefix.ts'
+
+export const STATE_BUNDLES = '{6f1d4a8e-0027-4e72-9a55-3d7c1b8e4f02}'
+
+export const bundlesRenameMigration: Migration = {
+  from: STATE_FORM_PERMISSION_PREFIX,
+  to: STATE_BUNDLES,
+  name: 'RenameCreatedPackageToBundle',
+  kind: 'expand',
+  release: '0.5.0',
+  async up(db: Db) {
+    await db.exec('ALTER TABLE created_package RENAME TO bundle')
+    // Neither dialect carries an index name through a table rename, so the
+    // unique name constraint is dropped and rebuilt rather than left reading
+    // `ux_created_package_name` on a table that no longer exists.
+    await db.exec('DROP INDEX ux_created_package_name')
+    await db.exec('CREATE UNIQUE INDEX ux_bundle_name ON bundle (name)')
+  },
+}