@mikro-orm/oracledb 7.0.7-dev.9 → 7.0.8-dev.0

package/OracleSchemaHelper.d.ts

@@ -1,25 +1,25 @@
-import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type Type } 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 } from '@mikro-orm/sql';
 /** Schema introspection helper for Oracle Database. */
 export declare class OracleSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: Record<string, string[]>;
     getDatabaseExistsSQL(name: string): string;
-    getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
+    getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
     getListTablesSQL(schemaName?: string): string;
     getListViewsSQL(): string;
-    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
-    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
+    getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     private getIgnoredNamespacesConditionSQL;
     getDefaultEmptyString(): string;
     normalizeDefaultValue(defaultValue: string, length: number, defaultValues?: Dictionary<string[]>, stripQuotes?: boolean): string | number;
-    getAllColumns(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Column[]>>;
-    getAllIndexes(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<IndexDef[]>>;
+    getAllColumns(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Column[]>>;
+    getAllIndexes(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
     createForeignKey(table: DatabaseTable, foreignKey: ForeignKey, alterTable?: boolean, inline?: boolean): string;
-    getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     private getEnumDefinitions;
     private getChecksSQL;
-    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<CheckDef[]>>;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
+    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getCreateNamespaceSQL(name: string): string;

package/OracleSchemaHelper.js

@@ -10,9 +10,9 @@ export class OracleSchemaHelper extends SchemaHelper {
     getDatabaseExistsSQL(name) {
         return `select 1 from all_users where username = ${this.platform.quoteValue(name)}`;
     }
-    async getAllTables(connection, schemas) {
+    async getAllTables(connection, schemas, ctx) {
         if (!schemas || schemas.length === 0) {
-            return connection.execute(this.getListTablesSQL());
+            return connection.execute(this.getListTablesSQL(), [], 'all', ctx);
         }
         const conditions = schemas.map(s => `at.owner = ${this.platform.quoteValue(s)}`).join(' or ');
         const sql = `select at.table_name, at.owner as schema_name, atc.comments as table_comment
@@ -20,7 +20,7 @@ export class OracleSchemaHelper extends SchemaHelper {
       left join all_tab_comments atc on at.owner = atc.owner and at.table_name = atc.table_name
       where (${conditions})
       order by schema_name, at.table_name`;
-        return connection.execute(sql);
+        return connection.execute(sql, [], 'all', ctx);
     }
     getListTablesSQL(schemaName) {
         /* v8 ignore next: nullish coalescing chain */
@@ -47,8 +47,8 @@ export class OracleSchemaHelper extends SchemaHelper {
       where owner = ${this.platform.quoteValue(schema)}
       order by view_name`;
     }
-    async loadViews(schema, connection) {
-        const views = await connection.execute(this.getListViewsSQL());
+    async loadViews(schema, connection, schemaName, ctx) {
+        const views = await connection.execute(this.getListViewsSQL(), [], 'all', ctx);
         for (const view of views) {
             const definition = view.view_definition?.trim();
             /* v8 ignore next 4: empty view definition edge case */
@@ -58,9 +58,9 @@ export class OracleSchemaHelper extends SchemaHelper {
             }
         }
     }
-    async getNamespaces(connection) {
+    async getNamespaces(connection, ctx) {
         const sql = `select username as schema_name from all_users where ${this.getIgnoredNamespacesConditionSQL()} order by username`;
-        const res = await connection.execute(sql);
+        const res = await connection.execute(sql, [], 'all', ctx);
         return res.map(row => row.schema_name);
     }
     getIgnoredNamespacesConditionSQL(column = 'username') {
@@ -104,7 +104,7 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         return super.normalizeDefaultValue(defaultValue, length, OracleSchemaHelper.DEFAULT_VALUES);
     }
-    async getAllColumns(connection, tablesBySchemas) {
+    async getAllColumns(connection, tablesBySchemas, ctx) {
         const sql = `select
       atc.owner as schema_name,
       atc.table_name as table_name,
@@ -127,7 +127,7 @@ export class OracleSchemaHelper extends SchemaHelper {
       where atc.hidden_column = 'NO'
       and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(atc.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')}) and atc.owner = ${this.platform.quoteValue(schema)})`).join(' or ')})
       order by atc.owner, atc.table_name, atc.column_id`;
-        const allColumns = await connection.execute(sql);
+        const allColumns = await connection.execute(sql, [], 'all', ctx);
         const str = (val) => (val != null ? '' + val : val);
         const ret = {};
         for (const col of allColumns) {
@@ -182,7 +182,7 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
-    async getAllIndexes(connection, tablesBySchemas) {
+    async getAllIndexes(connection, tablesBySchemas, ctx) {
         // Query indexes and join with constraints to identify which indexes back PRIMARY KEY or UNIQUE constraints
         // Also join with all_ind_expressions to get function-based index expressions
         const sql = `select ind.table_owner as schema_name, ind.table_name, ind.index_name, aic.column_name,
@@ -197,7 +197,7 @@ export class OracleSchemaHelper extends SchemaHelper {
       left join all_ind_expressions aie on ind.owner = aie.index_owner and ind.index_name = aie.index_name and aic.column_position = aie.column_position
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(ind.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')}) and ind.table_owner = ${this.platform.quoteValue(schema)})`).join(' or ')})
       order by ind.table_name, ind.index_name, aic.column_position`;
-        const allIndexes = await connection.execute(sql);
+        const allIndexes = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
@@ -251,7 +251,7 @@ export class OracleSchemaHelper extends SchemaHelper {
             deleteRule: supportedDeleteRules.includes(foreignKey.deleteRule ?? '') ? foreignKey.deleteRule : undefined,
         }, alterTable, inline);
     }
-    async getAllForeignKeys(connection, tablesBySchemas) {
+    async getAllForeignKeys(connection, tablesBySchemas, ctx) {
         const sql = `select fk_cons.constraint_name, fk_cons.table_name, fk_cons.owner as schema_name, fk_cols.column_name,
       fk_cons.r_owner as referenced_schema_name,
       pk_cols.column_name as referenced_column_name,
@@ -265,7 +265,7 @@ export class OracleSchemaHelper extends SchemaHelper {
       where fk_cons.constraint_type = 'R'
       and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(fk_cons.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')}) and fk_cons.owner = ${this.platform.quoteValue(schema)})`).join(' or ')})
       order by fk_cons.owner, fk_cons.table_name, fk_cons.constraint_name, pk_cols.position`;
-        const allFks = await connection.execute(sql);
+        const allFks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const fk of allFks) {
             // Oracle returns schema names in uppercase - normalize to lowercase for consistency
@@ -321,9 +321,9 @@ export class OracleSchemaHelper extends SchemaHelper {
       and (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(con.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')}) and con.owner = ${this.platform.quoteValue(schema)})`).join(' or ')})
       order by con.constraint_name`;
     }
-    async getAllChecks(connection, tablesBySchemas) {
+    async getAllChecks(connection, tablesBySchemas, ctx) {
         const sql = this.getChecksSQL(tablesBySchemas);
-        const allChecks = await connection.execute(sql);
+        const allChecks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const check of allChecks) {
             const key = this.getTableKey(check);
@@ -338,15 +338,15 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
-    async loadInformationSchema(schema, connection, tables) {
+    async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         if (tables.length === 0) {
             return;
         }
         const tablesBySchema = this.getTablesGroupedBySchemas(tables);
-        const columns = await this.getAllColumns(connection, tablesBySchema);
-        const indexes = await this.getAllIndexes(connection, tablesBySchema);
-        const checks = await this.getAllChecks(connection, tablesBySchema);
-        const fks = await this.getAllForeignKeys(connection, tablesBySchema);
+        const columns = await this.getAllColumns(connection, tablesBySchema, ctx);
+        const indexes = await this.getAllIndexes(connection, tablesBySchema, ctx);
+        const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
+        const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/oracledb",
-  "version": "7.0.7-dev.9",
+  "version": "7.0.8-dev.0",
   "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,15 +42,15 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.0.7-dev.9",
-    "kysely": "0.28.14",
+    "@mikro-orm/sql": "7.0.8-dev.0",
+    "kysely": "0.28.15",
     "oracledb": "6.10.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.6"
+    "@mikro-orm/core": "^7.0.7"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.7-dev.9"
+    "@mikro-orm/core": "7.0.8-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"