uql-orm 0.81.0 → 0.83.0

package/dist/migrate/ddl/sqliteIndexDdl.js

@@ -1,4 +1,5 @@
 import { indexDistance, isVectorIndexType, unsupportedVectorMetric } from '../../type/vector.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { IndexDdl } from './indexDdl.js';
 /**
  * SQLite's `CREATE INDEX`, which names no index type. A vector index is libSQL's DiskANN where the dialect
@@ -31,7 +32,7 @@ export class SqliteIndexDdl extends IndexDdl {
         }
         // Its tables are named after the index, unquoted: any other name fails with "unable to initialize diskann".
         if (!/^\w+$/.test(index.name) || index.entries.length !== 1) {
-            throw new TypeError(`libSQL names a vector index only by letters, digits and underscores, over one column (index "${index.name}")`);
+            throw new UqlUsageError(`libSQL names a vector index only by letters, digits and underscores, over one column (index "${index.name}")`);
         }
         return metric;
     }

package/dist/migrate/ddl/tableDdl.js

@@ -1,3 +1,4 @@
+import { UqlUsageError } from '../../util/uqlError.js';
 import { formatDefaultValue, sameDefault } from '../builder/expressions.js';
 /**
  * A column's type with the size it was read back with, unless its spelling already carries one:
@@ -39,7 +40,7 @@ export class TableDdl {
      */
     alterColumn(table, column, definition, from) {
         if (this.dialect.alterColumnSyntax === 'none') {
-            throw new TypeError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
+            throw new UqlUsageError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
                 `This database does not support ALTER COLUMN.`);
         }
         const target = this.dialect.escapeId(table);

package/dist/migrate/generator/mongoCommand.js

@@ -1,3 +1,4 @@
+import { UqlUsageError } from '../../util/uqlError.js';
 export function serializeMongoCommand(command) {
     return JSON.stringify(command);
 }
@@ -9,7 +10,7 @@ function parseMongoCommand(statement) {
     return JSON.parse(statement);
 }
 function unsupportedMongoCommand(statement) {
-    return new TypeError(`unsupported MongoDB migration command: ${statement}`);
+    return new UqlUsageError(`unsupported MongoDB migration command: ${statement}`);
 }
 /** Execute one emitted command. */
 export function runMongoCommand(db, statement) {

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -33,7 +33,7 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
     generateDropTable(tableName: string): string;
     /** A collection's indexes: each dropped, then each created, an alter as both. */
     generateAlterTable(diff: SchemaDiff): string[];
-    /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
+    /** MongoDB runs no trigger within a write, and a write to an entity declaring one is refused, so there is none to reconcile. */
     generateTriggers(): string[];
     generateTriggersDown(): string[];
     generateTriggerDrops(): string[];

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -6,6 +6,7 @@ import { QueryRaw, } from '../../type/index.js';
 import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
 import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { fulltextConfig, fulltextWeights } from '../../util/dialect.util.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
 import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
 import { sides } from '../schemaChange.js';
@@ -30,7 +31,7 @@ export class MongoSchemaGenerator extends MongoDialect {
     }
     /** A collection has no SQL to render a check, a computed column or an index expression into. */
     compileDdl() {
-        throw new TypeError('mongodb has no SQL to render a check, a computed column or an index expression into');
+        throw new UqlUsageError('mongodb has no SQL to render a check, a computed column or an index expression into');
     }
     /**
      * A document store has no cross-collection constraint, so unlike the SQL generator there is nothing to
@@ -84,7 +85,7 @@ export class MongoSchemaGenerator extends MongoDialect {
      */
     compileIndexPredicate(where, entity, indexName) {
         if (where instanceof QueryRaw) {
-            throw new TypeError(`mongodb does not support partial indexes from a SQL predicate (index "${indexName}")`);
+            throw new UqlUsageError(`mongodb does not support partial indexes from a SQL predicate (index "${indexName}")`);
         }
         assertIndexPredicate(where, this.dialectName, indexName);
         const filter = this.renderFilter(entity, where);
@@ -114,7 +115,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             ...sides(diff.indexes, 'to').map((index) => this.generateCreateIndex(diff.tableName, index)),
         ];
     }
