uql-orm 0.79.0 → 0.80.0

package/dist/dialect/operators.js

@@ -0,0 +1,129 @@
+import { VECTOR_QUERY_KEYS, } from '../type/index.js';
+import { isOperatorMap } from '../util/dialect.util.js';
+import { kindOf, UqlUsageError } from '../util/uqlError.js';
+/**
+ * How each grouping operator renders: the operator joining its clauses, and whether the group is
+ * negated (`$not` is `NOT (a AND b)`). Total over {@link QueryGroupOp}.
+ */
+export const GROUP_OPS = {
+    $and: { join: '$and', negate: false },
+    $or: { join: '$or', negate: false },
+    $not: { join: '$and', negate: true },
+    $nor: { join: '$or', negate: true },
+};
+/** Whether a `$where` key groups clauses, narrowing it for the renderers that read {@link GROUP_OPS}. */
+export function isGroupOp(key) {
+    return Object.hasOwn(GROUP_OPS, key);
+}
+/**
+ * A group operator's clauses, rejecting what the types do not cover: `/http` casts client JSON
+ * straight to `Query`, so a scalar can arrive where an array belongs. Shared so both backends
+ * refuse the same payload rather than one throwing and the other failing further in.
+ */
+export function groupClauses(key, val) {
+    if (val !== undefined && !Array.isArray(val)) {
+        throw new UqlUsageError(`${key} expects an array, got ${kindOf(val)}`);
+    }
+    return val ?? [];
+}
+/**
+ * A WHERE value as the operators it applies: an array is `$in`, an operator map its own entries, and
+ * anything else `$eq`. Each key is checked here, once, refused as `refusal` where it is no operator.
+ */
+export function whereOperators(val, refusal) {
+    const ops = Array.isArray(val) ? { $in: val } : isOperatorMap(val) ? val : { $eq: val };
+    return Object.entries(ops).map(([op, value]) => {
+        if (!isFieldOp(op)) {
+            throw new UqlUsageError(`${refusal}: ${op}`);
+        }
+        return [op, value];
+    });
+}
+/** An `$in`/`$nin` operand, which the types require to be an array but `/http` hands over untyped. */
+export function inOperands(op, value) {
+    if (!Array.isArray(value)) {
+        throw new UqlUsageError(`${op} expects an array, got ${kindOf(value)}`);
+    }
+    return value;
+}
+/** A `$between`'s two bounds, which `/http` hands over untyped too; one missing would bind `undefined`. */
+export function betweenBounds(value) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        const got = Array.isArray(value) ? `${value.length} values` : kindOf(value);
+        throw new UqlUsageError(`$between expects [min, max], got ${got}`);
+    }
+    const [min, max] = value;
+    return [min, max];
+}
+/**
+ * Every field operator as data, which is what checks a key `/http` hands over; `satisfies` fails the
+ * build on one {@link QueryWhereFieldOp} gains and this misses.
+ */
+const FIELD_OPS = {
+    $eq: true,
+    $ne: true,
+    $not: true,
+    $lt: true,
+    $lte: true,
+    $gt: true,
+    $gte: true,
+    $between: true,
+    $startsWith: true,
+    $istartsWith: true,
+    $endsWith: true,
+    $iendsWith: true,
+    $includes: true,
+    $iincludes: true,
+    $like: true,
+    $ilike: true,
+    $regex: true,
+    $in: true,
+    $nin: true,
+    $isNull: true,
+    $isNotNull: true,
+    $all: true,
+    $size: true,
+    $elemMatch: true,
+    $near: true,
+};
+function isFieldOp(op) {
+    return Object.hasOwn(FIELD_OPS, op);
+}
+/** Whether a `$near` names the vector it measures from, which its type requires and `/http` does not. */
+export function isVectorQuery(near) {
+    return Boolean(near['$vector']);
+}
+export const COMPARE_OPS = new Map([
+    ['$gt', ' > '],
+    ['$gte', ' >= '],
+    ['$lt', ' < '],
+    ['$lte', ' <= '],
+]);
+/**
+ * The ordered comparisons, `QueryOrderedOp` at runtime, derived from {@link COMPARE_OPS} rather than spelled
+ * again: {@link QueryVectorNear}'s bounds, so `$near` never accepts one the renderer has no operator
+ * for, and the operators that read a JSON path as a number.
+ */
+export const ORDERED_OPS = new Set([...COMPARE_OPS.keys(), '$between']);
+export function isOrderedOp(op) {
+    return ORDERED_OPS.has(op);
+}
+/** The operators an equality compares by value, which a JSON path reads the way that value compares. */
+export const EQUALITY_OPS = new Set(['$eq', '$ne', '$in', '$nin']);
+/**
+ * Every `$like`-family operator: the pattern it wraps its value in, and whether it ignores case.
+ * Each case-sensitive operator is paired here with the `$i` twin that shares its pattern, so the
+ * two can never drift apart - and neither one decides case folding, which is
+ * `AbstractSqlDialect.caseInsensitiveMatch`'s single call.
+ */
+export const LIKE_OPS = new Map([
+    ['$like', '$ilike', (v) => v],
+    ['$startsWith', '$istartsWith', (v) => `${v}%`],
+    ['$endsWith', '$iendsWith', (v) => `%${v}`],
+    ['$includes', '$iincludes', (v) => `%${v}%`],
+].flatMap(([sensitive, insensitive, pattern]) => [
+    [sensitive, { pattern, insensitive: false }],
+    [insensitive, { pattern, insensitive: true }],
+]));
+/** What a `$near` says about the search itself; everything else in it is a bound. */
+export const VECTOR_QUERY_KEY_SET = new Set(VECTOR_QUERY_KEYS);

