uql-orm 0.79.0 → 0.80.0

package/dist/migrate/migrator.d.ts

@@ -63,6 +63,33 @@ export declare class Migrator {
      * Generate a migration based on entity schema differences
      */
     generateFromEntities(name: string): Promise<string>;
+    /**
+     * Each entity on a table this plan does not create - a new one carries its triggers in its `CREATE` -
+     * beside the triggers uql has installed there, read once per schema. Kept only where either side has
+     * any: one declaring none on a table holding none has nothing to reconcile.
+     */
+    private installedTriggers;
+    /**
+     * The alters, with the triggers reconciled around them. Postgres refuses to retype or drop a column a
+     * trigger names, so every trigger on a table whose columns change comes off before the alters and what
+     * its entity declares goes back on after. `down` is lazy: SQLite cannot express every alter's inverse.
+     */
+    private alterPlan;
+    /**
+     * Each entity's triggers taken from what the catalogue holds to what it declares. Against the catalogue
+     * rather than a diff, because a trigger hangs off a table whose columns may be unchanged: a body edited
+     * on a settled table appears in no diff at all.
+     */
+    private reconcileTriggers;
+    /**
+     * The inverse: what the reconcile created dropped, and what it dropped restored as the engine reprints
+     * it. Read off the catalogue rather than recorded by uql, and exactly right for restoring one.
+     */
+    private revertedTriggers;
+    /** The entities whose tables are among `created`. */
+    private createdEntities;
+    /** The table `entity` maps to, as a diff names it. */
+    private tableOf;
     /**
      * Get all schema differences between entities and database
      */
@@ -82,7 +109,7 @@ export declare class Migrator {
      * settle instead of colliding; an existing one still pays for introspection, as a diff needs columns.
      */
     private planEntity;
-    /** The same for one entity against the table it already has, and nothing where the two agree. */
+    /** The diff for one entity against the table it already has, and none where the two agree. */
     private alterFromEntity;
     /** The configured entities, with `entity` among them however the migrator was built. */
     private entitiesWith;

package/dist/migrate/migrator.js

@@ -3,6 +3,7 @@ import { basename, extname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { getEntities, getMeta } from '../entity/index.js';
 import { SchemaAST } from '../schema/index.js';
+import { hasTriggers } from '../util/field.util.js';
 import { LoggerWrapper } from '../util/index.js';
 import { buildMigrationModule } from './codegen/migrationFile.js';
 import { introspectorFor } from './introspection/registry.js';
@@ -181,17 +182,17 @@ export class Migrator {
     async generateFromEntities(name) {
         const generator = await this.getSchemaGenerator();
         const { created, altered } = await this.pendingChanges();
-        const up = [
-            ...this.createSchema(generator, created),
-            ...altered.flatMap((diff) => generator.generateAlterTable(diff)),
-        ];
+        const plan = this.alterPlan(generator, altered, await this.installedTriggers(created));
+        const up = [...this.createSchema(generator, created), ...plan.up];
         if (up.length === 0) {
             this.logger.logInfo('No schema changes detected.');
             return '';
         }
         // Diff by diff in reverse, each rolled back in the order its generator wrote it.
         const down = [
-            ...altered.toReversed().flatMap((diff) => generator.generateAlterTableDown(diff)),
+            ...plan.down(),
+            // A table's drop takes its triggers along, but not the function the Postgres family keeps each body in.
+            ...this.createdEntities(created).flatMap((entity) => generator.generateTriggersDown(entity)),
             ...created.toReversed().map((tableName) => generator.generateDropTable(tableName, { ifExists: true })),
         ];
         const { emit } = this.target.source;
@@ -203,6 +204,81 @@ export class Migrator {
         this.logger.logInfo(`Created migration from entities: ${filePath}`);
         return filePath;
     }
+    /**
+     * Each entity on a table this plan does not create - a new one carries its triggers in its `CREATE` -
+     * beside the triggers uql has installed there, read once per schema. Kept only where either side has
+     * any: one declaring none on a table holding none has nothing to reconcile.
+     */
+    async installedTriggers(created, entities = this.entities) {
+        const { dialect } = this.pool;
+        const fresh = new Set(created);
+        // Tables this plan creates are left out: their `CREATE` carries their triggers, and asking the
+        // catalogue about a table that is not there yet fails outright on some engines.
+        const wanted = entities.filter((entity) => !fresh.has(this.tableOf(entity)));
+        const bySchema = new Map();
+        const state = [];
+        for (const entity of wanted) {
+            const meta = getMeta(entity);
+            const schema = dialect.resolveSchema(meta);
+            let owned = bySchema.get(schema);
+            if (!owned) {
+                owned = await this.schemaIntrospectorFor(schema).ownedTriggers();
+                bySchema.set(schema, owned);
+            }
+            const installed = owned.get(dialect.resolveTableAlias(meta)) ?? new Map();
+            // An installed trigger alone keeps it: an entity that stopped declaring one has it to drop.
+            if (installed.size || hasTriggers(meta)) {
+                state.push({ entity, installed });
+            }
+        }
+        return state;
+    }
+    /**
+     * The alters, with the triggers reconciled around them. Postgres refuses to retype or drop a column a
+     * trigger names, so every trigger on a table whose columns change comes off before the alters and what
+     * its entity declares goes back on after. `down` is lazy: SQLite cannot express every alter's inverse.
+     */
+    alterPlan(generator, altered, state) {
+        const changing = new Set(altered.filter((diff) => diff.columnsToAlter?.length || diff.columnsToDrop?.length).map((diff) => diff.tableName));
+        const cleared = state.filter(({ entity }) => changing.has(this.tableOf(entity)));
+        const after = state.map((it) => (cleared.includes(it) ? { entity: it.entity, installed: new Map() } : it));
+        return {
+            up: [
+                ...cleared.flatMap(({ entity, installed }) => generator.generateTriggerDrops(entity, [...installed.keys()])),
+                ...altered.flatMap((diff) => generator.generateAlterTable(diff)),
+                ...this.reconcileTriggers(generator, after),
+            ],
+            down: () => [
+                ...this.revertedTriggers(generator, after),
+                ...altered.toReversed().flatMap((diff) => generator.generateAlterTableDown(diff)),
+                ...cleared.flatMap(({ installed }) => [...installed.values()].flat().map((sql) => `${sql};`)),
+            ],
+        };
+    }
+    /**
+     * Each entity's triggers taken from what the catalogue holds to what it declares. Against the catalogue
+     * rather than a diff, because a trigger hangs off a table whose columns may be unchanged: a body edited
+     * on a settled table appears in no diff at all.
+     */
+    reconcileTriggers(generator, state) {
+        return state.flatMap(({ entity, installed }) => generator.generateTriggers(entity, installed));
+    }
+    /**
+     * The inverse: what the reconcile created dropped, and what it dropped restored as the engine reprints
+     * it. Read off the catalogue rather than recorded by uql, and exactly right for restoring one.
+     */
+    revertedTriggers(generator, state) {
+        return state.flatMap(({ entity, installed }) => generator.generateTriggersDown(entity, installed));
+    }
+    /** The entities whose tables are among `created`. */
+    createdEntities(created) {
+        const fresh = new Set(created);
+        return this.entities.filter((entity) => fresh.has(this.tableOf(entity)));
+    }
+    /** The table `entity` maps to, as a diff names it. */
+    tableOf(entity) {
+        return this.pool.dialect.resolveTableName(getMeta(entity));
+    }
     /**
      * Get all schema differences between entities and database
      */
@@ -269,14 +345,16 @@ export class Migrator {
         }
         // With the tables it references, which its foreign keys resolve against.
         const ast = await this.introspectEntities([entity, ...referencedEntities(meta)]);
-        return this.alterFromEntity(generator, entity, ast.getTable(tableName), options);
+        // The table is already there, so its triggers are reconciled rather than carried by a `CREATE`.
+        const altered = this.alterFromEntity(generator, entity, ast.getTable(tableName), options);
+        return this.alterPlan(generator, altered, await this.installedTriggers([], [entity])).up;
     }
-    /** The same for one entity against the table it already has, and nothing where the two agree. */
+    /** The diff for one entity against the table it already has, and none where the two agree. */
     alterFromEntity(generator, entity, table, options) {
         // Spanning the set for the reason `planEntity` spells out: a foreign key needs the table it
         // points at, which a sync of one entity outside the configured list would not otherwise have.
         const diff = generator.diffSchema(entity, table, generator.buildAST?.(this.entitiesWith(entity)));
-        return diff?.type === 'alter' ? generator.generateAlterTable(this.filterDiff(diff, options)) : [];
+        return diff?.type === 'alter' ? [this.filterDiff(diff, options)] : [];
     }
     /** The configured entities, with `entity` among them however the migrator was built. */
     entitiesWith(entity) {
@@ -300,9 +378,10 @@ export class Migrator {
             return this.planEntity(generator, options.entity, options);
         }
         const { created, altered } = await this.pendingChanges();
+        const filtered = altered.map((diff) => this.filterDiff(diff, options));
         return [
             ...this.createSchema(generator, created),
-            ...altered.flatMap((diff) => generator.generateAlterTable(this.filterDiff(diff, options))),
+            ...this.alterPlan(generator, filtered, await this.installedTriggers(created)).up,
         ];
     }
     /** The new tables, created together so a foreign key between them, cyclic included, resolves. Empty in, empty out. */

package/dist/migrate/schemaGenerator.d.ts

@@ -3,7 +3,7 @@ import type { SchemaAST } from '../schema/schemaAST.js';
 import { type BuildSchemaASTOptions } from '../schema/schemaASTBuilder.js';
 import { type DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
-import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, EntityWhereMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../type/index.js';
+import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, InstalledTriggers, EntityWhereMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../type/index.js';
 import type { AnyMigrationOperation, FullColumnDefinition, IndexDefinition, TableDefinition } from './builder/types.js';
 import { type IndexDdl, type TableDdl } from './ddl/index.js';
 /**
@@ -43,6 +43,17 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      * cyclic. SQLite keeps them inline: it cannot add one later, and resolves a forward reference lazily.
      */
     generateCreateSchema(entities: readonly Type<object>[], options?: CreateSchemaOptions): string[];
+    /**
+     * The installed triggers on `entity`'s table it does not declare, and the declared ones not installed,
+     * compared by name alone: a name carries a hash of the trigger's SQL, so an edited one is a new name.
+     * Every trigger counts - the ones it authored, and one per event each stamp names.
+     */
+    private triggerChanges;
+    generateTriggers(entity: Type<object>, installed?: InstalledTriggers): string[];
+    generateTriggersDown(entity: Type<object>, installed?: InstalledTriggers): string[];
+    /** `dropped` taken off `entity`'s table and `created` put on, which is a reconcile read either way. */
+    private swapTriggers;
+    generateTriggerDrops(entity: Type<object>, names: readonly string[]): string[];
     /**
      * One statement per distinct schema the tables being created live in, in first-seen order. Only
      * the tables actually being created, so a narrowed `only` does not declare namespaces it is not

package/dist/migrate/schemaGenerator.js

@@ -1,10 +1,10 @@
 import { getMeta } from '../entity/index.js';
-import { canonicalToSql, engineType, isVectorCategory } from '../schema/canonicalType.js';
+import { canonicalToSql, engineType, isVectorCategory, resolveColumnCanonicalType } from '../schema/canonicalType.js';
 import { indexChanges } from '../schema/indexDifferences.js';
-import { buildSchemaAST, resolveColumnCanonicalType } from '../schema/schemaASTBuilder.js';
+import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
 import { isAutoIncrement, qualifyName } from '../util/index.js';
-import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName } from '../util/sql.util.js';
+import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName, isOwnedName } from '../util/sql.util.js';
 import { formatDefaultValue, SqlExpression } from './builder/expressions.js';
 import { splitSqlStatements } from './builder/splitSqlStatements.js';
 import { indexDdlFor, tableDdlFor } from './ddl/index.js';
@@ -12,6 +12,7 @@ import { sizedType } from './ddl/tableDdl.js';
 import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, renderIndexDefinition, tableDefinitionToNode, } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 import { assertIndexPredicate } from './indexPredicate.js';
+import { dropTrigger, renderTrigger, stampTriggers } from './triggerSql.js';
 /**
  * Unified SQL schema generator.
  * Parameterized by dialect to handle Postgres, MySQL, MariaDB, and SQLite.
@@ -98,8 +99,49 @@ export class SqlSchemaGenerator {
                 statements.push(...this.addForeignKeyStatements(qualifyName(table.name, table.schema), table.outgoingRelations.map(foreignKeyOf)));
             }
         }
+        // Triggers last: each needs its own table, and a body may read any other the same schema just made.
+        const made = new Set(tables.map((table) => qualifyName(table.name, table.schema)));
+        statements.push(...entities
+            .filter((entity) => made.has(this.resolveTableName(getMeta(entity))))
+            .flatMap((entity) => this.generateTriggers(entity)));
         return statements;
     }
+    /**
+     * The installed triggers on `entity`'s table it does not declare, and the declared ones not installed,
+     * compared by name alone: a name carries a hash of the trigger's SQL, so an edited one is a new name.
+     * Every trigger counts - the ones it authored, and one per event each stamp names.
+     */
+    triggerChanges(entity, installed) {
+        const meta = getMeta(entity);
+        const triggers = [...(meta.triggers ?? []), ...stampTriggers(this.dialect, meta)];
+        const rendered = triggers.map((trigger, i) => renderTrigger(this.dialect, meta, trigger, i));
+        const declared = new Set(rendered.map((trigger) => trigger.name));
+        return {
+            stale: [...installed]
+                .filter(([name]) => isOwnedName(name) && !declared.has(name))
+                .map(([name, statements]) => ({ name, statements })),
+            missing: rendered.filter((trigger) => !installed.has(trigger.name)),
+        };
+    }
+    generateTriggers(entity, installed = new Map()) {
+        const { stale, missing } = this.triggerChanges(entity, installed);
+        return this.swapTriggers(entity, stale, missing);
+    }
+    generateTriggersDown(entity, installed = new Map()) {
+        const { stale, missing } = this.triggerChanges(entity, installed);
+        return this.swapTriggers(entity, missing, stale);
+    }
+    /** `dropped` taken off `entity`'s table and `created` put on, which is a reconcile read either way. */
+    swapTriggers(entity, dropped, created) {
+        return [
+            ...this.generateTriggerDrops(entity, dropped.map((trigger) => trigger.name)),
+            ...created.flatMap((trigger) => trigger.statements.map((sql) => `${sql};`)),
+        ];
+    }
+    generateTriggerDrops(entity, names) {
+        const meta = getMeta(entity);
+        return names.filter(isOwnedName).flatMap((name) => dropTrigger(this.dialect, meta, name).map((sql) => `${sql};`));
+    }
     /**
      * One statement per distinct schema the tables being created live in, in first-seen order. Only
      * the tables actually being created, so a narrowed `only` does not declare namespaces it is not
@@ -457,8 +499,8 @@ export class SqlSchemaGenerator {
             const refTable = this.dialect.escapeQualifiedId(rel.to.table.name, rel.to.table.schema);
             constraints.push(this.foreignKeyConstraint(table.name, foreignKeyOf(rel), refTable));
         }
-        const ifNotExists = options.ifNotExists && this.features.ifNotExists ? 'IF NOT EXISTS ' : '';
-        let createSql = `CREATE TABLE ${ifNotExists}${this.dialect.escapeQualifiedId(table.name, table.schema)} (\n`;
+        const target = this.dialect.escapeQualifiedId(table.name, table.schema);
+        let createSql = `${this.tableDdl.createTable(target, !!options.ifNotExists)} (\n`;
         createSql += columns.map((col) => `  ${col}`).join(',\n');
         if (constraints.length > 0) {
             createSql += ',\n';

package/dist/migrate/storage/databaseStorage.d.ts

@@ -13,6 +13,10 @@ export declare class DatabaseMigrationStorage implements MigrationStorage {
         tableName?: string;
     });
     ensureStorage(): Promise<void>;
+    /**
+     * Rendered by the schema generator rather than written out, so each engine gets its own spelling: SQL
+     * Server has no `CREATE TABLE IF NOT EXISTS`, and its `TIMESTAMP` is a row version that takes no default.
+     */
     private createTableIfNotExists;
     executed(): Promise<string[]>;
     /**

package/dist/migrate/storage/databaseStorage.js

@@ -1,4 +1,7 @@
 import { withSqlQuerierForMigrations } from '../acquireQuerierForMigrations.js';
+import { expr } from '../builder/expressions.js';
+import { TableBuilder } from '../builder/tableBuilder.js';
+import { SqlSchemaGenerator } from '../schemaGenerator.js';
 /** Where executed migrations are recorded when the config does not name a table. */
 export const DEFAULT_MIGRATIONS_TABLE = 'uql_migrations';
 /**
@@ -22,15 +25,18 @@ export class DatabaseMigrationStorage {
             this.storageInitialized = true;
         });
     }
+    /**
+     * Rendered by the schema generator rather than written out, so each engine gets its own spelling: SQL
+     * Server has no `CREATE TABLE IF NOT EXISTS`, and its `TIMESTAMP` is a row version that takes no default.
+     */
     async createTableIfNotExists(querier) {
-        const { dialect } = querier;
-        const sql = /*sql*/ `
-      CREATE TABLE IF NOT EXISTS ${dialect.escapeId(this.tableName)} (
-        ${dialect.escapeId('name')} VARCHAR(255) PRIMARY KEY,
-        ${dialect.escapeId('executed_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-        await querier.run(sql);
+        const table = new TableBuilder(this.tableName);
+        table.string('name', { length: 255, primaryKey: true });
+        table.timestamp('executed_at', { defaultValue: expr.now() });
+        const generator = new SqlSchemaGenerator(querier.dialect);
+        for (const sql of generator.generateCreateTableFromDefinition(table.build(), { ifNotExists: true })) {
+            await querier.run(sql);
+        }
     }
     async executed() {
         await this.ensureStorage();

package/dist/migrate/triggerSql.d.ts

@@ -0,0 +1,24 @@
+import type { AbstractSqlDialect } from '../dialect/index.js';
+import type { EntityMeta, EntityTriggerMeta } from '../type/index.js';
+/** A trigger as uql installs it: the identifier, and the statements creating it under that identifier. */
+export type RenderedTrigger = {
+    readonly name: string;
+    readonly statements: readonly string[];
+};
+/**
+ * One trigger for `dialect`, named for its table and label and ending in a hash of its own SQL. That hash
+ * is the whole of change detection: a trigger is in place exactly when its name is installed, and an
+ * edited one is a new name, created while the old one drops as no longer declared.
+ */
+export declare function renderTrigger<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>, trigger: EntityTriggerMeta<E>, position: number): RenderedTrigger;
+/**
+ * What removes one trigger: the trigger, named with its table only where the engine scopes the name to
+ * one, and on the Postgres family the function holding its body, which dropping a trigger leaves behind.
+ */
+export declare function dropTrigger<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>, name: string): string[];
+/**
+ * The triggers a stamp needs: one per event it names, each assigning the field's expression to its
+ * column. Generated rather than authored, so unlike an authored body it renders on every engine from
+ * one declaration - and not at all on the MySQL family, whose columns stamp themselves.
+ */
+export declare function stampTriggers<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>): EntityTriggerMeta<E>[];

package/dist/migrate/triggerSql.js

@@ -0,0 +1,229 @@
+import { stampEvents } from '../util/field.util.js';
+import { definedEntries } from '../util/object.util.js';
+import { raw, rowColumn, rowRefs } from '../util/raw.js';
+import { ownedName } from '../util/sql.util.js';
+/**
+ * One trigger for `dialect`, named for its table and label and ending in a hash of its own SQL. That hash
+ * is the whole of change detection: a trigger is in place exactly when its name is installed, and an
+ * edited one is a new name, created while the old one drops as no longer declared.
+ */
+export function renderTrigger(dialect, meta, trigger, position) {
+    const table = dialect.resolveTableAlias(meta);
+    const label = trigger.name ?? `${trigger.on}_${position}`;
+    const draft = triggerStatements(dialect, meta, trigger, label);
+    const name = ownedName(table, label, draft.join('\n'));
+    return { name, statements: triggerStatements(dialect, meta, trigger, name) };
+}
+/**
+ * What removes one trigger: the trigger, named with its table only where the engine scopes the name to
+ * one, and on the Postgres family the function holding its body, which dropping a trigger leaves behind.
+ */
+export function dropTrigger(dialect, meta, name) {
+    const { scope, body } = dialect.features.triggers;
+    const table = dialect.escapeId(dialect.resolveTableName(meta));
+    return [
+        `DROP TRIGGER IF EXISTS ${triggerId(dialect, meta, name)}${scope === 'table' ? ` ON ${table}` : ''}`,
+        ...(body === 'function' ? [`DROP FUNCTION IF EXISTS ${schemaObjectId(dialect, meta, name)}()`] : []),
+    ];
+}
+/**
+ * A trigger's name as its statements spell it: bare where the engine keeps the name under its table,
+ * since Postgres refuses a schema there, and in the table's schema where the engine keeps names per
+ * schema, or MySQL would look for it in the connection's database and SQL Server in its default schema.
+ */
+function triggerId(dialect, meta, name) {
+    return dialect.features.triggers.scope === 'table' ? dialect.escapeId(name) : schemaObjectId(dialect, meta, name);
+}
+/** A name in the schema of `meta`'s table, where uql keeps whatever it installs beside it. */
+function schemaObjectId(dialect, meta, name) {
+    return dialect.escapeQualifiedId(name, dialect.resolveSchema(meta));
+}
+/**
+ * The statements creating one trigger under `name`. Every difference between engines is read off
+ * `dialect.features.triggers` rather than branched on a dialect name, so a seventh engine states its
+ * shape and renders here unchanged.
+ */
+function triggerStatements(dialect, meta, trigger, name) {
+    const features = dialect.features.triggers;
+    // The event, read apart once: `beforeUpdate` is `BEFORE` and `UPDATE`, and everything else follows.
+    const before = trigger.on.startsWith('before');
+    const operation = trigger.on.slice(before ? 6 : 5).toUpperCase();
+    const body = triggerBody(dialect, meta, trigger, before);
+    const id = triggerId(dialect, meta, name);
+    const table = dialect.escapeId(dialect.resolveTableName(meta));
+    const column = (key) => dialect.escapeId(dialect.columnOf(meta, key));
+    const names = rowNames(dialect);
+    const rows = [rowRefs(names.$new), rowRefs(names.$old)];
+    const sql = dialect.compileDdl(body(...rows), meta.entity);
+    const guard = triggerGuard(dialect, meta, trigger, rows, names, column);
+    const inBody = features.guards !== 'clause';
+    const guarded = !guard || !inBody
+        ? sql
+        : features.guards === 'beginEnd'
+            ? `IF ${guard}\nBEGIN\n${sql}\nEND`
+            : `IF ${guard} THEN\n${sql}\nEND IF;`;
+    // The preamble opens the body, outside the guard: it settles how the batch reports itself rather than
+    // which rows are touched, so it runs even when the guard keeps the statements from running.
+    const opened = features.preamble ? `${features.preamble}\n${guarded}` : guarded;
+    const of = features.guards === 'clause' && operation === 'UPDATE' && trigger.of?.length
+        ? ` OF ${trigger.of.map(column).join(', ')}`
+        : '';
+    const each = features.rows === 'set' ? '' : '\nFOR EACH ROW';
+    const clause = guard && !inBody ? `\nWHEN (${guard})` : '';
+    const timing = `${before ? 'BEFORE' : 'AFTER'} ${operation}${of}`;
+    const header = features.layout === 'tableFirst'
+        ? `CREATE TRIGGER ${id}\nON ${table} ${timing}${each}${clause}\nAS`
+        : `CREATE TRIGGER ${id}\n${timing} ON ${table}${each}${clause}`;
+    if (features.body !== 'function') {
+        return [`${header}\nBEGIN\n${opened}\nEND`];
+    }
+    // A `BEFORE` trigger returning NULL discards the write, so it hands back the row it leaves behind;
+    // after the write the value is ignored.
+    const returned = before ? (operation === 'DELETE' ? names.$old : names.$new) : 'NULL';
+    const fn = schemaObjectId(dialect, meta, name);
+    return [plpgsqlFunction(fn, `BEGIN\n${opened}\nRETURN ${returned};\nEND`), `${header}\nEXECUTE FUNCTION ${fn}()`];
+}
+/**
+ * The body for the engine in use, refusing first what the engine cannot render at all. One body serves
+ * every engine; in a map, one written for the family serves its forks: CockroachDB runs Postgres's
+ * PL/pgSQL, MariaDB MySQL's.
+ */
+function triggerBody(dialect, meta, trigger, before) {
+    const features = dialect.features.triggers;
+    if (before && !features.before) {
+        throw new TypeError(`${dialect.dialectName} has no BEFORE trigger, only AFTER and INSTEAD OF, so '${trigger.on}' cannot be ` +
+            'rendered there. Use the matching after event, which sees the row already written.');
+    }
+    if (trigger.where && features.rows === 'set') {
+        throw new TypeError(`${dialect.dialectName} fires a trigger once per statement, over the rows it touched, so no condition ` +
+            `can read one row: '${meta.entity.name}' cannot state a trigger 'where' there. Guard inside the body ` +
+            'instead, where `inserted` and `deleted` can be read as tables.');
+    }
+    const { run } = trigger;
+    const body = typeof run === 'function' ? run : (run[dialect.dialectName] ?? run[dialect.dialectFamily]);
+    if (!body) {
+        throw new TypeError(`'${meta.entity.name}' has a trigger with no body for ${dialect.dialectName}, the engine in use. ` +
+            'Write one for it, or one body for every engine.');
+    }
+    return body;
+}
+/** The one condition both guards reduce to: any watched column that moved, and whatever `where` asks. */
+function triggerGuard(dialect, meta, trigger, rows, names, column) {
+    const moved = movedColumns(dialect, meta, trigger.of ?? [], names, column);
+    return [
+        ...(moved ? [moved] : []),
+        ...(trigger.where ? condition(dialect, meta, trigger.where, rows, names, Boolean(moved)) : []),
+    ].join(' AND ');
+}
+/** The PL/pgSQL function holding a body. `OR REPLACE`, since a dropped table leaves its function behind. */
+function plpgsqlFunction(id, block) {
+    const quote = dollarQuote(block);
+    return `CREATE OR REPLACE FUNCTION ${id}() RETURNS trigger AS ${quote}\n${block} ${quote} LANGUAGE plpgsql`;
+}
+/** What the engine calls the rows it hands a trigger: records on a row-based engine, tables on a set-based one. */
+function rowNames(dialect) {
+    return dialect.features.triggers.rows === 'set'
+        ? { $new: 'inserted', $old: 'deleted' }
+        : { $new: 'NEW', $old: 'OLD' };
+}
+/**
+ * The `where` guard as the terms an `AND` joins. A callback writes its own off the rows; a predicate
+ * renders a term per row it names, spelled verbatim because `NEW` is a record the engine declares. Each
+ * is an `operand` wherever another term sits beside it, bracketing itself if compound, as `$where` does.
+ */
+function condition(dialect, meta, where, rows, names, operand) {
+    if (typeof where === 'function') {
+        const sql = dialect.compileDdl(where(...rows), meta.entity);
+        return [operand ? `(${sql})` : sql];
+    }
+    const predicates = definedEntries(where);
+    return predicates.map(([row, predicate]) => {
+        const ctx = dialect.createContext({ inlineValues: true });
+        const escapedPrefix = `${names[row]}.`;
+        dialect.where(ctx, meta.entity, predicate, {
+            clause: false,
+            operand: operand || predicates.length > 1,
+            escapedPrefix,
+        });
+        return ctx.sql;
+    });
+}
+/**
+ * The triggers a stamp needs: one per event it names, each assigning the field's expression to its
+ * column. Generated rather than authored, so unlike an authored body it renders on every engine from
+ * one declaration - and not at all on the MySQL family, whose columns stamp themselves.
+ */
+export function stampTriggers(dialect, meta) {
+    const features = dialect.features.triggers;
+    // Restating the row has to wait for it to be there, so those engines stamp after the write.
+    const after = !features.assignsRow;
+    const newName = rowNames(dialect).$new;
+    return definedEntries(meta.fields).flatMap(([key, field]) => {
+        const events = stampEvents(field);
+        const { computed } = field;
+        if (!events?.length || !computed) {
+            return [];
+        }
+        return events.map((event) => ({
+            on: STAMP_EVENTS[after ? 'after' : 'before'][event],
+            // The event is part of the name: a stamp on both writes installs two triggers, and one identifier
+            // between them would have the second replace the first rather than sit beside it.
+            name: `${key}_${event}`,
+            run: () => stampBody(dialect, meta, key, computed, newName),
+        }));
+    });
+}
+/** The trigger event a stamp fires on, by when the engine lets it write and what it stamps. */
+const STAMP_EVENTS = {
+    before: { insert: 'beforeInsert', update: 'beforeUpdate' },
+    after: { insert: 'afterInsert', update: 'afterUpdate' },
+};
+/** The one statement a stamp runs, in whichever of the two shapes the engine leaves open. */
+function stampBody(dialect, meta, key, value, newName) {
+    const features = dialect.features.triggers;
+    const read = (member) => rowColumn(newName, member);
+    if (features.assignsRow) {
+        const target = read(key);
+        return features.body === 'function' ? raw `${target} := ${value};` : raw `SET ${target} = ${value};`;
+    }
+    const table = dialect.escapeId(dialect.resolveTableName(meta));
+    const column = dialect.escapeId(dialect.columnOf(meta, key));
+    const keyed = meta.ids
+        .map((id) => raw `${text(`${table}.${dialect.escapeId(dialect.columnOf(meta, id))}`)} = ${read(id)}`)
+        .reduce((all, part) => raw `${all} AND ${part}`);
+    // A set-based engine hands the rows as a table, which an `UPDATE` has to name in a `FROM` before its
+    // condition can read one: `inserted."id"` binds to nothing on its own.
+    const from = features.rows === 'set' ? ` FROM ${newName}` : '';
+    // Only where the stamp still differs: this `UPDATE` fires the trigger again, and with recursive triggers
+    // on, the restatement it runs then finds nothing left to change instead of recursing without end.
+    const differs = dialect.neExpr(`${table}.${column}`, dialect.compileDdl(value, meta.entity));
+    return raw `UPDATE ${text(table)} SET ${text(column)} = ${value}${text(from)} WHERE ${keyed} AND ${text(differs)};`;
+}
+/** A dollar quote the body does not contain, so no `$$` in it - a literal, a comment - ends the function early. */
+function dollarQuote(body) {
+    let tag = '$uql$';
+    for (let i = 1; body.includes(tag); i++) {
+        tag = `$uql${i}$`;
+    }
+    return tag;
+}
+/** SQL already written out, for the identifiers a statement splices rather than binds. */
+function text(sql) {
+    return raw((opts) => opts.ctx.append(sql));
+}
+/**
+ * Whether any watched column moved, null-safely, or `undefined` where none is watched: the two records
+ * compared on a row-based engine, and on a set-based one the same question over a join of its two tables.
+ */
+function movedColumns(dialect, meta, of, { $new: newName, $old: oldName }, column) {
+    if (!of.length) {
+        return undefined;
+    }
+    const differs = of.map((key) => dialect.neExpr(`${oldName}.${column(key)}`, `${newName}.${column(key)}`));
+    const moved = differs.length > 1 ? `(${differs.join(' OR ')})` : differs.join('');
+    if (dialect.features.triggers.rows === 'row') {
+        return moved;
+    }
+    const keyed = meta.ids.map((id) => `${newName}.${column(id)} = ${oldName}.${column(id)}`).join(' AND ');
+    return `EXISTS (SELECT 1 FROM ${newName} JOIN ${oldName} ON ${keyed} WHERE ${moved})`;
+}