@crombolo/data 0.9.1 → 0.11.0

package/src/repositories/content-types.ts

@@ -27,10 +27,26 @@ import type { Db } from '../database.ts'
 import { DbDate, fromDbBool } from '../dialect.ts'
 import { pendingUntil } from '../pending.ts'
 import type { NodeSchemaState } from '../schema-state.ts'
+import { queueContentTypesForSearch, queueEverythingForSearch } from '../search.ts'
 import { NodeRepository } from './nodes.ts'
 
 const GROUP_TYPE_NAMES = ['Group', 'Tab'] as const
 
+/** The live properties of a type, by alias, variation and storage: what its items are indexed by. */
+async function propertySignature(db: Db, contentTypeNodeId: number): Promise<string> {
+  const rows = await db.query<Record<string, unknown>>(
+    `SELECT p.id, p.alias, p.variations, p.data_type_id, p.searchable FROM property_type p
+     WHERE p.content_type_id = ? AND p.retired_at IS NULL ORDER BY p.id`,
+    [contentTypeNodeId],
+  )
+  return rows
+    .map(
+      (row) =>
+        `${row.id}:${row.alias}:${row.variations}:${row.data_type_id}:${fromDbBool(row.searchable)}`,
+    )
+    .join('|')
+}
+
 export interface SaveContentTypeOptions {
   userId?: number
   /** The schema state that introduced anything created by this save. */
@@ -228,6 +244,9 @@ export class ContentTypeRepository {
         ? ((await repo.nodes.byKey(aggregate.parentKey))?.id ?? SystemNodes.Root)
         : SystemNodes.Root
 
+      // What the search index holds depends on which properties are live and what
+      // they are called, so a change to either has the type's items re-indexed.
+      const propertiesBefore = existing ? await propertySignature(tx, existing.id) : ''
       let nodeId: number
       if (existing) {
         nodeId = existing.id
@@ -361,13 +380,25 @@ export class ContentTypeRepository {
              WHERE id = ?`,
             [...columns, Number(found[0].id)],
           )
+          // Only a schema sync says; a backoffice save leaves it as it was.
+          if (property.searchable !== undefined)
+            await tx.exec('UPDATE property_type SET searchable = ? WHERE id = ?', [
+              bool(property.searchable),
+              Number(found[0].id),
+            ])
         } else {
           await tx.exec(
             `INSERT INTO property_type
                (unique_id, content_type_id, data_type_id, property_type_group_id, alias, name, description, sort_order,
-                mandatory, mandatory_message, validation_reg_exp, validation_reg_exp_message, label_on_top, variations, since_version, since_state_id)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-            [key, nodeId, ...columns, options.sinceStateId ?? null],
+                mandatory, mandatory_message, validation_reg_exp, validation_reg_exp_message, label_on_top, variations, since_version, since_state_id, searchable)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [
+              key,
+              nodeId,
+              ...columns,
+              options.sinceStateId ?? null,
+              bool(property.searchable !== false),
+            ],
           )
         }
       }
@@ -451,6 +482,11 @@ export class ContentTypeRepository {
           )
       }
 
+      if (existing && propertiesBefore !== (await propertySignature(tx, nodeId))) {
+        if (aggregate.isElement) await queueEverythingForSearch(tx)
+        else await queueContentTypesForSearch(tx, [nodeId])
+      }
+
       const saved = await repo.byKey(aggregate.key)
       if (!saved) throw new Error('Content type could not be read back after saving.')
       return saved
