@mikro-orm/sql 7.1.0-dev.7 → 7.1.0-dev.8

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary, type Transaction, type Type } from '@mikro-orm/core';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
@@ -32,6 +32,9 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     protected appendMySqlIndexSuffix(sql: string, index: IndexDef): string;
     getAllColumns(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    getAllTriggers(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<SqlTriggerDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -64,11 +64,15 @@ export class MySqlSchemaHelper extends SchemaHelper {
         const checks = await this.getAllChecks(connection, tables, ctx);
         const fks = await this.getAllForeignKeys(connection, tables, ctx);
         const enums = await this.getAllEnumDefinitions(connection, tables, ctx);
+        const triggers = await this.getAllTriggers(connection, tables);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
         }
     }
     async getAllIndexes(connection, tables, ctx) {
@@ -264,6 +268,85 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        /* v8 ignore next 3 */
+        if (trigger.timing === 'instead of') {
+            throw new Error(`MySQL does not support INSTEAD OF triggers. Use BEFORE or AFTER for trigger "${trigger.name}".`);
+        }
+        /* v8 ignore next 5 */
+        if (trigger.forEach === 'statement') {
+            throw new Error(`MySQL does not support FOR EACH STATEMENT triggers. Use FOR EACH ROW for trigger "${trigger.name}".`);
+        }
+        const timing = trigger.timing.toUpperCase();
+        const ret = [];
+        for (const event of trigger.events) {
+            const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ROW begin ${trigger.body}; end`);
+        }
+        return ret.join(';\n');
+    }
+    async getAllTriggers(connection, tables) {
+        const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+        const sql = `select trigger_name as trigger_name, event_object_table as table_name, nullif(event_object_schema, schema()) as schema_name,
+      event_manipulation as event, action_timing as timing,
+      action_orientation as for_each, action_statement as body
+    from information_schema.triggers
+    where event_object_schema = database()
+      and event_object_table in (${names})
+    order by trigger_name, event_manipulation`;
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        // First pass: collect all raw trigger names per table to detect multi-event groups.
+        // A base name is only used for grouping if multiple triggers share it (e.g. trg_multi_insert + trg_multi_update).
+        const namesByTable = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            namesByTable.set(key, [...(namesByTable.get(key) ?? []), row.trigger_name]);
+        }
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const eventLower = row.event.toLowerCase();
+            const tableNames = namesByTable.get(key) ?? [];
+            // Only strip event suffix when another trigger with the same base exists for this table
+            const candidateBase = row.trigger_name.endsWith(`_${eventLower}`)
+                ? row.trigger_name.slice(0, -eventLower.length - 1)
+                : null;
+            const baseName = candidateBase && tableNames.some(n => n !== row.trigger_name && n.startsWith(`${candidateBase}_`))
+                ? candidateBase
+                : row.trigger_name;
+            const dedupeKey = `${key}:${baseName}`;
+            if (triggerMap.has(dedupeKey)) {
+                const existing = triggerMap.get(dedupeKey);
+                const event = eventLower;
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // Strip BEGIN/END wrapper from MySQL action_statement
+            let body = row.body ?? '';
+            const beginEndMatch = /^\s*begin\s+([\s\S]*)\s*end\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: baseName,
+                timing: row.timing.toLowerCase(),
+                events: [eventLower],
+                forEach: (row.for_each ?? 'row').toLowerCase(),
+                body,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
     async getAllForeignKeys(connection, tables, ctx) {
         const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
         from information_schema.key_column_usage k

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import { type Dictionary, type Transaction } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -49,6 +49,13 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
         items: string[];
     }>, ctx?: Transaction): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    private getSchemaQualifiedTriggerFnName;
+    getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<SqlTriggerDef[]>>;
+    private getTriggersSQL;
     getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[], ctx?: Transaction): Promise<Dictionary<{
         name: string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -118,6 +118,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tables, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const triggers = await this.getAllTriggers(connection, tablesBySchema);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
@@ -126,6 +127,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (columns[key]) {
                 table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
             }
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
         }
     }
     async getAllIndexes(connection, tables, ctx) {
@@ -375,6 +379,95 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const when = trigger.when ? `\n  when (${trigger.when})` : '';
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnSql = `create or replace function ${fnName}() returns trigger as $$ begin ${trigger.body}; end; $$ language plpgsql`;
+        const triggerSql = `create trigger ${triggerName} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} execute function ${fnName}()`;
+        return `${fnSql};\n${triggerSql}`;
+    }
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table, trigger) {
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
+    }
+    getSchemaQualifiedTriggerFnName(table, trigger) {
+        const rawName = `${table.name}_${trigger.name}_fn`;
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (table.schema && table.schema !== defaultSchema) {
+            return `${this.platform.quoteIdentifier(table.schema)}.${this.platform.quoteIdentifier(rawName)}`;
+        }
+        return this.platform.quoteIdentifier(rawName);
+    }
+    async getAllTriggers(connection, tablesBySchemas) {
+        const sql = this.getTriggersSQL(tablesBySchemas);
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const dedupeKey = `${key}:${row.trigger_name}`;
+            if (triggerMap.has(dedupeKey)) {
+                // Same trigger with multiple events — merge events
+                const existing = triggerMap.get(dedupeKey);
+                const event = row.event.toLowerCase();
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // prosrc includes the full function body between $$ delimiters (e.g. " begin RETURN NEW; end;")
+            // Strip the begin/end wrapper to get just the trigger body for round-trip comparison
+            let body = (row.function_body ?? '').trim();
+            const beginEndMatch = /^\s*begin\s+([\s\S]*?)\s*end;?\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: row.trigger_name,
+                timing: row.timing.toLowerCase(),
+                events: [row.event.toLowerCase()],
+                forEach: row.for_each.toLowerCase(),
+                body,
+                when: row.when_clause ?? undefined,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
+    getTriggersSQL(tablesBySchemas) {
+        const conditions = [];
+        for (const [schema, tables] of tablesBySchemas) {
+            const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+            const schemaName = this.platform.quoteValue(schema ?? this.platform.getDefaultSchemaName());
+            conditions.push(`(t.event_object_schema = ${schemaName} and t.event_object_table in (${names}))`);
+        }
+        // Function lookup uses the '{table}_{trigger}_fn' convention from createTrigger().
+        // External triggers with different function names will have NULL body;
+        // use the `expression` escape hatch for those.
+        return `select t.trigger_name, t.event_object_schema as schema_name, t.event_object_table as table_name,
+      t.event_manipulation as event, t.action_timing as timing,
+      t.action_orientation as for_each,
+      t.action_condition as when_clause,
+      pg_get_functiondef(p.oid) as function_def,
+      p.prosrc as function_body
+    from information_schema.triggers t
+    left join pg_namespace n on n.nspname = t.event_object_schema
+    left join pg_proc p on p.proname = t.event_object_table || '_' || t.trigger_name || '_fn' and p.pronamespace = n.oid
+    where (${conditions.join(' or ')})
+    order by t.trigger_name, t.event_manipulation`;
+    }
     async getAllForeignKeys(connection, tablesBySchemas, ctx) {
         const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
       cls2.relname referenced_table_name, a.attname column_name, af.attname referenced_column_name, conname constraint_name,

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import { type Connection, type Transaction } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
-import type { Column, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { Column, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 export declare class SqliteSchemaHelper extends SchemaHelper {
@@ -64,5 +64,9 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      */
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     alterTable(diff: TableDifference, safe?: boolean): string[];
+    /** Generates SQL to create SQLite triggers. SQLite requires one trigger per event. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    private getTableTriggers;
+    private parseTriggerDDL;
     private getAlterTempTableSQL;
 }

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -101,7 +101,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
             const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema, ctx);
             const fks = await this.getForeignKeys(connection, table.name, table.schema, ctx);
             const enums = await this.getEnumDefinitions(connection, table.name, table.schema, ctx);
+            const triggers = await this.getTableTriggers(connection, table.name);
             table.init(cols, indexes, checks, pks, fks, enums);
+            table.setTriggers(triggers);
         }
     }
     createTable(table, alter) {
@@ -140,6 +142,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
         for (const index of table.getIndexes()) {
             this.append(ret, this.createIndex(index, table));
         }
+        for (const trigger of table.getTriggers()) {
+            this.append(ret, this.createTrigger(table, trigger));
+        }
         return ret;
     }
     createTableColumn(column, table, _changedProperties) {
@@ -501,8 +506,102 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
             }
         }
+        for (const trigger of Object.values(diff.removedTriggers)) {
+            this.append(ret, this.dropTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            this.append(ret, this.dropTrigger(diff.toTable, trigger));
+            this.append(ret, this.createTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.addedTriggers)) {
+            this.append(ret, this.createTrigger(diff.toTable, trigger));
+        }
         return ret;
     }
+    /** Generates SQL to create SQLite triggers. SQLite requires one trigger per event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const ret = [];
+        for (const event of trigger.events) {
+            const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
+            const when = trigger.when ? `\n  when ${trigger.when}` : '';
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`);
+        }
+        return ret.join(';\n');
+    }
+    async getTableTriggers(connection, tableName) {
+        const rows = await connection.execute(`select name, sql from sqlite_master where type = 'trigger' and tbl_name = ?`, [tableName]);
+        // First pass: parse all triggers and collect names to detect multi-event groups
+        const parsedRows = [];
+        for (const row of rows) {
+            /* v8 ignore next 3 */
+            if (!row.sql) {
+                continue;
+            }
+            const parsed = this.parseTriggerDDL(row.sql, row.name);
+            if (parsed) {
+                parsedRows.push({ name: row.name, parsed });
+            }
+        }
+        const allNames = parsedRows.map(r => r.name);
+        const triggers = [];
+        const triggerMap = new Map();
+        for (const { name, parsed } of parsedRows) {
+            // Only strip event suffix when another trigger with the same base exists
+            const eventLower = parsed.events[0];
+            const candidateBase = name.endsWith(`_${eventLower}`) ? name.slice(0, -eventLower.length - 1) : null;
+            const baseName = candidateBase && allNames.some(n => n !== name && n.startsWith(`${candidateBase}_`)) ? candidateBase : name;
+            if (triggerMap.has(baseName)) {
+                const existing = triggerMap.get(baseName);
+                if (!existing.events.includes(parsed.events[0])) {
+                    existing.events.push(parsed.events[0]);
+                }
+                continue;
+            }
+            const trigger = { ...parsed, name: baseName };
+            triggers.push(trigger);
+            triggerMap.set(baseName, trigger);
+        }
+        return triggers;
+    }
+    parseTriggerDDL(sql, name) {
+        // Split at the last top-level BEGIN to separate header from body,
+        // so that a WHEN clause containing the word "begin" in a string literal doesn't confuse parsing.
+        const beginIdx = sql.search(/\bbegin\b(?=[^]*$)/i);
+        /* v8 ignore next 3 */
+        if (beginIdx === -1) {
+            return null;
+        }
+        const header = sql.slice(0, beginIdx);
+        const bodyPart = sql.slice(beginIdx);
+        const headerMatch = /create\s+trigger\s+["`]?\w+["`]?\s+(before|after|instead\s+of)\s+(insert|update|delete)\s+on\s+["`]?\w+["`]?\s*(?:for\s+each\s+(row|statement))?\s*(?:when\s+([\s\S]*?))?\s*$/i.exec(header);
+        /* v8 ignore next 3 */
+        if (!headerMatch) {
+            return null;
+        }
+        const bodyMatch = /^begin\s+([\s\S]*?)\s*end/i.exec(bodyPart);
+        /* v8 ignore next 3 */
+        if (!bodyMatch) {
+            return null;
+        }
+        const timing = headerMatch[1].toLowerCase();
+        const event = headerMatch[2].toLowerCase();
+        const forEach = (headerMatch[3]?.toLowerCase() ?? 'row');
+        const when = headerMatch[4]?.trim() || undefined;
+        const body = bodyMatch[1].trim().replace(/;\s*$/, '');
+        return {
+            name,
+            timing,
+            events: [event],
+            forEach,
+            body,
+            when,
+        };
+    }
     getAlterTempTableSQL(changedTable) {
         const tempName = `${changedTable.toTable.name}__temp_alter`;
         const quotedName = this.quote(changedTable.toTable.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.7",
+  "version": "7.1.0-dev.8",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.11"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.7"
+    "@mikro-orm/core": "7.1.0-dev.8"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseSchema.js

@@ -220,6 +220,20 @@ export class DatabaseSchema {
                     columnName,
                 });
             }
+            for (const trigger of meta.triggers) {
+                const body = isRaw(trigger.body)
+                    ? platform.formatQuery(trigger.body.sql, trigger.body.params)
+                    : trigger.body;
+                table.addTrigger({
+                    name: trigger.name,
+                    timing: trigger.timing,
+                    events: trigger.events,
+                    forEach: trigger.forEach ?? 'row',
+                    body: body ?? '',
+                    when: trigger.when,
+                    expression: trigger.expression,
+                });
+            }
         }
         return schema;
     }

