@mikro-orm/pglite 7.2.6-dev.37 → 7.2.6-dev.38

package/PgliteConnection.js

@@ -2,6 +2,37 @@ import { PGlite } from '@electric-sql/pglite';
 import { PGliteDialect } from 'kysely';
 import array from 'postgres-array';
 import { AbstractSqlConnection, createPostgreSqlTypeParsers } from '@mikro-orm/sql';
+/**
+ * PostgreSQL answers `COMMIT` of an aborted transaction (e.g. after a caught unique violation) with the command
+ * tag `ROLLBACK` instead of an error, and PGlite's `transaction()` commits without looking at the tag. Any server
+ * error aborts the transaction, and the only statement that then succeeds is `ROLLBACK TO SAVEPOINT`, which
+ * recovers it, so the last statement's outcome tells whether the commit would be a rollback.
+ */
+const rejectAbortedCommit = (transaction) => callback => transaction(async (tx) => {
+    let aborted = false;
+    const result = await callback(Object.create(tx, {
+        query: {
+            value: async (...args) => {
+                try {
+                    const res = await tx.query(...args);
+                    aborted = false;
+                    return res;
+                }
+                catch (e) {
+                    // client-side failures (e.g. a serializer throwing) have no SQLSTATE and leave the transaction alone
+                    aborted ||= !!e.code;
+                    throw e;
+                }
+            },
+        },
+    }));
+    if (aborted) {
+        throw Object.assign(new Error('current transaction is aborted, COMMIT would be answered with ROLLBACK'), {
+            code: '25P02',
+        });
+    }
+    return result;
+});
 const isInMemoryDataDir = (dataDir) => !dataDir || dataDir === 'memory://' || dataDir.startsWith('memory:');
 /**
  * Named-database mode is active when `driverOptions.dataDir` points at a real
@@ -63,30 +94,28 @@ export class PgliteConnection extends AbstractSqlConnection {
                 });
             }
         }
-        if (this.#neuterClose) {
-            // Hand kysely a delegating wrapper rather than mutating the underlying
-            // instance — proxies can't pierce PGlite's private fields, and patching
-            // `close` directly would orphan a user-supplied PGlite (its real `close`
-            // would stay neutered after `orm.close()`). Each method call hits the
-            // original `p`, so `#private` fields stay reachable.
-            const sharedPglitePromise = this.#pglite.then(p => ({
-                query: p.query.bind(p),
-                transaction: p.transaction.bind(p),
-                close: () => Promise.resolve(),
-                get closed() {
-                    return p.closed;
-                },
-                get ready() {
-                    return p.ready;
-                },
-                // `waitReady` is a stable Promise on the underlying instance — capture it
-                // directly so coverage doesn't hinge on `kysely` actually awaiting it (which
-                // only happens in the WASM-not-yet-loaded transient window).
-                waitReady: p.waitReady,
-            }));
-            return new PGliteDialect({ pglite: () => sharedPglitePromise, onCreateConnection });
-        }
-        return new PGliteDialect({ pglite: () => this.#pglite, onCreateConnection });
+        // Hand kysely a delegating wrapper rather than mutating the underlying
+        // instance — proxies can't pierce PGlite's private fields, and patching
+        // `close` directly would orphan a user-supplied PGlite (its real `close`
+        // would stay neutered after `orm.close()`). Each method call hits the
+        // original `p`, so `#private` fields stay reachable.
+        const neuterClose = this.#neuterClose;
+        const pglitePromise = this.#pglite.then(p => ({
+            query: p.query.bind(p),
+            transaction: rejectAbortedCommit(p.transaction.bind(p)),
+            close: neuterClose ? () => Promise.resolve() : p.close.bind(p),
+            get closed() {
+                return p.closed;
+            },
+            get ready() {
+                return p.ready;
+            },
+            // `waitReady` is a stable Promise on the underlying instance — capture it
+            // directly so coverage doesn't hinge on `kysely` actually awaiting it (which
+            // only happens in the WASM-not-yet-loaded transient window).
+            waitReady: p.waitReady,
+        }));
+        return new PGliteDialect({ pglite: () => pglitePromise, onCreateConnection });
     }
     async close(force) {
         await super.close(force);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/pglite",
-  "version": "7.2.6-dev.37",
+  "version": "7.2.6-dev.38",
   "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",
@@ -49,7 +49,7 @@
   },
   "dependencies": {
     "@electric-sql/pglite": "0.5.13",
-    "@mikro-orm/sql": "7.2.6-dev.37",
+    "@mikro-orm/sql": "7.2.6-dev.38",
     "kysely": "0.29.7",
     "postgres-array": "3.0.4",
     "postgres-date": "2.1.0",
@@ -59,7 +59,7 @@
     "@mikro-orm/core": "^7.2.5"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.6-dev.37"
+    "@mikro-orm/core": "7.2.6-dev.38"
   },
   "engines": {
     "node": ">= 22.17.0"