-    /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
+    /** MongoDB runs no trigger within a write, and a write to an entity declaring one is refused, so there is none to reconcile. */
     generateTriggers() {
         return [];
     }
@@ -160,7 +161,7 @@ export class MongoSchemaGenerator extends MongoDialect {
         assertIndexFeatures(index, new Set(), this.dialectName);
         const [vector, ...filters] = index.entries;
         if (!vector || index.dimensions === undefined) {
-            throw new TypeError(`an Atlas vector search index states its field's dimensions (index "${index.name}")`);
+            throw new UqlUsageError(`an Atlas vector search index states its field's dimensions (index "${index.name}")`);
         }
         const distance = indexDistance(index);
         const similarity = ATLAS_SIMILARITY[distance];
@@ -192,7 +193,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             case 'createTable': {
                 const { name, columns, indexes } = operation.table;
                 if (columns.length) {
-                    throw new TypeError(`mongodb does not support columns in a migration (collection "${name}")`);
+                    throw new UqlUsageError(`mongodb does not support columns in a migration (collection "${name}")`);
                 }
                 return [
                     serializeMongoCommand({ action: 'createCollection', name }),
@@ -208,7 +209,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             case 'dropIndex':
                 return [this.generateDropIndex(operation.tableName, operation.indexName)];
             default:
-                throw new TypeError(`mongodb does not support ${operation.type} in a migration`);
+                throw new UqlUsageError(`mongodb does not support ${operation.type} in a migration`);
         }
     }
     diffSchema(entity, currentTable) {

package/dist/migrate/indexPredicate.js

@@ -1,5 +1,6 @@
 import { QueryRaw } from '../type/queryRaw.js';
 import { isOperatorObject } from '../util/object.util.js';
+import { UqlUsageError } from '../util/uqlError.js';
 /**
  * The `$where` a partial index takes, on the engines where that is less than a query's: SQL Server's
  * `CREATE INDEX` `<filter_predicate>` (comparisons and `IN` on plain columns, joined by `AND`), and
@@ -30,7 +31,7 @@ export function assertIndexPredicate(where, dialectName, indexName) {
 }
 /** What refusing any part of a partial index's predicate reports. */
 export function refusedIndexPredicate(dialectName, part, indexName) {
-    return new TypeError(`${dialectName} does not support ${part} in a partial index predicate (index "${indexName}")`);
+    return new UqlUsageError(`${dialectName} does not support ${part} in a partial index predicate (index "${indexName}")`);
 }
 /** The first part of `where` outside `grammar`, depth-first; a `raw` clause is left alone. */
 function refusedOperator(where, grammar) {

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -1,6 +1,7 @@
 import { FOREIGN_KEY_ACTIONS } from '../../schema/types.js';
 import { isSqlQuerier } from '../../type/index.js';
 import { isOwnedName } from '../../util/sql.util.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /** A SQL introspector: an engine states its catalogue queries (`get*Query`) and how their rows map (`map*Result`). */
 export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
@@ -73,7 +74,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     withSqlQuerier(task) {
         return this.pool.withQuerier((querier) => {
             if (!isSqlQuerier(querier)) {
-                throw new TypeError(`${this.constructor.name} requires a SQL-based querier`);
+                throw new UqlUsageError(`${this.constructor.name} requires a SQL-based querier`);
             }
             return task(querier);
         });

package/dist/migrate/introspection/mongoIntrospector.d.ts

@@ -10,7 +10,7 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     /** `listIndexes` reports keys, uniqueness and text weights; a `partialFilterExpression` is no SQL predicate. */
     readonly indexFacets: ReadonlySet<IndexFacet>;
     constructor(pool: QuerierPool);
-    /** MongoDB has no triggers, so none is ever installed. */
+    /** MongoDB runs no trigger within a write, so uql installs none. */
     ownedTriggers(): Promise<InstalledTriggers>;
     introspect(tables?: readonly string[]): Promise<SchemaAST>;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;

package/dist/migrate/introspection/mongoIntrospector.js

@@ -1,6 +1,7 @@
 import { textConfigOf } from '../../mongo/textLanguage.js';
 import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
 import { isMongoQuerier, } from '../../type/index.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 /** What a server without Atlas Search answers a search index command with. */
 const SEARCH_NOT_ENABLED = 31082;
 /**
@@ -14,7 +15,7 @@ export class MongoSchemaIntrospector {
     constructor(pool) {
         this.pool = pool;
     }
-    /** MongoDB has no triggers, so none is ever installed. */
+    /** MongoDB runs no trigger within a write, so uql installs none. */
     async ownedTriggers() {
         return new Map();
     }
@@ -80,7 +81,7 @@ export class MongoSchemaIntrospector {
     withDb(task) {
         return this.pool.withQuerier((querier) => {
             if (!isMongoQuerier(querier)) {
-                throw new TypeError('MongoSchemaIntrospector requires a MongoDB querier');
+                throw new UqlUsageError('MongoSchemaIntrospector requires a MongoDB querier');
             }
             return task(querier.db);
         });

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -1,3 +1,4 @@
+import { defaultTimestampPrecision } from '../../schema/canonicalType.js';
 import { AbstractSqlSchemaIntrospector, } from './abstractSqlSchemaIntrospector.js';
 /**
  * SQL Server schema introspector.
@@ -137,7 +138,7 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             const bytes = this.toNumber(row.max_length);
             return {
                 name: row.column_name,
-                type: bytes === -1 && CHARACTER_TYPES.has(type) ? `${type}(MAX)` : type,
+                type: spelledType(type, bytes, this.toNumber(row.numeric_scale)),
                 nullable: Boolean(row.is_nullable),
                 defaultValue: this.parseDefaultValue(row.column_default),
                 isAutoIncrement: Boolean(row.is_identity),
@@ -183,6 +184,17 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
 /** The types whose `max_length` is a width rather than a fixed storage size. */
 const CHARACTER_TYPES = new Set(['CHAR', 'NCHAR', 'VARCHAR', 'NVARCHAR', 'BINARY', 'VARBINARY']);
 const NUMERIC_TYPES = new Set(['DECIMAL', 'NUMERIC']);
+/** `(MAX)` on an unbounded character type, and a timestamp's fractional digits where not the engine's default. */
+function spelledType(type, bytes, scale) {
+    if (bytes === -1 && CHARACTER_TYPES.has(type)) {
+        return `${type}(MAX)`;
+    }
+    return (type === 'DATETIME2' || type === 'DATETIMEOFFSET') &&
+        scale !== undefined &&
+        scale !== defaultTimestampPrecision('mssql')
+        ? `${type}(${scale})`
+        : type;
+}
 /**
  * A column's declared width from `max_length`, which is bytes: an `N` type holds two a character, a
  * `VECTOR` is an 8-byte header and four a dimension, and `MAX` is `-1`. Read as bytes, every Unicode

package/dist/migrate/introspection/mysqlIntrospector.d.ts

@@ -29,6 +29,7 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
 }
 type MysqlColumnRow = {
     column_name: string;
+    data_type: string;
     column_type: string;
     is_nullable: string;
     column_default: string | null;
@@ -36,6 +37,7 @@ type MysqlColumnRow = {
     extra: string;
     character_maximum_length: number | bigint | null;
     numeric_precision: number | bigint | null;
+    datetime_precision: number | bigint | null;
     numeric_scale: number | null;
     column_comment: string | null;
     generated_as: string | null;

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -47,6 +47,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         CHARACTER_MAXIMUM_LENGTH as character_maximum_length,
         NUMERIC_PRECISION as numeric_precision,
         NUMERIC_SCALE as numeric_scale,
+        DATETIME_PRECISION as datetime_precision,
         COLUMN_KEY as column_key,
         EXTRA as extra,
         CASE WHEN EXTRA LIKE '%STORED GENERATED%' THEN GENERATION_EXPRESSION END as generated_as,
@@ -113,7 +114,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             isUnique: row.column_key === 'UNI',
             // A `VECTOR`'s is its bytes, four a dimension, which `column_type` already states as dimensions.
             length: /^vector/i.test(row.column_type) ? undefined : this.toNumber(row.character_maximum_length),
-            precision: this.toNumber(row.numeric_precision),
+            // A timestamp's fractional digits, stated even when 0, which uql's own unstated `DATETIME(3)` is not.
+            precision: this.toNumber(TIMESTAMP_TYPES.has(row.data_type) ? row.datetime_precision : row.numeric_precision),
             scale: this.toNumber(row.numeric_scale),
             comment: row.column_comment || undefined,
             generatedAs: row.generated_as ?? undefined,
@@ -146,7 +148,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         if (normalized === 'NULL') {
             return null;
         }
-        if (normalized === 'CURRENT_TIMESTAMP' || normalized === 'CURRENT_TIMESTAMP()') {
+        // Whatever precision it repeats from its column, which the column's own type already states.
+        if (/^CURRENT_TIMESTAMP(?:\(\d?\))?$/.test(normalized)) {
             return 'CURRENT_TIMESTAMP';
         }
         if (/^-?\d+(\.\d+)?$/.test(defaultValue)) {
@@ -158,6 +161,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return quoted ? unescapeMysqlString(quoted[1]) : literal;
     }
 }
+const TIMESTAMP_TYPES = new Set(['datetime', 'timestamp']);
 /**
  * MariaDB reads out of the same `information_schema` as MySQL, save for one column type it does not
  * have: `JSON` there is an alias for `LONGTEXT` plus a `json_valid()` check constraint named after

package/dist/migrate/introspection/postgresIntrospector.js

@@ -75,7 +75,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         c.is_identity,
         c.identity_generation,
         CASE WHEN a.attgenerated = 's' THEN c.generation_expression END AS generated_as,
-        CASE WHEN c.data_type IN ('USER-DEFINED', 'vector') AND a.atttypmod > -1
+        CASE WHEN (c.data_type IN ('USER-DEFINED', 'vector') OR c.data_type LIKE 'timestamp%') AND a.atttypmod > -1
           THEN format_type(a.atttypid, a.atttypmod) END AS formatted_type,
         EXISTS (
           SELECT 1 FROM information_schema.table_constraints tc

package/dist/migrate/migrationTarget.js

@@ -1,4 +1,5 @@
 import { isMongoQuerier, isSqlQuerier, } from '../type/index.js';
+import { UqlUsageError } from '../util/uqlError.js';
 import { withMongoQuerierForMigrations, withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
 import { MigrationBuilder } from './builder/migrationBuilder.js';
 import { migrationSource } from './codegen/migrationFile.js';
@@ -46,5 +47,5 @@ export async function migrationBuilderFor(querier) {
     if (isMongoQuerier(querier)) {
         return new MigrationBuilder(await mongoSchemaGenerator(), mongoSession(querier).run);
     }
-    throw new TypeError('A migration builder needs a SQL or a MongoDB querier');
+    throw new UqlUsageError('A migration builder needs a SQL or a MongoDB querier');
 }

package/dist/migrate/migrator.js

@@ -5,6 +5,7 @@ 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 { UqlUsageError } from '../util/uqlError.js';
 import { buildMigrationModule } from './codegen/migrationFile.js';
 import { introspectorFor } from './introspection/registry.js';
 import { migrationBuilderFor, migrationTargetFor } from './migrationTarget.js';
@@ -96,7 +97,7 @@ export class Migrator {
         if (options.to) {
             const toIndex = selected.findIndex((m) => m.name === options.to);
             if (toIndex === -1) {
-                throw new TypeError(`Migration '${options.to}' not found`);
+                throw new UqlUsageError(`Migration '${options.to}' not found`);
             }
             selected = selected.slice(0, toIndex + 1);
         }

package/dist/migrate/schemaGenerator.js

@@ -5,6 +5,7 @@ import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
 import { isAutoIncrement, qualifyName } from '../util/index.js';
 import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName, isOwnedName } from '../util/sql.util.js';
+import { UqlUsageError } from '../util/uqlError.js';
 import { sameDefault } from './builder/expressions.js';
 import { splitSqlStatements } from './builder/splitSqlStatements.js';
 import { indexDdlFor, tableDdlFor } from './ddl/index.js';
@@ -536,7 +537,7 @@ export class SqlSchemaGenerator {
     }
     generateAddForeignKeySql(tableName, foreignKey) {
         if (!this.features.foreignKeyAlter) {
-            throw new TypeError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
+            throw new UqlUsageError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
         }
         const constraint = this.foreignKeyConstraint(tableName, foreignKey, this.escapeId(foreignKey.references.table));
         return `ALTER TABLE ${this.escapeId(tableName)} ADD ${constraint};`;
@@ -566,7 +567,7 @@ export class SqlSchemaGenerator {
             return `ALTER TABLE ${table} DROP PRIMARY KEY;`;
         }
         if (!constraintName) {
-            throw new TypeError(`Cannot drop the primary key of "${tableName}": ${this.dialect} names the constraint, and ` +
+            throw new UqlUsageError(`Cannot drop the primary key of "${tableName}": ${this.dialect} names the constraint, and ` +
                 'introspection did not report a name for it.');
         }
         return `ALTER TABLE ${table} DROP CONSTRAINT ${this.escapeId(constraintName)};`;
@@ -579,7 +580,7 @@ export class SqlSchemaGenerator {
         if (!column.generatedAs || this.features.generatedColumnAdd) {
             return;
         }
-        throw new TypeError(`${this.dialect}: Cannot add the computed column "${column.name}" to the existing table ` +
+        throw new UqlUsageError(`${this.dialect}: Cannot add the computed column "${column.name}" to the existing table ` +
             `"${tableName}" - this database only accepts one in a CREATE TABLE. Drop \`stored\` to have the ` +
             'expression spliced into each statement instead, or recreate the table in a written migration.');
     }
@@ -587,7 +588,7 @@ export class SqlSchemaGenerator {
         if (this.features.primaryKeyAlter) {
             return;
         }
-        throw new TypeError(`${this.dialect}: Cannot change the primary key of "${tableName}" - this database has no ALTER ` +
+        throw new UqlUsageError(`${this.dialect}: Cannot change the primary key of "${tableName}" - this database has no ALTER ` +
             'for it. Recreate the table in a written migration.');
     }
 }

package/dist/migrate/storage/databaseStorage.js

@@ -32,7 +32,7 @@ export class DatabaseMigrationStorage {
     async createTableIfNotExists(querier) {
         const table = new TableBuilder(this.tableName);
         table.string('name', { length: 255, primaryKey: true });
-        table.timestamp('executed_at', { defaultValue: expr.now() });
+        table.timestamptz('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);

package/dist/migrate/triggerSql.d.ts

@@ -21,4 +21,4 @@ export declare function dropTrigger<E>(dialect: AbstractSqlDialect, meta: Entity
  * 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>[];
+export declare function stampTriggers<E extends object>(dialect: AbstractSqlDialect, meta: EntityMeta<E>): EntityTriggerMeta<E>[];

package/dist/migrate/triggerSql.js

@@ -1,7 +1,8 @@
 import { stampEvents } from '../util/field.util.js';
 import { definedEntries } from '../util/object.util.js';
-import { raw, rowColumn, rowRefs } from '../util/raw.js';
+import { raw, refs, rowRefs } from '../util/raw.js';
 import { ownedName } from '../util/sql.util.js';
+import { UqlUsageError } from '../util/uqlError.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
@@ -20,7 +21,7 @@ export function renderTrigger(dialect, meta, trigger, position) {
  */
 export function dropTrigger(dialect, meta, name) {
     const { scope, body } = dialect.features.triggers;
-    const table = dialect.escapeId(dialect.resolveTableName(meta));
+    const table = dialect.escapedTableName(meta);
     return [
         `DROP TRIGGER IF EXISTS ${triggerId(dialect, meta, name)}${scope === 'table' ? ` ON ${table}` : ''}`,
         ...(body === 'function' ? [`DROP FUNCTION IF EXISTS ${schemaObjectId(dialect, meta, name)}()`] : []),
@@ -45,17 +46,15 @@ function schemaObjectId(dialect, meta, name) {
  */
 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 [timing, operation] = EVENT_PARTS[trigger.on];
+    const before = timing === 'BEFORE';
     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 table = dialect.escapedTableName(meta);
     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 rows = [rowRefs(meta.entity, names.$new), rowRefs(meta.entity, names.$old)];
+    const sql = dialect.compileDdl(body(...rows), meta.entity, { rows: rowsFrom(dialect, meta, operation) });
+    const guard = triggerGuard(dialect, meta, trigger, rows, names);
     const inBody = features.guards !== 'clause';
     const guarded = !guard || !inBody
         ? sql
@@ -66,14 +65,14 @@ function triggerStatements(dialect, meta, trigger, name) {
     // 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(', ')}`
+        ? ` OF ${trigger.of.map((key) => dialect.escapedColumnName(meta, key)).join(', ')}`
         : '';
     const each = features.rows === 'set' ? '' : '\nFOR EACH ROW';
     const clause = guard && !inBody ? `\nWHEN (${guard})` : '';
-    const timing = `${before ? 'BEFORE' : 'AFTER'} ${operation}${of}`;
+    const when = `${timing} ${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}`;
+        ? `CREATE TRIGGER ${id}\nON ${table} ${when}${each}${clause}\nAS`
+        : `CREATE TRIGGER ${id}\n${when} ON ${table}${each}${clause}`;
     if (features.body !== 'function') {
         return [`${header}\nBEGIN\n${opened}\nEND`];
     }
@@ -83,6 +82,15 @@ function triggerStatements(dialect, meta, trigger, name) {
     const fn = schemaObjectId(dialect, meta, name);
     return [plpgsqlFunction(fn, `BEGIN\n${opened}\nRETURN ${returned};\nEND`), `${header}\nEXECUTE FUNCTION ${fn}()`];
 }
+/** Each event read apart: `beforeUpdate` is `BEFORE` and `UPDATE`. */
+const EVENT_PARTS = {
+    beforeInsert: ['BEFORE', 'INSERT'],
+    afterInsert: ['AFTER', 'INSERT'],
+    beforeUpdate: ['BEFORE', 'UPDATE'],
+    afterUpdate: ['AFTER', 'UPDATE'],
+    beforeDelete: ['BEFORE', 'DELETE'],
+    afterDelete: ['AFTER', 'DELETE'],
+};
 /**
  * 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
@@ -91,25 +99,25 @@ function triggerStatements(dialect, meta, trigger, name) {
 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 ` +
+        throw new UqlUsageError(`${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 ` +
+        throw new UqlUsageError(`${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. ` +
+        throw new UqlUsageError(`'${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);
+function triggerGuard(dialect, meta, trigger, rows, names) {
+    const moved = movedColumns(dialect, meta, trigger.of ?? [], names);
     return [
         ...(moved ? [moved] : []),
         ...(trigger.where ? condition(dialect, meta, trigger.where, rows, names, Boolean(moved)) : []),
@@ -137,16 +145,10 @@ function condition(dialect, meta, where, rows, names, operand) {
         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;
-    });
+    return predicates.map(([row, predicate]) => dialect.compileDdl(predicate, meta.entity, {
+        escapedPrefix: `${names[row]}.`,
+        operand: operand || predicates.length > 1,
+    }));
 }
 /**
  * The triggers a stamp needs: one per event it names, each assigning the field's expression to its
@@ -157,8 +159,8 @@ 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 fields = meta.fields;
+    return definedEntries(fields).flatMap(([key, field]) => {
         const events = stampEvents(field);
         const { computed } = field;
         if (!events?.length || !computed) {
@@ -169,7 +171,7 @@ export function stampTriggers(dialect, meta) {
             // 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),
+            run: (newRow) => stampBody(dialect, meta, key, computed, newRow),
         }));
     });
 }
@@ -178,26 +180,25 @@ 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};`;
+/**
+ * The one statement a stamp runs, in whichever of the two shapes the engine leaves open: an assignment
+ * to the incoming row, or where it may not be written, the row restated after the write, as any write in
+ * a trigger's body is, keyed on its whole key and only where the stamp still differs: that `UPDATE` fires
+ * the trigger again, and with recursive triggers on it then finds nothing left to change.
+ */
+function stampBody(dialect, meta, key, value, newRow) {
+    const { entity } = meta;
+    if (dialect.features.triggers.assignsRow) {
+        const target = newRow[key];
+        return dialect.features.triggers.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)};`;
+    const table = refs(entity);
+    const keyed = meta.ids.map((id) => raw `${table[id]} = ${newRow[id]}`);
+    // Read through the write's own qualifier, as `keyed` is: `inserted` holds the same column name.
+    const stamped = dialect.compileDdl(value, entity);
+    const differs = raw(({ ctx, escapedPrefix }) => ctx.append(dialect.neExpr(`${escapedPrefix}${dialect.escapedColumnName(meta, key)}`, stamped)));
+    const where = { $and: [...keyed, differs] };
+    return raw(({ ctx, rows }) => dialect.triggerWrite(ctx, { kind: 'update', entity, set: { [key]: value }, where }, rows));
 }
 /** A dollar quote the body does not contain, so no `$$` in it - a literal, a comment - ends the function early. */
 function dollarQuote(body) {
@@ -207,23 +208,38 @@ function dollarQuote(body) {
     }
     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) {
+function movedColumns(dialect, meta, of, { $new: newName, $old: oldName }) {
     if (!of.length) {
         return undefined;
     }
-    const differs = of.map((key) => dialect.neExpr(`${oldName}.${column(key)}`, `${newName}.${column(key)}`));
+    const differs = of.map((key) => {
+        const column = dialect.escapedColumnName(meta, key);
+        return dialect.neExpr(`${oldName}.${column}`, `${newName}.${column}`);
+    });
     const moved = differs.length > 1 ? `(${differs.join(' OR ')})` : differs.join('');
-    if (dialect.features.triggers.rows === 'row') {
-        return moved;
+    const source = rowsFrom(dialect, meta, 'UPDATE');
+    return source ? `EXISTS (SELECT 1 ${source} WHERE ${moved})` : moved;
+}
+/**
+ * Where a set-based engine's body reads the rows it fires for, as the `FROM` a statement names them in:
+ * `inserted` on an insert, `deleted` on a delete, and on an update both, joined on the whole key. None on a
+ * row-based engine, whose body reads `NEW` and `OLD` bare.
+ */
+function rowsFrom(dialect, meta, operation) {
+    if (dialect.features.triggers.rows !== 'set') {
+        return undefined;
+    }
+    const { $new, $old } = rowNames(dialect);
+    if (operation !== 'UPDATE') {
+        return `FROM ${operation === 'INSERT' ? $new : $old}`;
     }
-    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})`;
+    const keyed = meta.ids.map((id) => {
+        const column = dialect.escapedColumnName(meta, id);
+        return `${$new}.${column} = ${$old}.${column}`;
+    });
+    return `FROM ${$new} JOIN ${$old} ON ${keyed.join(' AND ')}`;
 }

package/dist/mongo/mongoDialect.d.ts

@@ -90,9 +90,7 @@ export declare class MongoDialect extends AbstractDialect {
      * apply to JSON paths.
      */
     private assertKnownPathRoot;
-    /**
-     * Transform UQL operators to MongoDB operators.
-     */
+    /** Transform UQL operators to MongoDB operators, refusing as `refusal` a key that is none. */
     private transformOperators;
     /**
      * What a value holding `value` matches, as the SQL engines read it: an operator map tests it, an array