package/schema/DatabaseTable.d.ts

@@ -1,6 +1,6 @@
 import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type IndexCallback, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper.js';
-import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, SqlTriggerDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -22,11 +22,14 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
+    getTriggers(): SqlTriggerDef[];
     /** @internal */
     setIndexes(indexes: IndexDef[]): void;
     /** @internal */
     setChecks(checks: CheckDef[]): void;
     /** @internal */
+    setTriggers(triggers: SqlTriggerDef[]): void;
+    /** @internal */
     setForeignKeys(fks: Dictionary<ForeignKey>): void;
     init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
@@ -47,6 +50,8 @@ export declare class DatabaseTable {
     hasIndex(indexName: string): boolean;
     getCheck(checkName: string): CheckDef | undefined;
     hasCheck(checkName: string): boolean;
+    getTrigger(triggerName: string): SqlTriggerDef | undefined;
+    hasTrigger(triggerName: string): boolean;
     getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;
     private getForeignKeyDeclaration;
@@ -78,5 +83,6 @@ export declare class DatabaseTable {
         clustered?: boolean;
     }, type: 'index' | 'unique' | 'primary'): void;
     addCheck(check: CheckDef): void;
+    addTrigger(trigger: SqlTriggerDef): void;
     toJSON(): Dictionary;
 }

package/schema/DatabaseTable.js

@@ -8,6 +8,7 @@ export class DatabaseTable {
     #columns = {};
     #indexes = [];
     #checks = [];
+    #triggers = [];
     #foreignKeys = {};
     #platform;
     nativeEnums = {}; // for postgres
@@ -35,6 +36,9 @@ export class DatabaseTable {
     getChecks() {
         return this.#checks;
     }
+    getTriggers() {
+        return this.#triggers;
+    }
     /** @internal */
     setIndexes(indexes) {
         this.#indexes = indexes;
@@ -44,6 +48,10 @@ export class DatabaseTable {
         this.#checks = checks;
     }
     /** @internal */
+    setTriggers(triggers) {
+        this.#triggers = triggers;
+    }
+    /** @internal */
     setForeignKeys(fks) {
         this.#foreignKeys = fks;
     }
@@ -598,6 +606,12 @@ export class DatabaseTable {
     hasCheck(checkName) {
         return !!this.getCheck(checkName);
     }
+    getTrigger(triggerName) {
+        return this.#triggers.find(t => t.name === triggerName);
+    }
+    hasTrigger(triggerName) {
+        return !!this.getTrigger(triggerName);
+    }
     getPrimaryKey() {
         return this.#indexes.find(i => i.primary);
     }
@@ -885,6 +899,9 @@ export class DatabaseTable {
     addCheck(check) {
         this.#checks.push(check);
     }
+    addTrigger(trigger) {
+        this.#triggers.push(trigger);
+    }
     toJSON() {
         const columns = this.#columns;
         const columnsMapped = Utils.keys(columns).reduce((o, col) => {
@@ -929,6 +946,7 @@ export class DatabaseTable {
             columns: columnsMapped,
             indexes: this.#indexes,
             checks: this.#checks,
+            triggers: this.#triggers,
             foreignKeys: this.#foreignKeys,
             nativeEnums: this.nativeEnums,
             comment: this.comment,

package/schema/SchemaComparator.d.ts

@@ -69,6 +69,7 @@ export declare class SchemaComparator {
      * @see https://github.com/mikro-orm/mikro-orm/issues/7308
      */
     private diffViewExpression;
+    private diffTrigger;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;

package/schema/SchemaComparator.js

@@ -176,14 +176,17 @@ export class SchemaComparator {
             addedForeignKeys: {},
             addedIndexes: {},
             addedChecks: {},
+            addedTriggers: {},
             changedColumns: {},
             changedForeignKeys: {},
             changedIndexes: {},
             changedChecks: {},
+            changedTriggers: {},
             removedColumns: {},
             removedForeignKeys: {},
             removedIndexes: {},
             removedChecks: {},
+            removedTriggers: {},
             renamedColumns: {},
             renamedIndexes: {},
             fromTable,
@@ -309,6 +312,33 @@ export class SchemaComparator {
             tableDifferences.changedChecks[check.name] = toTableCheck;
             changes++;
         }
+        const fromTableTriggers = fromTable.getTriggers();
+        const toTableTriggers = toTable.getTriggers();
+        for (const trigger of toTableTriggers) {
+            if (fromTable.hasTrigger(trigger.name)) {
+                continue;
+            }
+            tableDifferences.addedTriggers[trigger.name] = trigger;
+            this.log(`trigger ${trigger.name} added to table ${tableDifferences.name}`, { trigger });
+            changes++;
+        }
+        for (const trigger of fromTableTriggers) {
+            if (!toTable.hasTrigger(trigger.name)) {
+                tableDifferences.removedTriggers[trigger.name] = trigger;
+                this.log(`trigger ${trigger.name} removed from table ${tableDifferences.name}`);
+                changes++;
+                continue;
+            }
+            const toTableTrigger = toTable.getTrigger(trigger.name);
+            if (this.diffTrigger(trigger, toTableTrigger)) {
+                this.log(`trigger ${trigger.name} changed in table ${tableDifferences.name}`, {
+                    fromTableTrigger: trigger,
+                    toTableTrigger,
+                });
+                tableDifferences.changedTriggers[trigger.name] = toTableTrigger;
+                changes++;
+            }
+        }
         const fromForeignKeys = { ...fromTable.getForeignKeys() };
         const toForeignKeys = { ...toTable.getForeignKeys() };
         for (const fromConstraint of Object.values(fromForeignKeys)) {
@@ -714,6 +744,30 @@ export class SchemaComparator {
         }
         return true;
     }
+    diffTrigger(from, to) {
+        // Raw DDL expression cannot be meaningfully compared to introspected
+        // trigger metadata, so skip diffing when the metadata side uses it.
+        if (to.expression) {
+            // Both sides have expression — compare the raw DDL directly
+            if (from.expression) {
+                return this.diffExpression(from.expression, to.expression);
+            }
+            // Only metadata side has expression — the raw DDL cannot be compared to
+            // introspected metadata. Changes to the expression value won't be detected;
+            // drop and recreate the trigger manually to apply expression changes.
+            return false;
+        }
+        if (from.timing !== to.timing || from.forEach !== to.forEach) {
+            return true;
+        }
+        if ([...from.events].sort().join(',') !== [...to.events].sort().join(',')) {
+            return true;
+        }
+        if ((from.when ?? '') !== (to.when ?? '')) {
+            return true;
+        }
+        return this.diffExpression(from.body, to.body);
+    }
     parseJsonDefault(defaultValue) {
         /* v8 ignore next */
         if (!defaultValue) {

package/schema/SchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
@@ -84,6 +84,16 @@ export declare abstract class SchemaHelper {
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     createCheck(table: DatabaseTable, check: CheckDef): string;
+    /**
+     * Generates SQL to create a database trigger on a table.
+     * Override in driver-specific helpers for custom DDL (e.g., PostgreSQL function wrapping).
+     */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /**
+     * Generates SQL to drop a database trigger from a table.
+     * Override in driver-specific helpers for custom DDL.
+     */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     /** @internal */
     getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;

package/schema/SchemaHelper.js

@@ -204,6 +204,12 @@ export class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.dropConstraint(diff.name, check.name));
         }
+        for (const trigger of Object.values(diff.removedTriggers)) {
+            ret.push(this.dropTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            ret.push(this.dropTrigger(diff.toTable, trigger));
+        }
         /* v8 ignore next */
         if (!safe && Object.values(diff.removedColumns).length > 0) {
             ret.push(this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
@@ -263,6 +269,12 @@ export class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.createCheck(diff.toTable, check));
         }
+        for (const trigger of Object.values(diff.addedTriggers)) {
+            ret.push(this.createTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            ret.push(this.createTrigger(diff.toTable, trigger));
+        }
         if ('changedComment' in diff) {
             ret.push(this.alterTableComment(diff.toTable, diff.changedComment));
         }
@@ -521,6 +533,9 @@ export class SchemaHelper {
             for (const check of table.getChecks()) {
                 this.append(ret, this.createCheck(table, check));
             }
+            for (const trigger of table.getTriggers()) {
+                this.append(ret, this.createTrigger(table, trigger));
+            }
         }
         return ret;
     }
@@ -600,6 +615,33 @@ export class SchemaHelper {
     createCheck(table, check) {
         return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
     }
+    /**
+     * Generates SQL to create a database trigger on a table.
+     * Override in driver-specific helpers for custom DDL (e.g., PostgreSQL function wrapping).
+     */
+    /* v8 ignore next 10 */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const when = trigger.when ? ` when (${trigger.when})` : '';
+        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`;
+    }
+    /**
+     * Generates SQL to drop a database trigger from a table.
+     * Override in driver-specific helpers for custom DDL.
+     */
+    dropTrigger(table, trigger) {
+        if (trigger.events.length > 1) {
+            return trigger.events
+                .map(event => `drop trigger if exists ${this.quote(`${trigger.name}_${event}`)}`)
+                .join(';\n');
+        }
+        return `drop trigger if exists ${this.quote(trigger.name)}`;
+    }
     /** @internal */
     getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {

package/schema/SqlSchemaGenerator.js

@@ -300,11 +300,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 for (const check of newTable.getChecks()) {
                     this.append(sql, this.helper.createCheck(newTable, check));
                 }
+                for (const trigger of newTable.getTriggers()) {
+                    this.append(sql, this.helper.createTrigger(newTable, trigger));
+                }
                 this.append(ret, sql, true);
             }
         }
         if (options.dropTables && !options.safe) {
             for (const table of Object.values(schemaDiff.removedTables)) {
+                // Drop triggers before the table so driver-specific cleanup runs (e.g. PostgreSQL function removal)
+                for (const trigger of table.getTriggers()) {
+                    this.append(ret, this.helper.dropTrigger(table, trigger));
+                }
                 this.append(ret, this.helper.dropTableIfExists(table.name, table.schema));
             }
             if (Utils.hasObjectKeys(schemaDiff.removedTables)) {

package/typings.d.ts

@@ -108,6 +108,16 @@ export interface CheckDef<T = unknown> {
     definition?: string;
     columnName?: string;
 }
+/** Resolved trigger definition for schema operations (all callbacks resolved to strings). */
+export interface SqlTriggerDef {
+    name: string;
+    timing: 'before' | 'after' | 'instead of';
+    events: ('insert' | 'update' | 'delete' | 'truncate')[];
+    forEach: 'row' | 'statement';
+    body: string;
+    when?: string;
+    expression?: string;
+}
 export interface ColumnDifference {
     oldColumnName: string;
     column: Column;
@@ -130,6 +140,9 @@ export interface TableDifference {
     addedChecks: Dictionary<CheckDef>;
     changedChecks: Dictionary<CheckDef>;
     removedChecks: Dictionary<CheckDef>;
+    addedTriggers: Dictionary<SqlTriggerDef>;
+    changedTriggers: Dictionary<SqlTriggerDef>;
+    removedTriggers: Dictionary<SqlTriggerDef>;
     addedForeignKeys: Dictionary<ForeignKey>;
     changedForeignKeys: Dictionary<ForeignKey>;
     removedForeignKeys: Dictionary<ForeignKey>;