@mikro-orm/postgresql 6.6.11-dev.0 → 6.6.11-dev.2

package/PostgreSqlSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary } from '@mikro-orm/core';
+import { type Transaction, type Dictionary } from '@mikro-orm/core';
 import { SchemaHelper, type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type ForeignKey, type IndexDef, type Knex, type Table, type TableDifference } from '@mikro-orm/knex';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: {
@@ -13,18 +13,18 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
     getCreateDatabaseSQL(name: string): string;
     getListTablesSQL(): string;
-    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     private getIgnoredNamespacesConditionSQL;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
-    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     getAllColumns(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, nativeEnums?: Dictionary<{
         name: string;
         schema?: string;
         items: string[];
-    }>): Promise<Dictionary<Column[]>>;
-    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<CheckDef[]>>;
-    getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Dictionary<ForeignKey>>>;
-    getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[]): Promise<Dictionary<{
+    }>, ctx?: Transaction): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    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;
         schema?: string;
         items: string[];

package/PostgreSqlSchemaHelper.js

@@ -32,11 +32,11 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
             + `and table_name not in (select inhrelid::regclass::text from pg_inherits) `
             + `order by table_name`;
     }
-    async getNamespaces(connection) {
+    async getNamespaces(connection, ctx) {
         const sql = `select schema_name from information_schema.schemata `
             + `where ${this.getIgnoredNamespacesConditionSQL()} `
             + `order by schema_name`;
-        const res = await connection.execute(sql);
+        const res = await connection.execute(sql, [], 'all', ctx);
         return res.map(row => row.schema_name);
     }
     getIgnoredNamespacesConditionSQL(column = 'schema_name') {
@@ -54,18 +54,18 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         ].map(p => `"${column}" not like '${p}%'`).join(' and ');
         return `${ignoredPrefixes} and "${column}" not in (${ignored})`;
     }
-    async loadInformationSchema(schema, connection, tables, schemas) {
+    async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         schemas ??= tables.length === 0 ? [schema.name] : tables.map(t => t.schema_name ?? schema.name);
-        const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas);
+        const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas, ctx);
         schema.setNativeEnums(nativeEnums);
         if (tables.length === 0) {
             return;
         }
         const tablesBySchema = this.getTablesGroupedBySchemas(tables);
-        const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums);
-        const indexes = await this.getAllIndexes(connection, tables);
-        const checks = await this.getAllChecks(connection, tablesBySchema);
-        const fks = await this.getAllForeignKeys(connection, tablesBySchema);
+        const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums, ctx);
+        const indexes = await this.getAllIndexes(connection, tables, 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);
@@ -76,10 +76,10 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
             }
         }
     }
-    async getAllIndexes(connection, tables) {
+    async getAllIndexes(connection, tables, ctx) {
         const sql = this.getIndexesSQL(tables);
         const unquote = (str) => str.replace(/['"`]/g, '');
-        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);
@@ -106,7 +106,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         }
         return ret;
     }
-    async getAllColumns(connection, tablesBySchemas, nativeEnums) {
+    async getAllColumns(connection, tablesBySchemas, nativeEnums, ctx) {
         const sql = `select table_schema as schema_name, table_name, column_name,
       column_default,
       is_nullable,
@@ -126,7 +126,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
-        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) {
@@ -176,9 +176,9 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         }
         return ret;
     }
-    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 = {};
         const seen = new Set();
         for (const check of allChecks) {
@@ -200,7 +200,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         }
         return ret;
     }
-    async getAllForeignKeys(connection, tablesBySchemas) {
+    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,
       confupdtype update_rule, confdeltype delete_rule, array_position(con.conkey,a.attnum) as ord, condeferrable, condeferred,
@@ -215,7 +215,7 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(cls1.relname in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and nsp1.nspname = ${this.platform.quoteValue(schema)})`).join(' or ')})
       and confrelid > 0
       order by nsp1.nspname, cls1.relname, constraint_name, ord`;
-        const allFks = await connection.execute(sql);
+        const allFks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         function mapReferentialIntegrity(value, def) {
             const match = ['n', 'd'].includes(value) && def.match(/ON DELETE (SET (NULL|DEFAULT) \(.*?\))/);
@@ -248,14 +248,14 @@ class PostgreSqlSchemaHelper extends knex_1.SchemaHelper {
         });
         return ret;
     }
-    async getNativeEnumDefinitions(connection, schemas) {
+    async getNativeEnumDefinitions(connection, schemas, ctx) {
         const uniqueSchemas = core_1.Utils.unique(schemas);
         const res = await connection.execute(`select t.typname as enum_name, n.nspname as schema_name, array_agg(e.enumlabel order by e.enumsortorder) as enum_value
         from pg_type t
         join pg_enum e on t.oid = e.enumtypid
         join pg_catalog.pg_namespace n on n.oid = t.typnamespace
         where n.nspname in (${Array(uniqueSchemas.length).fill('?').join(', ')})
-        group by t.typname, n.nspname`, uniqueSchemas);
+        group by t.typname, n.nspname`, uniqueSchemas, 'all', ctx);
         return res.reduce((o, row) => {
             let name = row.enum_name;
             if (row.schema_name && row.schema_name !== this.platform.getDefaultSchemaName()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/postgresql",
-  "version": "6.6.11-dev.0",
+  "version": "6.6.11-dev.2",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -58,8 +58,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "6.6.11-dev.0",
-    "pg": "8.19.0",
+    "@mikro-orm/knex": "6.6.11-dev.2",
+    "pg": "8.20.0",
     "postgres-array": "3.0.4",
     "postgres-date": "2.1.0",
     "postgres-interval": "4.0.2"
@@ -68,6 +68,6 @@
     "@mikro-orm/core": "^6.6.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.6.11-dev.0"
+    "@mikro-orm/core": "6.6.11-dev.2"
   }
 }