@mikro-orm/postgresql 7.1.0-dev.8 → 7.1.0

package/PostgreSqlConnection.d.ts

@@ -1,8 +1,11 @@
 import { type PoolConfig } from 'pg';
 import { PostgresDialect } from 'kysely';
+import { type Routine, type Transaction } from '@mikro-orm/core';
 import { AbstractSqlConnection } from '@mikro-orm/sql';
 /** PostgreSQL database connection using the `pg` driver. */
 export declare class PostgreSqlConnection extends AbstractSqlConnection {
     createKyselyDialect(overrides: PoolConfig): PostgresDialect;
     mapOptions(overrides: PoolConfig): PoolConfig;
+    callRoutine<T>(routine: Routine, args?: Record<string, unknown>, ctx?: Transaction): Promise<T>;
+    private fetchRefcursors;
 }

package/PostgreSqlConnection.js

@@ -2,13 +2,16 @@ import { Pool, TypeOverrides } from 'pg';
 import Cursor from 'pg-cursor';
 import { PostgresDialect } from 'kysely';
 import array from 'postgres-array';
-import { AbstractSqlConnection, Utils } from '@mikro-orm/sql';
+import { AbstractSqlConnection, createPostgreSqlTypeParsers, Utils } from '@mikro-orm/sql';
 /** PostgreSQL database connection using the `pg` driver. */
 export class PostgreSqlConnection extends AbstractSqlConnection {
     createKyselyDialect(overrides) {
-        const options = this.mapOptions(overrides);
+        const { onPoolCreated, ...poolOverrides } = (overrides ?? {});
+        const options = this.mapOptions(poolOverrides);
+        const pool = new Pool(options);
+        void onPoolCreated?.(pool);
         return new PostgresDialect({
-            pool: new Pool(options),
+            pool,
             cursor: Cursor,
             onCreateConnection: this.options.onCreateConnection ?? this.config.get('onCreateConnection'),
         });
@@ -18,21 +21,45 @@ export class PostgreSqlConnection extends AbstractSqlConnection {
         const pool = this.config.get('pool');
         Utils.defaultValue(ret, 'max', pool?.max);
         Utils.defaultValue(ret, 'idleTimeoutMillis', pool?.idleTimeoutMillis);
-        // use `select typname, oid, typarray from pg_type order by oid` to get the list of OIDs
         const types = new TypeOverrides();
-        [
-            1082, // date
-            1114, // timestamp
-            1184, // timestamptz
-            1186, // interval
-        ].forEach(oid => types.setTypeParser(oid, str => str));
-        [
-            1182, // date[]
-            1115, // timestamp[]
-            1185, // timestamptz[]
-            1187, // interval[]
-        ].forEach(oid => types.setTypeParser(oid, str => array.parse(str)));
+        for (const [oid, parser] of Object.entries(createPostgreSqlTypeParsers(s => array.parse(s)))) {
+            types.setTypeParser(Number(oid), parser);
+        }
         ret.types = types;
         return Utils.mergeConfig(ret, overrides);
     }
+    async callRoutine(routine, args = {}, ctx) {
+        if (routine.type === 'function') {
+            return this.callRoutineFunction(routine, args, ctx);
+        }
+        const quoted = (id) => this.platform.quoteIdentifier(id);
+        const qualified = (routine.schema ? `${quoted(routine.schema)}.` : '') + quoted(routine.name);
+        // Refcursor OUT params come back as server-generated cursor names to FETCH from later.
+        const refcursorParams = routine.params.filter(p => p.direction !== 'in' && typeof p.type === 'string' && /^refcursor$/i.test(p.type));
+        // Refcursors are transaction-scoped — fail fast instead of opening cursors we can't read.
+        if (refcursorParams.length > 0 && !ctx) {
+            throw new Error(`Routine ${routine.name} declares refcursor OUT params on PostgreSQL but was not called inside a transaction. Wrap the call in 'em.transactional(...)' so the refcursor OUT params remain valid for FETCH.`);
+        }
+        const placeholders = routine.params.map(() => '?').join(', ');
+        const positional = routine.params.map(p => this.convertRoutineInbound(args[p.name], p));
+        const rows = (await this.execute(`call ${qualified}(${placeholders})`, positional, 'all', ctx));
+        const row = rows[0] ?? {};
+        const scalarOutParams = routine.params.filter(p => p.direction !== 'in' && !refcursorParams.includes(p));
+        this.applyRoutineOutParams(row, scalarOutParams, args);
+        if (refcursorParams.length > 0) {
+            return (await this.fetchRefcursors(row, routine, refcursorParams, ctx));
+        }
+        return undefined;
+    }
+    async fetchRefcursors(row, routine, refcursorParams, ctx) {
+        const cursorNames = refcursorParams
+            .map(p => row[p.name])
+            .filter((name) => typeof name === 'string');
+        const sets = [];
+        for (const cursorName of cursorNames) {
+            const fetched = (await this.execute(`fetch all from "${cursorName.replaceAll('"', '""')}"`, [], 'all', ctx));
+            sets.push(fetched);
+        }
+        return sets;
+    }
 }

package/PostgreSqlEntityManager.d.ts

@@ -1,18 +1,7 @@
-import { type EntityName } from '@mikro-orm/core';
-import { SqlEntityManager } from '@mikro-orm/sql';
+import { BasePostgreSqlEntityManager } from '@mikro-orm/sql';
 import type { PostgreSqlDriver } from './PostgreSqlDriver.js';
 /**
  * @inheritDoc
  */
-export declare class PostgreSqlEntityManager<Driver extends PostgreSqlDriver = PostgreSqlDriver> extends SqlEntityManager<Driver> {
-    /**
-     * Refreshes a materialized view.
-     *
-     * @param entityName - The entity name or class of the materialized view
-     * @param options - Optional settings
-     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
-     */
-    refreshMaterializedView<Entity extends object>(entityName: EntityName<Entity>, options?: {
-        concurrently?: boolean;
-    }): Promise<void>;
+export declare class PostgreSqlEntityManager<Driver extends PostgreSqlDriver = PostgreSqlDriver> extends BasePostgreSqlEntityManager<Driver> {
 }

package/PostgreSqlEntityManager.js

@@ -1,23 +1,6 @@
-import { SqlEntityManager } from '@mikro-orm/sql';
+import { BasePostgreSqlEntityManager } from '@mikro-orm/sql';
 /**
  * @inheritDoc
  */
-export class PostgreSqlEntityManager extends SqlEntityManager {
-    /**
-     * Refreshes a materialized view.
-     *
-     * @param entityName - The entity name or class of the materialized view
-     * @param options - Optional settings
-     * @param options.concurrently - If true, refreshes the view concurrently (requires a unique index on the view)
-     */
-    async refreshMaterializedView(entityName, options) {
-        const meta = this.getMetadata(entityName);
-        if (!meta.view || !meta.materialized) {
-            throw new Error(`Entity ${meta.className} is not a materialized view`);
-        }
-        const helper = this.getDriver().getPlatform().getSchemaHelper();
-        const schema = meta.schema ?? this.config.get('schema');
-        const sql = helper.refreshMaterializedView(meta.tableName, schema, options?.concurrently);
-        await this.execute(sql);
-    }
+export class PostgreSqlEntityManager extends BasePostgreSqlEntityManager {
 }

package/PostgreSqlMikroORM.d.ts

@@ -1,4 +1,5 @@
-import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { type AnyEntity, type EntityClass, type EntitySchema, type MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { SqlMikroORM } from '@mikro-orm/sql';
 import { PostgreSqlDriver } from './PostgreSqlDriver.js';
 import type { PostgreSqlEntityManager } from './PostgreSqlEntityManager.js';
 /** Configuration options for the PostgreSQL driver. */
@@ -8,7 +9,7 @@ export declare function definePostgreSqlConfig<EM extends PostgreSqlEntityManage
 /**
  * @inheritDoc
  */
-export declare class PostgreSqlMikroORM<EM extends PostgreSqlEntityManager = PostgreSqlEntityManager, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<PostgreSqlDriver, EM, Entities> {
+export declare class PostgreSqlMikroORM<EM extends PostgreSqlEntityManager = PostgreSqlEntityManager, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends SqlMikroORM<PostgreSqlDriver, EM, Entities> {
     /**
      * @inheritDoc
      */

package/PostgreSqlMikroORM.js

@@ -1,4 +1,5 @@
-import { defineConfig, MikroORM, } from '@mikro-orm/core';
+import { defineConfig, } from '@mikro-orm/core';
+import { SqlMikroORM } from '@mikro-orm/sql';
 import { PostgreSqlDriver } from './PostgreSqlDriver.js';
 /** Creates a type-safe configuration object for the PostgreSQL driver. */
 export function definePostgreSqlConfig(options) {
@@ -7,7 +8,7 @@ export function definePostgreSqlConfig(options) {
 /**
  * @inheritDoc
  */
-export class PostgreSqlMikroORM extends MikroORM {
+export class PostgreSqlMikroORM extends SqlMikroORM {
     /**
      * @inheritDoc
      */

package/PostgreSqlPlatform.d.ts

@@ -5,7 +5,6 @@ export declare class PostgreSqlPlatform extends BasePostgreSqlPlatform {
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: IPostgresInterval): unknown;
     unmarshallArray(value: string): string[];
-    escape(value: any): string;
     /**
      * @inheritDoc
      */

package/PostgreSqlPlatform.js

@@ -1,4 +1,3 @@
-import { Client } from 'pg';
 import array from 'postgres-array';
 import parseDate from 'postgres-date';
 import PostgresInterval from 'postgres-interval';
@@ -17,24 +16,6 @@ export class PostgreSqlPlatform extends BasePostgreSqlPlatform {
     unmarshallArray(value) {
         return array.parse(value);
     }
-    escape(value) {
-        if (typeof value === 'bigint') {
-            value = value.toString();
-        }
-        if (typeof value === 'string') {
-            return Client.prototype.escapeLiteral(value);
-        }
-        if (value instanceof Date) {
-            return `'${this.formatDate(value)}'`;
-        }
-        if (ArrayBuffer.isView(value)) {
-            return `E'\\\\x${value.toString('hex')}'`;
-        }
-        if (Array.isArray(value)) {
-            return value.map(v => this.escape(v)).join(', ');
-        }
-        return value;
-    }
     /**
      * @inheritDoc
      */

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/postgresql",
-  "version": "7.1.0-dev.8",
+  "version": "7.1.0",
   "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",
@@ -47,19 +47,19 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.8",
-    "kysely": "0.28.16",
-    "pg": "8.20.0",
-    "pg-cursor": "2.19.0",
+    "@mikro-orm/sql": "7.1.0",
+    "kysely": "0.29.2",
+    "pg": "8.21.0",
+    "pg-cursor": "2.20.0",
     "postgres-array": "3.0.4",
     "postgres-date": "2.1.0",
     "postgres-interval": "4.0.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.1.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.8"
+    "@mikro-orm/core": "7.1.0"
   },
   "engines": {
     "node": ">= 22.17.0"