@@ -739,7 +775,7 @@ export class ContentTypeRepository {
               p.validation_reg_exp, p.validation_reg_exp_message, p.label_on_top, p.variations,
               dtn.unique_id AS data_type_key, g.unique_id AS container_key,
               p.since_version, ss.version AS since_v, ss.revision AS since_r,
-              m.member_can_edit, m.member_can_view, m.is_sensitive
+              m.member_can_edit, m.member_can_view, m.is_sensitive, p.searchable
        FROM property_type p
        JOIN node dtn ON dtn.id = p.data_type_id
        LEFT JOIN property_type_group g ON g.id = p.property_type_group_id
@@ -766,6 +802,7 @@ export class ContentTypeRepository {
       labelOnTop: fromDbBool(row.label_on_top),
       sinceVersion: (row.since_version as string | null) ?? null,
       pending: this.#pending(row),
+      ...(fromDbBool(row.searchable) ? {} : { searchable: false }),
       ...(this.#kind === 'member'
         ? {
             memberCanEdit: fromDbBool(row.member_can_edit),

package/src/repositories/documents.ts

@@ -5,7 +5,7 @@
  * tagged with the event that wrote it and the schema state the writer was at.
  * `content_version` rows are events (save | publish | rollback | migrate).
  * Publish is an event and a pointer, not a copy; rollback appends the old
- * values under a new event. See docs/02-data-model.md.
+ * values under a new event. See docs/data-model.md.
  */
 import {
   type DocumentAggregate,
@@ -36,6 +36,7 @@ import {
   type SchemaStateRow,
   visibleStateIdFor,
 } from '../schema-state.ts'
+import { queueForSearch } from '../search.ts'
 import { NodeRepository, type NodeRow } from './nodes.ts'
 
 export type EventKind = 'save' | 'publish' | 'rollback' | 'migrate'
@@ -334,7 +335,11 @@ export class DocumentRepository {
       ? (await this.#nodes.byKey(options.parentKey))?.id
       : undefined
     if (options.parentKey && parentId === undefined) return { total: 0, items: [] }
-    return this.#nodes.search(this.objectType, query, { ...options, parentId })
+    return this.#nodes.search(this.objectType, query, {
+      ...options,
+      parentId,
+      fullText: this.kind === 'document' || this.kind === 'media',
+    })
   }
 
   async versions(key: string): Promise<DocumentVersionSummary[]> {
@@ -594,7 +599,10 @@ export class DocumentRepository {
         )
         written = true
       }
-      if (written) await repo.#recomputeEdited(node.id)
+      if (written) {
+        await repo.#recomputeEdited(node.id)
+        await queueForSearch(tx, [node.id])
+      }
       return written
     })
   }
@@ -2053,6 +2061,8 @@ export class DocumentRepository {
       'INSERT INTO document_version (id, template_id, published) VALUES (?, ?, ?)',
       [eventId, templateId, this.#db.dialect.boolValue(published)],
     )
+    // Every change to what an item says is an event, so this is where the search index hears of it.
+    await queueForSearch(this.#db, [nodeId])
     return eventId
   }
 

package/src/repositories/form-entries.ts

@@ -1,5 +1,5 @@
 /**
- * Form entries: what visitors submitted. `docs/18-forms.md`.
+ * Form entries: what visitors submitted. `docs/forms.md`.
  *
  * Keyed by the form's UUID rather than a foreign key, because the definition is
  * a file. An entry outlives its definition on purpose.

package/src/repositories/form-workflows.ts

@@ -1,5 +1,5 @@
 /**
- * The form workflow queue. `docs/18-forms.md`.
+ * The form workflow queue. `docs/forms.md`.
  *
  * Claimed with `UPDATE … WHERE state = 'pending' … RETURNING`, which is atomic
  * on both dialects: on a multi-node Postgres site every node polls, and exactly

package/src/repositories/members.ts

@@ -14,6 +14,8 @@
 import { normaliseUuid, ObjectTypes } from '@crombolo/core'
 import type { Db } from '../database.ts'
 import { DbDate, fromDbBool } from '../dialect.ts'
+import { queueForSearch } from '../search.ts'
+import { searchTerms } from '../search-text.ts'
 import {
   DocumentRepository,
   type DocumentRepositoryOptions,
@@ -242,6 +244,8 @@ export class MemberRepository {
       ],
     )
     await this.#writeGroups(node.id, identity.groupKeys ?? [])
+    // Again, now the e-mail and username it is found by are written.
+    await queueForSearch(this.#db, [node.id])
     const member = await this.byKey(created.key)
     if (!member) throw new Error(`the member ${created.key} could not be read back`)
     return member
@@ -290,6 +294,7 @@ export class MemberRepository {
       ...values,
       node.id,
     ])
+    await queueForSearch(this.#db, [node.id])
     if (identity.groupKeys) await this.#writeGroups(node.id, identity.groupKeys)
     return this.byKey(key)
   }
@@ -365,9 +370,18 @@ export class MemberRepository {
     }
     const text = criteria.filter?.trim()
     if (text) {
-      wheres.push('(LOWER(m.email) LIKE ? OR LOWER(m.login_name) LIKE ? OR LOWER(n.text) LIKE ?)')
       const like = `%${text.toLowerCase()}%`
+      const terms = searchTerms(text)
+      // The index adds what a member's properties say to the name, username and e-mail.
+      const indexed =
+        terms.length > 0
+          ? ` OR m.node_id IN (SELECT node_id FROM (${this.#db.dialect.fullTextHits}) h)`
+          : ''
+      wheres.push(
+        `(LOWER(m.email) LIKE ? OR LOWER(m.login_name) LIKE ? OR LOWER(n.text) LIKE ?${indexed})`,
+      )
       values.push(like, like, like)
+      if (indexed) values.push(this.#db.dialect.fullTextQuery(terms))
     }
     const where = wheres.length > 0 ? `WHERE ${wheres.join(' AND ')}` : ''
     const order = ORDER_COLUMNS[(criteria.orderBy ?? '').toLowerCase()] ?? ORDER_COLUMNS.username

package/src/repositories/nodes.ts

@@ -7,6 +7,7 @@
 import { normaliseUuid, ObjectTypes, type Page, SystemNodes } from '@crombolo/core'
 import type { Db } from '../database.ts'
 import { DbDate, fromDbBool } from '../dialect.ts'
+import { searchTerms } from '../search-text.ts'
 
 export interface NodeRow {
   id: number
@@ -231,30 +232,54 @@ export class NodeRepository {
     return { items: rows.slice(start, end), totalBefore: start, totalAfter: rows.length - end }
   }
 
-  /** Name search, case-insensitive, optionally under a parent. */
+  /**
+   * Name search, case-insensitive, optionally under a parent. With `fullText`,
+   * an item also matches when the search index holds every word of the query by
+   * prefix; items whose name matches come first, then the best index matches.
+   */
   async search(
     objectType: string,
     query: string,
-    options: { trashed?: boolean; parentId?: number; skip: number; take: number },
+    options: {
+      trashed?: boolean
+      parentId?: number
+      fullText?: boolean
+      skip: number
+      take: number
+    },
   ): Promise<Page<NodeRow>> {
-    const conditions = ['node_object_type = ?', 'trashed = ?', 'LOWER(text) LIKE ?']
+    const like = `%${query.toLowerCase().replaceAll('%', '').replaceAll('_', '')}%`
+    const terms = options.fullText ? searchTerms(query) : []
+    const indexed = terms.length > 0
+    const conditions = [
+      'node_object_type = ?',
+      'trashed = ?',
+      indexed ? '(LOWER(text) LIKE ? OR h.node_id IS NOT NULL)' : 'LOWER(text) LIKE ?',
+    ]
     const params: unknown[] = [
+      ...(indexed ? [this.#db.dialect.fullTextQuery(terms)] : []),
       objectType,
       this.#db.dialect.boolValue(options.trashed ?? false),
-      `%${query.toLowerCase().replaceAll('%', '').replaceAll('_', '')}%`,
+      like,
     ]
     if (options.parentId !== undefined) {
       conditions.push('parent_id = ?')
       params.push(options.parentId)
     }
+    const from = indexed
+      ? `node LEFT JOIN (${this.#db.dialect.fullTextHits}) h ON h.node_id = node.id`
+      : 'node'
     const where = conditions.join(' AND ')
     const totals = await this.#db.query<{ n: number }>(
-      `SELECT COUNT(*) AS n FROM node WHERE ${where}`,
+      `SELECT COUNT(*) AS n FROM ${from} WHERE ${where}`,
       params,
     )
+    const order = indexed
+      ? 'CASE WHEN LOWER(text) LIKE ? THEN 0 ELSE 1 END, COALESCE(h.score, 0) DESC, text, id'
+      : 'text, id'
     const rows = await this.#db.query(
-      `SELECT ${NODE_COLUMNS} FROM node WHERE ${where} ORDER BY text, id LIMIT ? OFFSET ?`,
-      [...params, options.take, options.skip],
+      `SELECT ${NODE_COLUMNS} FROM ${from} WHERE ${where} ORDER BY ${order} LIMIT ? OFFSET ?`,
+      [...params, ...(indexed ? [like] : []), options.take, options.skip],
     )
     return { total: Number(totals[0]?.n ?? 0), items: rows.map(mapNode) }
   }

package/src/repositories/transfer-runs.ts

@@ -24,6 +24,9 @@ export interface TransferRun {
   id: string
   bundleId: string
   bundleLabel: string | null
+  /** The npm package the content arrived in, and its version. */
+  packageName: string | null
+  packageVersion: string | null
   direction: TransferDirection
   revertsRunId: string | null
   schemaStateId: number
@@ -57,12 +60,14 @@ export class TransferRunRepository {
   async start(run: Omit<TransferRun, 'finishedAt' | 'status'>): Promise<void> {
     await this.#db.exec(
       `INSERT INTO content_transfer_run
-         (id, bundle_id, bundle_label, direction, reverts_run_id, schema_state_id, started_at, applied_by, node_count, status)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'applied')`,
+         (id, bundle_id, bundle_label, package_name, package_version, direction, reverts_run_id, schema_state_id, started_at, applied_by, node_count, status)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'applied')`,
       [
         run.id,
         run.bundleId,
         run.bundleLabel,
+        run.packageName,
+        run.packageVersion,
         run.direction,
         run.revertsRunId,
         run.schemaStateId,
@@ -121,6 +126,17 @@ export class TransferRunRepository {
     return rows[0] ? mapRun(rows[0]) : undefined
   }
 
+  /** The latest standing import of a package's content, whichever version brought it. */
+  async appliedForPackage(packageName: string): Promise<TransferRun | undefined> {
+    const rows = await this.#db.query(
+      `SELECT * FROM content_transfer_run
+         WHERE package_name = ? AND direction = 'import' AND status = 'applied'
+         ORDER BY started_at DESC, id DESC LIMIT 1`,
+      [packageName],
+    )
+    return rows[0] ? mapRun(rows[0]) : undefined
+  }
+
   /** Runs, newest first. */
   async recent(limit = 20): Promise<TransferRun[]> {
     const rows = await this.#db.query(
@@ -164,6 +180,8 @@ function mapRun(row: Record<string, unknown>): TransferRun {
     id: String(row.id),
     bundleId: String(row.bundle_id),
     bundleLabel: (row.bundle_label as string | null) ?? null,
+    packageName: (row.package_name as string | null) ?? null,
+    packageVersion: (row.package_version as string | null) ?? null,
     direction: String(row.direction) as TransferDirection,
     revertsRunId: (row.reverts_run_id as string | null) ?? null,
     schemaStateId: Number(row.schema_state_id),

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/bundle-components.ts

@@ -1,7 +1,7 @@
 /**
  * Migration 028 — a bundle's `templates` and `partial_views` become `components`.
  *
- * There is one root and one kind of file on disk now (`docs/05-rendering.md`),
+ * 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

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

@@ -3,7 +3,7 @@
  *
  * The table was named after Umbraco's `umbracoCreatedPackageSchema`, which it
  * mirrors column for column. What it holds is a bundle definition
- * (`docs/17-bundles.md`), and the backoffice now says so, so the table does too.
+ * (`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

package/src/schema/content.ts

@@ -2,7 +2,7 @@
  * Migration 002 — the content schema.
  *
  * `node` is the universal polymorphic tree; every other table here is a facet of
- * it. See docs/02-data-model.md for the model and why it is kept.
+ * it. See docs/data-model.md for the model and why it is kept.
  */
 import type { Db } from '../database.ts'
 import type { Migration } from '../migrations.ts'
@@ -164,7 +164,7 @@ export const contentMigration: Migration = {
        )`,
     )
 
-    // ---- documents and versions (Phase 4 uses these) ----
+    // ---- documents and versions (story 005 uses these) ----
 
     await db.exec(
       `CREATE TABLE content (

package/src/schema/created-packages.ts

@@ -2,7 +2,7 @@
  * Migration 022 — the created-package definitions the Packages section builds.
  *
  * A definition, never an artifact: the zip is built when it is downloaded
- * (`docs/17-bundles.md`), so there are no bytes here to go stale when a
+ * (`docs/bundles.md`), so there are no bytes here to go stale when a
  * content type the package carries is edited afterwards.
  *
  * The selection lists are JSON text rather than a row each. They are read and

package/src/schema/form-permissions.ts

@@ -1,6 +1,6 @@
 /**
  * Migration 025 — the form permission verbs, for databases seeded before they
- * existed. `docs/18-forms.md`.
+ * existed. `docs/forms.md`.
  *
  * The same shape as migration 007: granting what the seed now grants, so an
  * upgraded site does not have a Forms section nobody can open. Idempotent, and

package/src/schema/form-workflows.ts

@@ -1,5 +1,5 @@
 /**
- * Migration 024 — the queue a form's workflows run from. `docs/18-forms.md`.
+ * Migration 024 — the queue a form's workflows run from. `docs/forms.md`.
  *
  * A submission is stored and *then* its workflows run, so a mail server being
  * down never loses an entry. That means a row per workflow per submission,

package/src/schema/forms.ts

@@ -1,5 +1,5 @@
 /**
- * Migration 023 — form entries. `docs/18-forms.md`.
+ * Migration 023 — form entries. `docs/forms.md`.
  *
  * The definition is a file, so there is no form table and nothing to point at:
  * an entry carries `form_key`, the UUID from `schema/forms/*.toml`, and keeps

package/src/schema/identity.ts

@@ -1,7 +1,7 @@
 /**
  * Migration 001 — back-office identity.
  *
- * Table and column names follow docs/02-data-model.md: Umbraco's relational
+ * 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`.
  */

package/src/schema/plan.ts

@@ -13,7 +13,9 @@
  */
 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'
 import { changeReportMigration } from './change-report.ts'
 import { clientIdPrefixMigration } from './client-id-prefix.ts'
@@ -30,12 +32,15 @@ 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 { transferRunPackageMigration } from './transfer-run-package.ts'
 import { transferRunsMigration } from './transfer-runs.ts'
 import { upgradeReportMigration } from './upgrade-report.ts'
 import { usersLocalisationMigration } from './users-localisation.ts'
@@ -70,4 +75,9 @@ export const cromboloPlan = new MigrationPlan([
   formPermissionPrefixMigration,
   bundlesRenameMigration,
   bundleComponentsMigration,
+  bundlePackageMigration,
+  transferRunPackageMigration,
+  searchIndexMigration,
+  propertySearchableMigration,
+  auditLogMigration,
 ])

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],
+    )
+  },
+}