package/dist/dialect/pgLikeSqlDialect.d.ts

@@ -1,4 +1,5 @@
 import type { IndexType } from '../schema/types.js';
+import type { SqlDialectName } from '../type/index.js';
 import { type DriverCapabilities, type EntityMeta, type FieldOptions, type JsonColumnType, type Query, type QueryContext, type QueryTextSearchOptions, type SqlDialectFeatures, type VectorDistance, type VectorMetric } from '../type/index.js';
 import type { DialectOptions } from './abstractDialect.js';
 import { AbstractSqlDialect, type RelationRows } from './abstractSqlDialect.js';
@@ -13,6 +14,8 @@ export declare const PG_VECTOR_METRICS: ReadonlyMap<VectorDistance, VectorMetric
 export declare const PG_FEATURES: SqlDialectFeatures;
 /** What Postgres and CockroachDB share: JSONB, full-text search, pgvector's operators, and the upsert. */
 export declare abstract class PgLikeSqlDialect extends AbstractSqlDialect {
+    /** Every member of this family runs the same SQL, so a body written once serves them all. */
+    get dialectFamily(): SqlDialectName;
     /** How the driver binds a parameter: node-`pg`'s, unless the pool states its own. */
     readonly driverCapabilities: DriverCapabilities;
     constructor(options?: PgLikeDialectOptions);
@@ -96,7 +99,7 @@ export declare abstract class PgLikeSqlDialect extends AbstractSqlDialect {
     jsonPathExpr(escapedColumn: string, path: string, mode: JsonAccessMode): string;
     protected get regexpOp(): string;
     protected readonly caseInsensitiveMatch = "ilike";
-    protected get neOp(): string;
+    neExpr(field: string, ph: string): string;
     /**
      * One array parameter, which a context that inlines values has none of: it lists them instead. The
      * array takes its type from `operand`, so it needs none of the casts `bind` would give each value.

package/dist/dialect/pgLikeSqlDialect.js

@@ -17,7 +17,6 @@ export const PG_VECTOR_METRICS = new Map([
 const HNSW_EF_SEARCH = 'hnsw.ef_search';
 /** What the Postgres-wire engines have. */
 export const PG_FEATURES = {
-    ifNotExists: true,
     indexIfNotExists: true,
     schemas: true,
     dropTableCascade: true,
@@ -41,9 +40,23 @@ export const PG_FEATURES = {
     narrowVectorTypes: false,
     vectorTuningNeedsTransaction: true,
     serialDeclaresPrimaryKey: false,
+    triggers: {
+        preamble: '',
+        assignsRow: true,
+        body: 'function',
+        guards: 'clause',
+        layout: 'timingFirst',
+        rows: 'row',
+        scope: 'table',
+        before: true,
+    },
 };
 /** What Postgres and CockroachDB share: JSONB, full-text search, pgvector's operators, and the upsert. */
 export class PgLikeSqlDialect extends AbstractSqlDialect {
+    /** Every member of this family runs the same SQL, so a body written once serves them all. */
+    get dialectFamily() {
+        return 'postgres';
+    }
     /** How the driver binds a parameter: node-`pg`'s, unless the pool states its own. */
     driverCapabilities;
     constructor(options = {}) {
@@ -213,8 +226,8 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         return '~';
     }
     caseInsensitiveMatch = 'ilike';
-    get neOp() {
-        return 'IS DISTINCT FROM';
+    neExpr(field, ph) {
+        return `${field} IS DISTINCT FROM ${ph}`;
     }
     /**
      * One array parameter, which a context that inlines values has none of: it lists them instead. The

package/dist/entity/decorator/entity.d.ts

@@ -1,4 +1,4 @@
-import type { EntityIndexColumnInput, EntityIndexOptions, EntityOptions, FilterName, FilterOptions, RefMap, Type } from '../../type/index.js';
+import type { EntityIndexColumnInput, EntityIndexOptions, EntityOptions, FilterName, FilterOptions, RefMap, TriggerOptions, Type } from '../../type/index.js';
 /**
  * Marks a class as an entity and finalizes its metadata, draining `context.metadata`: the class gets
  * `Symbol.metadata` only after its decorators return.
@@ -16,3 +16,8 @@ export declare function Filter<E, N extends string>(name: FilterName<N>, opts: F
  * @example `@Index((user) => [user.lastName, raw`lower(${user.email})`], { unique: true })`
  */
 export declare function Index<E>(columns: (refs: RefMap<E>) => readonly EntityIndexColumnInput<E>[], options?: EntityIndexOptions<E>): (entity: Type<E>) => void;
+/**
+ * Declares triggers the database runs, in the order written. Stacks, so several may sit above one class.
+ * @example ``@Trigger({ on: 'beforeUpdate', of: (post) => [post.body], run: (newRow) => raw`...` })``
+ */
+export declare function Trigger<E>(...triggers: readonly TriggerOptions<E>[]): (entity: Type<E>) => void;

package/dist/entity/decorator/entity.js

@@ -1,4 +1,4 @@
-import { applyMembers, defineEntity, defineFilter, defineIndex } from '../metadata/definition.js';
+import { applyMembers, defineEntity, defineFilter, defineIndex, defineTrigger } from '../metadata/definition.js';
 import { drainRegistrations } from './bag.js';
 // The class-level decorators. Unlike the member ones they receive the class, so each is a direct call
 // into the registry with no bag in between.
@@ -32,3 +32,14 @@ export function Index(columns, options = {}) {
         defineIndex(entity, { ...options, columns });
     };
 }
+/**
+ * Declares triggers the database runs, in the order written. Stacks, so several may sit above one class.
+ * @example ``@Trigger({ on: 'beforeUpdate', of: (post) => [post.body], run: (newRow) => raw`...` })``
+ */
+export function Trigger(...triggers) {
+    return (entity) => {
+        for (const trigger of triggers) {
+            defineTrigger(entity, trigger);
+        }
+    };
+}

package/dist/entity/index.d.ts

@@ -1,3 +1,3 @@
 export * from './decorator/entity.js';
 export * from './decorator/members.js';
-export { defineEntity, defineField, defineFilter, defineHook, defineId, defineIndex, defineRelation, getEntities, getMeta, removeEntity, assertSoleId, fieldOf, idOf, namesKey, relationOf, soleIdOf, } from './metadata/definition.js';
+export { defineEntity, defineField, defineFilter, defineHook, defineId, defineIndex, defineRelation, defineTrigger, getEntities, getMeta, removeEntity, assertSoleId, fieldOf, idOf, namesKey, relationOf, soleIdOf, } from './metadata/definition.js';

package/dist/entity/index.js

@@ -1,3 +1,3 @@
 export * from './decorator/entity.js';
 export * from './decorator/members.js';
-export { defineEntity, defineField, defineFilter, defineHook, defineId, defineIndex, defineRelation, getEntities, getMeta, removeEntity, assertSoleId, fieldOf, idOf, namesKey, relationOf, soleIdOf, } from './metadata/definition.js';
+export { defineEntity, defineField, defineFilter, defineHook, defineId, defineIndex, defineRelation, defineTrigger, getEntities, getMeta, removeEntity, assertSoleId, fieldOf, idOf, namesKey, relationOf, soleIdOf, } from './metadata/definition.js';

package/dist/entity/metadata/definition.d.ts

@@ -1,4 +1,4 @@
-import type { EntityIndexInput, EntityMembers, EntityMeta, EntityOptions, FieldMeta, FieldOptions, FilterName, FilterOptions, HookEvent, IdKey, RelationKey, RelationMeta, RelationOptions, RelationRegistration, Type, WrittenId } from '../../type/index.js';
+import type { EntityIndexInput, EntityMembers, EntityMeta, EntityOptions, FieldMeta, FieldOptions, FilterName, FilterOptions, HookEvent, IdKey, RelationKey, RelationMeta, RelationOptions, RelationRegistration, TriggerOptions, Type, WrittenId } from '../../type/index.js';
 export declare function defineField<E>(entity: Type<E>, key: string, opts?: FieldOptions): EntityMeta<E>;
 export declare function defineId<E>(entity: Type<E>, key: string, opts: FieldOptions): EntityMeta<E>;
 /** `T` is the relation's target, independent of the owner `E`. */
@@ -15,6 +15,11 @@ export declare function defineHook<E>(entity: Type<E>, methodName: string, event
  * sugar are normalized here, which is what lets the dialects render one shape instead of re-parsing it.
  */
 export declare function defineIndex<E>(entity: Type<E>, index: EntityIndexInput<E>): EntityMeta<E>;
+/**
+ * Registers a trigger, its watched columns read off the entity's refs so a rename reaches them and a
+ * column the entity has not got does not compile. Appended, since triggers fire in the order written.
+ */
+export declare function defineTrigger<E>(entity: Type<E>, trigger: TriggerOptions<E>): EntityMeta<E>;
 export declare function defineFilter<E, N extends string>(entity: Type<E>, name: FilterName<N>, opts: FilterOptions<E>): EntityMeta<E>;
 /**
  * Feeds fields, relations and hooks into the `define*` primitives, so the decorators and the imperative

package/dist/entity/metadata/definition.js

@@ -112,6 +112,22 @@ export function defineIndex(entity, index) {
     });
     return meta;
 }
+/**
+ * Registers a trigger, its watched columns read off the entity's refs so a rename reaches them and a
+ * column the entity has not got does not compile. Appended, since triggers fire in the order written.
+ */
+export function defineTrigger(entity, trigger) {
+    const meta = ensureWritableMeta(entity);
+    // The type already refuses an empty map; this is the same answer for plain JavaScript.
+    if (typeof trigger.run !== 'function' && !hasKeys(trigger.run)) {
+        throw new TypeError(`'${entity.name}' has a trigger whose body names at least one engine to run on`);
+    }
+    if (trigger.name && meta.triggers?.some((it) => it.name === trigger.name)) {
+        throw new TypeError(`'${entity.name}' already has a trigger named '${trigger.name}'`);
+    }
+    (meta.triggers ??= []).push({ ...trigger, of: trigger.of?.(memberRefs()).map((ref) => ref.key) });
+    return meta;
+}
 export function defineFilter(entity, name, opts) {
     const meta = ensureWritableMeta(entity);
     if (name === SOFT_DELETE_FILTER) {
@@ -178,6 +194,9 @@ export function defineEntity(entity, opts = {}) {
     for (const index of opts.indexes ?? []) {
         defineIndex(entity, index);
     }
+    for (const trigger of opts.triggers ?? []) {
+        defineTrigger(entity, trigger);
+    }
     for (const [name, filter] of definedEntries(opts.filters ?? {})) {
         defineFilter(entity, name, filter);
     }

package/dist/migrate/codegen/entityTypes.js

@@ -1,6 +1,5 @@
 import { getMeta } from '../../entity/index.js';
-import { canonicalToTypeScript } from '../../schema/canonicalType.js';
-import { resolveColumnCanonicalType } from '../../schema/schemaASTBuilder.js';
+import { canonicalToTypeScript, resolveColumnCanonicalType } from '../../schema/canonicalType.js';
 import { isToManyRelation, upperFirst } from '../../util/index.js';
 import { isIdentifierName } from './sourceLiteral.js';
 /**

package/dist/migrate/ddl/mssqlIndexDdl.d.ts

@@ -1,3 +1,4 @@
+import type { IndexSchema } from '../../type/index.js';
 import { IndexDdl } from './indexDdl.js';
 /**
  * SQL Server's `CREATE INDEX` is the portable form minus what 2025 rejects: an expression (Msg 16216),
@@ -7,4 +8,8 @@ import { IndexDdl } from './indexDdl.js';
 export declare class MsSqlIndexDdl extends IndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+    /** T-SQL has no `IF NOT EXISTS` on an index, so the create is guarded by a lookup in the same statement. */
+    getCreateIndexStatement(tableName: string, index: IndexSchema, opts?: {
+        ifNotExists?: boolean;
+    }): string;
 }

package/dist/migrate/ddl/mssqlIndexDdl.js

@@ -7,4 +7,14 @@ import { IndexDdl } from './indexDdl.js';
 export class MsSqlIndexDdl extends IndexDdl {
     indexFeatures = new Set(['partial']);
     indexTypes = new Set(['btree']);
+    /** T-SQL has no `IF NOT EXISTS` on an index, so the create is guarded by a lookup in the same statement. */
+    getCreateIndexStatement(tableName, index, opts = {}) {
+        const create = super.getCreateIndexStatement(tableName, index, { ifNotExists: false });
+        if (!(opts.ifNotExists ?? this.dialect.features.indexIfNotExists)) {
+            return create;
+        }
+        const table = this.dialect.escape(this.dialect.escapeId(tableName));
+        const name = this.dialect.escape(index.name);
+        return `IF NOT EXISTS (SELECT 1 FROM sys.indexes WHERE name = ${name} AND object_id = OBJECT_ID(${table})) ${create}`;
+    }
 }

package/dist/migrate/ddl/mssqlTableDdl.d.ts

@@ -6,6 +6,8 @@ import { TableDdl } from './tableDdl.js';
  * databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
  */
 export declare class MsSqlTableDdl extends TableDdl {
+    /** T-SQL has no `IF NOT EXISTS` on a table, so the create is guarded by a lookup in the same statement. */
+    createTable(target: string, ifNotExists: boolean): string;
     /** T-SQL rejects the optional `COLUMN` keyword after `ADD`. */
     addColumn(table: string, definition: string): string;
     /** Its constraints go with the column, as they do on every other engine. */

package/dist/migrate/ddl/mssqlTableDdl.js

@@ -16,6 +16,11 @@ const CONSTRAINTS_ON = {
  * databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
  */
 export class MsSqlTableDdl extends TableDdl {
+    /** T-SQL has no `IF NOT EXISTS` on a table, so the create is guarded by a lookup in the same statement. */
+    createTable(target, ifNotExists) {
+        const guard = ifNotExists ? `IF OBJECT_ID(${this.dialect.escape(target)}, N'U') IS NULL ` : '';
+        return `${guard}${super.createTable(target, false)}`;
+    }
     /** T-SQL rejects the optional `COLUMN` keyword after `ADD`. */
     addColumn(table, definition) {
         return /*sql*/ `ALTER TABLE ${this.dialect.escapeId(table)} ADD ${definition};`;

package/dist/migrate/ddl/tableDdl.d.ts

@@ -12,6 +12,8 @@ export declare function sizedType(column: Pick<ColumnSchema, 'type' | 'length' |
 export declare class TableDdl {
     protected readonly dialect: AbstractSqlDialect;
     constructor(dialect: AbstractSqlDialect);
+    /** A `CREATE TABLE` up to its column list, a no-op where `ifNotExists` and the table is already there. */
+    createTable(target: string, ifNotExists: boolean): string;
     addColumn(table: string, definition: string): string;
     dropColumn(table: string, column: string): string[];
     /**

package/dist/migrate/ddl/tableDdl.js

@@ -22,6 +22,10 @@ export class TableDdl {
     constructor(dialect) {
         this.dialect = dialect;
     }
+    /** A `CREATE TABLE` up to its column list, a no-op where `ifNotExists` and the table is already there. */
+    createTable(target, ifNotExists) {
+        return `CREATE TABLE ${ifNotExists ? 'IF NOT EXISTS ' : ''}${target}`;
+    }
     addColumn(table, definition) {
         return `ALTER TABLE ${this.dialect.escapeId(table)} ADD COLUMN ${definition};`;
     }

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

@@ -33,6 +33,10 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
     generateDropTable(tableName: string): string;
     generateAlterTable(diff: SchemaDiff): string[];
     generateAlterTableDown(diff: SchemaDiff): string[];
+    /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
+    generateTriggers(): string[];
+    generateTriggersDown(): string[];
+    generateTriggerDrops(): string[];
     private dropIndexCommand;
     /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName: string, index: IndexSchema): string;

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -118,6 +118,16 @@ export class MongoSchemaGenerator extends MongoDialect {
             ...(diff.indexesToDrop ?? []).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. */
+    generateTriggers() {
+        return [];
+    }
+    generateTriggersDown() {
+        return [];
+    }
+    generateTriggerDrops() {
+        return [];
+    }
     dropIndexCommand(tableName, index) {
         return index.type === 'vectorSearch'
             ? serializeMongoCommand({ action: 'dropSearchIndex', collection: tableName, name: index.name })

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

@@ -1,5 +1,5 @@
 import { type ForeignKeyAction } from '../../schema/types.js';
-import type { ColumnSchema, ForeignKeySchema, IndexSchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
+import type { ColumnSchema, InstalledTriggers, ForeignKeySchema, IndexSchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /**
  * Reads the rows of one statement while introspecting a table.
@@ -38,6 +38,12 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected readonly defaultSchemaExpr: string;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     getTableNames(): Promise<string[]>;
+    /**
+     * Every trigger uql installed in this schema, by table and then by name, with the statements recreating
+     * it: the whole schema in one read, since a table whose entity stopped declaring one still has one to
+     * drop. Ownership is matched here rather than with `LIKE`, whose `_` wildcard would take in a hand-written one.
+     */
+    ownedTriggers(): Promise<Map<string, InstalledTriggers>>;
     tableExists(tableName: string): Promise<boolean>;
     /**
      * Introspection reads, so `withQuerier` rather than `transaction`: the pool owns the release either
@@ -79,6 +85,12 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected abstract getForeignKeysQuery(tableName: string): string;
     /** SQL query to get primary key columns. Parameter: tableName (for PRAGMA-style). */
     protected abstract getPrimaryKeyQuery(tableName: string): string;
+    /**
+     * SQL listing every trigger in the schema as a `table`, a `name`, the engine's reprint of it as a
+     * `definition`, and where the body lives apart, the `requires` recreated first: what is installed, not
+     * what uql wrote, which is exactly what a rollback puts back.
+     */
+    protected abstract triggersQuery(): string;
     /**
      * Extract table name from a row returned by getTableNamesQuery.
      *

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -1,5 +1,6 @@
 import { FOREIGN_KEY_ACTIONS } from '../../schema/types.js';
 import { isSqlQuerier } from '../../type/index.js';
+import { isOwnedName } from '../../util/sql.util.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 {
@@ -50,6 +51,26 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
             return results.map((row) => this.mapTableNameRow(row));
         });
     }
+    /**
+     * Every trigger uql installed in this schema, by table and then by name, with the statements recreating
+     * it: the whole schema in one read, since a table whose entity stopped declaring one still has one to
+     * drop. Ownership is matched here rather than with `LIKE`, whose `_` wildcard would take in a hand-written one.
+     */
+    async ownedTriggers() {
+        return this.withSqlQuerier(async (querier) => {
+            const byTable = new Map();
+            for (const row of await querier.all(this.triggersQuery())) {
+                const name = String(row['name']);
+                if (!isOwnedName(name)) {
+                    continue;
+                }
+                const table = String(row['table']);
+                const statements = [row['requires'], row['definition']].filter(Boolean).map((sql) => String(sql));
+                byTable.set(table, (byTable.get(table) ?? new Map()).set(name, statements));
+            }
+            return byTable;
+        });
+    }
     async tableExists(tableName) {
         return this.withSqlQuerier((querier) => this.tableExistsInternal(createTableRowReader(querier), tableName));
     }

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

@@ -1,6 +1,6 @@
 import type { IndexFacet } from '../../schema/indexDifferences.js';
 import { SchemaAST } from '../../schema/schemaAST.js';
-import { type QuerierPool, type SchemaIntrospector, type TableSchema } from '../../type/index.js';
+import { type InstalledTriggers, type QuerierPool, type SchemaIntrospector, type TableSchema } from '../../type/index.js';
 /**
  * MongoDB schema introspector.
  * MongoDB doesn't have a fixed schema, so this primarily focuses on collections and indexes.
@@ -10,6 +10,8 @@ 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. */
+    ownedTriggers(): Promise<Map<string, InstalledTriggers>>;
     introspect(tables?: readonly string[]): Promise<SchemaAST>;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     /** Collections only, the way a SQL engine lists its base tables: no view, nor the `system.views` behind one. */

package/dist/migrate/introspection/mongoIntrospector.js

@@ -14,6 +14,10 @@ export class MongoSchemaIntrospector {
     constructor(pool) {
         this.pool = pool;
     }
+    /** MongoDB has no triggers, so none is ever installed. */
+    async ownedTriggers() {
+        return new Map();
+    }
     async introspect(tables) {
         const tableNames = tables ?? (await this.getTableNames());
         const ast = new SchemaAST();

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

@@ -10,6 +10,7 @@ import { AbstractSqlSchemaIntrospector, type JoinedForeignKeyRow, type TableRowR
  */
 export declare class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     protected readonly defaultSchemaExpr = "SCHEMA_NAME()";
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: {

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -9,6 +9,14 @@ import { AbstractSqlSchemaIntrospector, } from './abstractSqlSchemaIntrospector.
  */
 export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     defaultSchemaExpr = 'SCHEMA_NAME()';
+    triggersQuery() {
+        return /*sql*/ `
+      SELECT OBJECT_NAME(t.parent_id) AS [table], t.name AS name, m.definition AS definition
+      FROM sys.triggers t
+      JOIN sys.sql_modules m ON m.object_id = t.object_id
+      WHERE t.parent_id <> 0 AND OBJECT_SCHEMA_NAME(t.parent_id) = ${this.schemaExpr}
+    `;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT TABLE_NAME as table_name

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

@@ -6,6 +6,7 @@ import { AbstractSqlSchemaIntrospector, type JoinedForeignKeyRow, type TableRowR
  */
 export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     protected readonly defaultSchemaExpr = "DATABASE()";
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: {

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -7,6 +7,15 @@ import { AbstractSqlSchemaIntrospector, } from './abstractSqlSchemaIntrospector.
 export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     // A MySQL "schema" is a database, so the connection's own is what `DATABASE()` reports.
     defaultSchemaExpr = 'DATABASE()';
+    triggersQuery() {
+        return /*sql*/ `
+      SELECT EVENT_OBJECT_TABLE AS \`table\`, TRIGGER_NAME AS name,
+        CONCAT('CREATE TRIGGER \`', TRIGGER_SCHEMA, '\`.\`', TRIGGER_NAME, '\` ', ACTION_TIMING, ' ', EVENT_MANIPULATION,
+          ' ON \`', EVENT_OBJECT_SCHEMA, '\`.\`', EVENT_OBJECT_TABLE, '\` FOR EACH ROW ', ACTION_STATEMENT) AS definition
+      FROM information_schema.TRIGGERS
+      WHERE TRIGGER_SCHEMA = ${this.schemaExpr}
+    `;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT TABLE_NAME as table_name

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

@@ -11,6 +11,7 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
      * database reprints in its own words, so they are not comparable and are not claimed here.
      */
     readonly indexFacets: ReadonlySet<IndexFacet>;
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: RawRow[]): boolean;

package/dist/migrate/introspection/postgresIntrospector.js

@@ -16,6 +16,16 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         'accessMethod',
         'include',
     ]);
+    triggersQuery() {
+        return /*sql*/ `
+      SELECT c.relname AS "table", t.tgname AS name, pg_get_triggerdef(t.oid) AS definition,
+        pg_get_functiondef(t.tgfoid) AS requires
+      FROM pg_trigger t
+      JOIN pg_class c ON c.oid = t.tgrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE NOT t.tgisinternal AND n.nspname = ${this.schemaExpr}
+    `;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT table_name

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

@@ -8,6 +8,7 @@ export declare class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospec
     /** Whether an index is libSQL's vector index, where the engine has one; elsewhere a declared one is built plain. */
     readonly indexFacets: ReadonlySet<IndexFacet>;
     /** Not SQLite's own tables, nor the ones libSQL keeps a vector index in: its metadata and `<index>_shadow`. */
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: SqliteCountRow[]): boolean;

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -7,6 +7,9 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     /** Whether an index is libSQL's vector index, where the engine has one; elsewhere a declared one is built plain. */
     indexFacets = new Set(this.dialect.hasVectorIndex() ? ['vector'] : []);
     /** Not SQLite's own tables, nor the ones libSQL keeps a vector index in: its metadata and `<index>_shadow`. */
+    triggersQuery() {
+        return /*sql*/ `SELECT tbl_name AS \`table\`, name, sql AS definition FROM sqlite_master WHERE type = 'trigger'`;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT name