@mikro-orm/oracledb 7.3.0-dev.12 → 7.3.0-dev.14

package/OracleSchemaGenerator.d.ts

@@ -8,6 +8,8 @@ export declare class OracleSchemaGenerator extends SchemaGenerator {
     /** Tracks whether the main user has been granted DBA (or equivalent) privileges. */
     private hasDbaGrant;
     static register(orm: MikroORM): void;
+    /** Ends the batch after a PL/SQL block (e.g. `create trigger ... end;`), so the `;\n` statement split keeps its closing `;`. */
+    protected startsBatch(_statement: string, previous: string): boolean;
     /**
      * creates new database and connects to it
      */

package/OracleSchemaGenerator.js

@@ -6,6 +6,10 @@ export class OracleSchemaGenerator extends SchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new OracleSchemaGenerator(orm.em));
     }
+    /** Ends the batch after a PL/SQL block (e.g. `create trigger ... end;`), so the `;\n` statement split keeps its closing `;`. */
+    startsBatch(_statement, previous) {
+        return /\bend;$/i.test(previous);
+    }
     /**
      * creates new database and connects to it
      */

package/OracleSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type Transaction, type Type, type SqlRoutineDef } from '@mikro-orm/sql';
+import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type Transaction, type Type, type SqlRoutineDef, type SqlTriggerDef } from '@mikro-orm/sql';
 /** Schema introspection helper for Oracle Database. */
 export declare class OracleSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: Record<string, string[]>;
@@ -27,6 +27,7 @@ export declare class OracleSchemaHelper extends SchemaHelper {
     getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
     getDatabaseCollation(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string | undefined>;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
+    getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<SqlTriggerDef[]>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getCreateNamespaceSQL(name: string): string;
@@ -49,6 +50,11 @@ export declare class OracleSchemaHelper extends SchemaHelper {
     dropForeignKey(tableName: string, constraintName: string): string;
     dropViewIfExists(name: string, schema?: string): string;
     dropTableIfExists(name: string, schema?: string): string;
+    /** Oracle supports multiple events and both row and statement level in one trigger, but `instead of` works only on views and there is no `truncate` DML event. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Uses `IF EXISTS` (Oracle 23c+), same as the other drop statements. */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    private getTriggerName;
     getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     appendComments(table: DatabaseTable): string[];
     inferLengthFromColumnType(type: string): number | undefined;

package/OracleSchemaHelper.js

@@ -390,6 +390,7 @@ export class OracleSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tablesBySchema, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const triggers = await this.getAllTriggers(connection, tablesBySchema, ctx);
         const dbCollation = await this.getDatabaseCollation(connection, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
@@ -398,7 +399,34 @@ export class OracleSchemaHelper extends SchemaHelper {
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             const enums = this.getEnumDefinitions(checks[key] ?? []);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
+        }
+    }
+    async getAllTriggers(connection, tablesBySchemas, ctx) {
+        // `trigger_body` is a LONG column, which node-oracledb fetches as a string
+        const sql = `select trigger_name, table_owner as schema_name, table_name, trigger_type, triggering_event, when_clause, trigger_body
+      from all_triggers
+      where base_object_type = 'TABLE'
+      and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')}) and table_owner = ${this.platform.quoteValue(schema)})`).join(' or ')})
+      order by table_owner, table_name, trigger_name`;
+        const allTriggers = await connection.execute(sql, [], 'all', ctx);
+        const ret = {};
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            ret[key] ??= [];
+            ret[key].push({
+                name: row.trigger_name,
+                // e.g. `BEFORE EACH ROW`, `AFTER STATEMENT`
+                timing: row.trigger_type.replace(/\s+(each row|statement)$/i, '').toLowerCase(),
+                events: row.triggering_event.toLowerCase().split(/\s+or\s+/),
+                forEach: /\beach row$/i.test(row.trigger_type) ? 'row' : 'statement',
+                body: this.stripRoutineBody(row.trigger_body),
+                when: row.when_clause?.trim() || undefined,
+            });
         }
+        return ret;
     }
     getPreAlterTable(tableDiff, safe) {
         const ret = [];
@@ -626,6 +654,34 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         return `drop table if exists ${this.quote(schema, name)} cascade constraint`;
     }
+    /** Oracle supports multiple events and both row and statement level in one trigger, but `instead of` works only on views and there is no `truncate` DML event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        if (trigger.timing === 'instead of') {
+            throw new Error(`Oracle supports INSTEAD OF triggers only on views. Use BEFORE or AFTER for trigger "${trigger.name}".`);
+        }
+        if (trigger.events.includes('truncate')) {
+            throw new Error(`Oracle does not support TRUNCATE triggers. Remove the TRUNCATE event from trigger "${trigger.name}".`);
+        }
+        if (trigger.when && trigger.forEach === 'statement') {
+            throw new Error(`Oracle supports WHEN conditions only on row-level triggers (trigger "${trigger.name}").`);
+        }
+        const timing = trigger.timing.toUpperCase();
+        const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
+        const forEach = trigger.forEach === 'statement' ? '' : ' for each row';
+        const when = trigger.when ? ` when (${trigger.when})` : '';
+        return `create or replace trigger ${this.getTriggerName(table, trigger)} ${timing} ${events} on ${table.getQuotedName()}${forEach}${when} begin ${this.normalizeTriggerBody(trigger.body)} end;`;
+    }
+    /** Uses `IF EXISTS` (Oracle 23c+), same as the other drop statements. */
+    dropTrigger(table, trigger) {
+        return `drop trigger if exists ${this.getTriggerName(table, trigger)}`;
+    }
+    getTriggerName(table, trigger) {
+        const schema = table.schema === this.platform.getDefaultSchemaName() ? undefined : table.schema;
+        return this.quote(schema, trigger.name);
+    }
     getAddColumnsSQL(table, columns) {
         const adds = columns
             .map(column => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/oracledb",
-  "version": "7.3.0-dev.12",
+  "version": "7.3.0-dev.14",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite, MSSQL and Oracle databases.",
   "keywords": [
     "data-mapper",
@@ -42,7 +42,7 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.3.0-dev.12",
+    "@mikro-orm/sql": "7.3.0-dev.14",
     "kysely": "0.29.6",
     "oracledb": "7.0.1"
   },
@@ -50,7 +50,7 @@
     "@mikro-orm/core": "^7.2.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.12"
+    "@mikro-orm/core": "7.3.0-dev.14"
   },
   "engines": {
     "node": ">= 22.17.0"