uql-orm 0.21.0 → 0.23.0

package/dist/nestjs/uqlModule.js

@@ -1,17 +1,38 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
-var UqlModule_1;
-import { Inject, Module, } from '@nestjs/common';
+import { Module, } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import { setQuerierPool } from '../options.js';
 import { UqlContextInterceptor } from './uqlContextInterceptor.js';
@@ -28,7 +49,16 @@ export const UQL_QUERIER_POOL = Symbol('UQL_QUERIER_POOL');
  * optionally scopes every request to a {@link UqlContext} (multi-tenancy), and ends the pool on
  * application shutdown.
  */
-let UqlModule = UqlModule_1 = class UqlModule {
+/**
+ * Ends the pool when Nest shuts down.
+ *
+ * @remarks A provider rather than a hook on the module class, and built through `useFactory` with an
+ * `inject` list rather than constructor injection: Nest injects constructor parameters with a parameter
+ * decorator, and the TC39 decorator spec has none, so `@Inject()` cannot appear in a file compiled
+ * against it. Nest runs lifecycle hooks on providers too, so this keeps the pool that *this* module was
+ * configured with instead of reaching for the global default.
+ */
+class UqlPoolLifecycle {
     pool;
     constructor(pool) {
         this.pool = pool;
@@ -36,36 +66,55 @@ let UqlModule = UqlModule_1 = class UqlModule {
     onApplicationShutdown() {
         return this.pool.end();
     }
-    /** Configure with an already-built pool. */
-    static forRoot({ pool, global = true, getContext }) {
-        setQuerierPool(pool);
-        return UqlModule_1.build(global, { provide: UQL_QUERIER_POOL, useValue: pool }, getContext);
-    }
-    /** Configure with a pool built asynchronously from injected providers (e.g. `ConfigService`). */
-    static forRootAsync({ imports, useFactory, inject = [], global = true, getContext, }) {
-        const poolProvider = {
-            provide: UQL_QUERIER_POOL,
-            useFactory: async (...args) => {
-                const pool = await useFactory(...args);
-                setQuerierPool(pool); // register as UQL's default once the pool is resolved
-                return pool;
-            },
-            inject,
-        };
-        return UqlModule_1.build(global, poolProvider, getContext, imports);
-    }
-    static build(global, poolProvider, getContext, imports) {
-        const providers = [poolProvider];
-        if (getContext) {
-            // Scope every request to its context so multi-tenancy / security filters apply automatically.
-            providers.push({ provide: APP_INTERCEPTOR, useValue: new UqlContextInterceptor(getContext) });
+}
+let UqlModule = (() => {
+    let _classDecorators = [Module({})];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var UqlModule = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            UqlModule = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        return { module: UqlModule_1, global, imports, providers, exports: [UQL_QUERIER_POOL] };
-    }
-};
-UqlModule = UqlModule_1 = __decorate([
-    Module({}),
-    __param(0, Inject(UQL_QUERIER_POOL)),
-    __metadata("design:paramtypes", [Object])
-], UqlModule);
+        /** Configure with an already-built pool. */
+        static forRoot({ pool, global = true, getContext }) {
+            setQuerierPool(pool);
+            return UqlModule.build(global, { provide: UQL_QUERIER_POOL, useValue: pool }, getContext);
+        }
+        /** Configure with a pool built asynchronously from injected providers (e.g. `ConfigService`). */
+        static forRootAsync({ imports, useFactory, inject = [], global = true, getContext, }) {
+            const poolProvider = {
+                provide: UQL_QUERIER_POOL,
+                useFactory: async (...args) => {
+                    const pool = await useFactory(...args);
+                    setQuerierPool(pool); // register as UQL's default once the pool is resolved
+                    return pool;
+                },
+                inject,
+            };
+            return UqlModule.build(global, poolProvider, getContext, imports);
+        }
+        static build(global, poolProvider, getContext, imports) {
+            const providers = [
+                poolProvider,
+                {
+                    provide: UqlPoolLifecycle,
+                    useFactory: (pool) => new UqlPoolLifecycle(pool),
+                    inject: [UQL_QUERIER_POOL],
+                },
+            ];
+            if (getContext) {
+                // Scope every request to its context so multi-tenancy / security filters apply automatically.
+                providers.push({ provide: APP_INTERCEPTOR, useValue: new UqlContextInterceptor(getContext) });
+            }
+            return { module: UqlModule, global, imports, providers, exports: [UQL_QUERIER_POOL] };
+        }
+    };
+    return UqlModule = _classThis;
+})();
 export { UqlModule };

package/dist/postgres/postgresDialect.js

@@ -10,7 +10,7 @@ export class PostgresDialect extends PgLikeSqlDialect {
     dialectName = 'postgres';
     vectorExtension = 'vector';
     upsert(ctx, entity, conflictPaths, payload) {
-        // xmax system column is 0 for newly inserted rows, non-zero for updated rows (MVCC).
-        this.buildUpsertOnConflict(ctx, entity, conflictPaths, payload, `, (xmax = 0) AS ${this.escapeId('_created')}`);
+        // The xmax system column is 0 for a newly inserted row and non-zero for an updated one (MVCC).
+        super.upsert(ctx, entity, conflictPaths, payload, `, (xmax = 0) AS ${this.escapeId('_created')}`);
     }
 }

package/dist/querier/abstractQuerier.d.ts

@@ -117,6 +117,23 @@ export declare abstract class AbstractQuerier implements Querier {
     private saveOneToOne;
     private saveManyToOne;
     abstract readonly hasOpenTransaction: boolean;
+    /**
+     * Runs `callback` in a transaction: begin, commit on success, roll back on failure.
+     *
+     * The single place that sequence is written; everything else delegates here, because both subtleties
+     * below were got wrong by code that hand-rolled it:
+     *
+     * - `beginTransaction` connects before it begins, so a refused connection lands in the catch with no
+     *   transaction open. Rolling back regardless threw `not a pending transaction`, and that replaced the
+     *   real cause: a wrong password surfaced as a transaction-state error.
+     * - A rollback that fails too is a consequence of the original failure, not news, so it must not
+     *   replace it either.
+     *
+     * The connection is **not** released here: whoever took it from the pool gives it back, through
+     * {@link QuerierPool.transaction}, {@link QuerierPool.withQuerier} or `await using`. Releasing a
+     * connection this method never acquired is what forced every caller to know whether it still owned
+     * one afterwards.
+     */
     transaction<T>(callback: () => Promise<T>, opts?: TransactionOptions): Promise<T>;
     /**
      * Emit a lifecycle hook event for the given entity.
@@ -132,9 +149,20 @@ export declare abstract class AbstractQuerier implements Querier {
      * @returns A promise that resolves with the task's result.
      */
     protected serialize<T>(task: () => Promise<T>): Promise<T>;
+    /**
+     * Runs `task`, logs `query` with how long it took, and tags any error it throws with that query.
+     *
+     * A method rather than the `@Log()` decorator it replaces. A standard-spec method decorator works by
+     * returning a replacement function, and a replacement cannot carry the original's type parameters, so
+     * decorating `internalFindMany<E extends Document>` made its signature unresolvable. Most of the query
+     * surface is generic like that, and wrapping at the call site costs one line while keeping the
+     * signature intact.
+     */
+    protected timed<T>(query: string, values: unknown[] | undefined, task: () => Promise<T>): Promise<T>;
     abstract beginTransaction(opts?: TransactionOptions): Promise<void>;
     abstract commitTransaction(): Promise<void>;
     abstract rollbackTransaction(): Promise<void>;
     protected abstract internalRelease(): Promise<void>;
     release(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
 }

package/dist/querier/abstractQuerier.js

@@ -1,15 +1,6 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { getMeta } from '../entity/decorator/index.js';
+import { getMeta } from '../entity/index.js';
 import { asSelectMap, augmentWhere, clone, filterPersistableRelationKeys, forEachRequestedRelation, getKeys, getRelationRequestSummary, LoggerWrapper, parseRelationAtKey, parseRelationQueryValue, runHooks, } from '../util/index.js';
-import { Serialized } from './decorator/index.js';
+import { enrichError } from './queryError.js';
 /**
  * Base class for all database queriers.
  * It provides a standardized way to execute tasks serially to prevent race conditions on database connections.
@@ -366,6 +357,23 @@ export class AbstractQuerier {
         const referenceId = await this.insertOne(relEntity, relPayload);
         await this.updateOneById(entity, id, { [localField]: referenceId });
     }
+    /**
+     * Runs `callback` in a transaction: begin, commit on success, roll back on failure.
+     *
+     * The single place that sequence is written; everything else delegates here, because both subtleties
+     * below were got wrong by code that hand-rolled it:
+     *
+     * - `beginTransaction` connects before it begins, so a refused connection lands in the catch with no
+     *   transaction open. Rolling back regardless threw `not a pending transaction`, and that replaced the
+     *   real cause: a wrong password surfaced as a transaction-state error.
+     * - A rollback that fails too is a consequence of the original failure, not news, so it must not
+     *   replace it either.
+     *
+     * The connection is **not** released here: whoever took it from the pool gives it back, through
+     * {@link QuerierPool.transaction}, {@link QuerierPool.withQuerier} or `await using`. Releasing a
+     * connection this method never acquired is what forced every caller to know whether it still owned
+     * one afterwards.
+     */
     async transaction(callback, opts) {
         if (this.hasOpenTransaction) {
             return callback();
@@ -377,12 +385,11 @@ export class AbstractQuerier {
             return res;
         }
         catch (err) {
-            await this.rollbackTransaction();
+            if (this.hasOpenTransaction) {
+                await this.rollbackTransaction().catch(() => { });
+            }
             throw err;
         }
-        finally {
-            await this.release();
-        }
     }
     /**
      * Emit a lifecycle hook event for the given entity.
@@ -428,13 +435,31 @@ export class AbstractQuerier {
         this.taskQueue = res.catch(() => { });
         return res;
     }
+    /**
+     * Runs `task`, logs `query` with how long it took, and tags any error it throws with that query.
+     *
+     * A method rather than the `@Log()` decorator it replaces. A standard-spec method decorator works by
+     * returning a replacement function, and a replacement cannot carry the original's type parameters, so
+     * decorating `internalFindMany<E extends Document>` made its signature unresolvable. Most of the query
+     * surface is generic like that, and wrapping at the call site costs one line while keeping the
+     * signature intact.
+     */
+    async timed(query, values, task) {
+        const startTime = performance.now();
+        try {
+            return await task();
+        }
+        catch (err) {
+            throw enrichError(err, this.logger, query, values);
+        }
+        finally {
+            this.logger.logQuery(query, values, Math.round(performance.now() - startTime));
+        }
+    }
     async release() {
-        return this.internalRelease();
+        return this.serialize(() => this.internalRelease());
+    }
+    async [Symbol.asyncDispose]() {
+        return this.release();
     }
 }
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], AbstractQuerier.prototype, "release", null);

package/dist/querier/abstractQuerierPool.d.ts

@@ -13,6 +13,9 @@ export declare abstract class AbstractQuerierPool<Q extends Querier, D extends A
     abstract getQuerier(): Promise<Q>;
     /**
      * get a querier from the pool and run the given callback inside a transaction.
+     *
+     * The pool acquired the connection, so the pool releases it: `withQuerier` owns that half and
+     * `querier.transaction` owns begin/commit/rollback. Neither knows about the other's job.
      */
     transaction<T>(callback: (querier: Q) => Promise<T>, opts?: TransactionOptions & PoolRunOptions): Promise<T>;
     /**

package/dist/querier/abstractQuerierPool.js

@@ -11,10 +11,12 @@ export class AbstractQuerierPool {
     }
     /**
      * get a querier from the pool and run the given callback inside a transaction.
+     *
+     * The pool acquired the connection, so the pool releases it: `withQuerier` owns that half and
+     * `querier.transaction` owns begin/commit/rollback. Neither knows about the other's job.
      */
-    async transaction(callback, opts) {
-        const querier = await this.getQuerier();
-        return this.runScoped(opts?.context, () => querier.transaction(() => callback(querier), opts));
+    transaction(callback, opts) {
+        return this.withQuerier((querier) => querier.transaction(() => callback(querier), opts), opts);
     }
     /**
      * get a querier from the pool, run the given callback, and release the querier.

package/dist/querier/abstractSqlQuerier.d.ts

@@ -28,13 +28,11 @@ export declare abstract class AbstractSqlQuerier extends AbstractQuerier impleme
     protected loadInsertIdIncrement(): Promise<number>;
     /**
      * Hook for subclasses (e.g. pool queriers) to establish a connection.
-     * Called before every query but outside the `@Log()` timer.
+     * Called before every query but outside the timing window.
      */
     protected lazyConnect(): Promise<void>;
     all<T>(query: string, values?: unknown[]): Promise<T[]>;
-    private timedAll;
     run(query: string, values?: unknown[]): Promise<QueryUpdateResult>;
-    private timedRun;
     protected internalFindMany<E extends object>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): Promise<E[]>;
     protected internalFindManyStream<E extends object>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): AsyncGenerator<Awaited<E>, void, unknown>;
     /**

package/dist/querier/abstractSqlQuerier.js

@@ -1,16 +1,7 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import { getMeta } from '../entity/index.js';
 import { buildUpdateResult, clone, getInsertFieldKeys, getRelationRequestSummary, isAutoIncrement, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
-import { enrichError, Log, Serialized } from './decorator/index.js';
+import { enrichError } from './queryError.js';
 export class AbstractSqlQuerier extends AbstractQuerier {
     dialect;
     extra;
@@ -44,22 +35,20 @@ export class AbstractSqlQuerier extends AbstractQuerier {
     }
     /**
      * Hook for subclasses (e.g. pool queriers) to establish a connection.
-     * Called before every query but outside the `@Log()` timer.
+     * Called before every query but outside the timing window.
      */
     async lazyConnect() { }
     async all(query, values) {
-        await this.lazyConnect();
-        return this.timedAll(query, values);
-    }
-    async timedAll(query, values) {
-        return this.internalAll(query, this.dialect.normalizeValues(values));
+        return this.serialize(async () => {
+            await this.lazyConnect();
+            return this.timed(query, values, () => this.internalAll(query, this.dialect.normalizeValues(values)));
+        });
     }
     async run(query, values) {
-        await this.lazyConnect();
-        return this.timedRun(query, values);
-    }
-    async timedRun(query, values) {
-        return this.internalRun(query, this.dialect.normalizeValues(values));
+        return this.serialize(async () => {
+            await this.lazyConnect();
+            return this.timed(query, values, () => this.internalRun(query, this.dialect.normalizeValues(values)));
+        });
     }
     async internalFindMany(entity, q, opts) {
         const ctx = this.dialect.createContext();
@@ -86,7 +75,7 @@ export class AbstractSqlQuerier extends AbstractQuerier {
             }
         }
         catch (err) {
-            enrichError(err, this.logger, ctx.sql, normalizedParams);
+            throw enrichError(err, this.logger, ctx.sql, normalizedParams);
         }
     }
     /**
@@ -243,85 +232,48 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         return !!this.hasPendingTransaction;
     }
     async beginTransaction(opts) {
-        if (this.hasPendingTransaction) {
-            throwPendingTransaction();
-        }
-        await this.lazyConnect();
-        const statements = this.dialect.getBeginTransactionStatements(opts?.isolationLevel);
-        for (const sql of statements) {
-            try {
-                await this.internalRun(sql);
+        return this.serialize(async () => {
+            if (this.hasPendingTransaction) {
+                throwPendingTransaction();
             }
-            catch (err) {
-                enrichError(err, this.logger, sql);
+            await this.lazyConnect();
+            for (const sql of this.dialect.getBeginTransactionStatements(opts?.isolationLevel)) {
+                try {
+                    await this.internalRun(sql);
+                }
+                catch (err) {
+                    throw enrichError(err, this.logger, sql);
+                }
             }
-        }
-        this.hasPendingTransaction = true;
+            this.hasPendingTransaction = true;
+        });
     }
     async commitTransaction() {
-        if (!this.hasPendingTransaction) {
-            throwNoPendingTransaction();
-        }
-        try {
-            await this.internalRun(this.dialect.commitTransactionCommand);
-        }
-        catch (err) {
-            enrichError(err, this.logger, this.dialect.commitTransactionCommand);
-        }
-        this.hasPendingTransaction = false;
+        return this.serialize(async () => {
+            if (!this.hasPendingTransaction) {
+                throwNoPendingTransaction();
+            }
+            try {
+                await this.internalRun(this.dialect.commitTransactionCommand);
+            }
+            catch (err) {
+                throw enrichError(err, this.logger, this.dialect.commitTransactionCommand);
+            }
+            this.hasPendingTransaction = false;
+        });
     }
     async rollbackTransaction() {
-        if (!this.hasPendingTransaction) {
-            throwNoPendingTransaction();
-        }
-        try {
-            await this.internalRun(this.dialect.rollbackTransactionCommand);
-        }
-        catch (err) {
-            enrichError(err, this.logger, this.dialect.rollbackTransactionCommand);
-        }
-        this.hasPendingTransaction = false;
+        return this.serialize(async () => {
+            if (!this.hasPendingTransaction) {
+                throwNoPendingTransaction();
+            }
+            try {
+                await this.internalRun(this.dialect.rollbackTransactionCommand);
+            }
+            catch (err) {
+                throw enrichError(err, this.logger, this.dialect.rollbackTransactionCommand);
+            }
+            this.hasPendingTransaction = false;
+        });
     }
 }
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array]),
-    __metadata("design:returntype", Promise)
-], AbstractSqlQuerier.prototype, "all", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array]),
-    __metadata("design:returntype", Promise)
-], AbstractSqlQuerier.prototype, "timedAll", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array]),
-    __metadata("design:returntype", Promise)
-], AbstractSqlQuerier.prototype, "run", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array]),
-    __metadata("design:returntype", Promise)
-], AbstractSqlQuerier.prototype, "timedRun", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], AbstractSqlQuerier.prototype, "beginTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], AbstractSqlQuerier.prototype, "commitTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], AbstractSqlQuerier.prototype, "rollbackTransaction", null);

package/dist/querier/index.d.ts

@@ -2,4 +2,6 @@ export * from './abstractQuerier.js';
 export * from './abstractQuerierPool.js';
 export * from './abstractSqlQuerier.js';
 export * from './abstractSqlQuerierPool.js';
-export * from './decorator/index.js';
+export * from './querierContext.js';
+export * from './queryError.js';
+export * from './transactional.js';

package/dist/querier/index.js

@@ -2,4 +2,6 @@ export * from './abstractQuerier.js';
 export * from './abstractQuerierPool.js';
 export * from './abstractSqlQuerier.js';
 export * from './abstractSqlQuerierPool.js';
-export * from './decorator/index.js';
+export * from './querierContext.js';
+export * from './queryError.js';
+export * from './transactional.js';

package/dist/querier/querierContext.browser.d.ts

@@ -0,0 +1,12 @@
+import type { Querier } from '../type/index.js';
+/**
+ * Browser build of the transactional querier context: bundlers targeting the browser resolve
+ * `querierContext.ts` to this file (see the `browser` map in package.json), keeping the root entrypoint
+ * free of `node:async_hooks`.
+ *
+ * Nothing in a browser bundle opens a transaction. The browser querier serializes queries over HTTP and
+ * the server owns the transaction, so there is no ambient querier to hand out and no flow to track.
+ */
+export declare function withQuerierContext<T>(_querier: Querier, callback: () => T): T;
+export declare function currentQuerier(): Querier;
+export declare function currentQuerierIfAny(): Querier | undefined;

package/dist/querier/querierContext.browser.js

@@ -0,0 +1,18 @@
+/**
+ * Browser build of the transactional querier context: bundlers targeting the browser resolve
+ * `querierContext.ts` to this file (see the `browser` map in package.json), keeping the root entrypoint
+ * free of `node:async_hooks`.
+ *
+ * Nothing in a browser bundle opens a transaction. The browser querier serializes queries over HTTP and
+ * the server owns the transaction, so there is no ambient querier to hand out and no flow to track.
+ */
+export function withQuerierContext(_querier, callback) {
+    return callback();
+}
+export function currentQuerier() {
+    throw new TypeError('currentQuerier() is server-only: transactions run on the server, and the browser querier sends each ' +
+        'request over HTTP. Call it from server code, or use the querier you already have.');
+}
+export function currentQuerierIfAny() {
+    return undefined;
+}

package/dist/querier/querierContext.d.ts

@@ -0,0 +1,22 @@
+import type { Querier } from '../type/index.js';
+/** Runs `callback` with `querier` as the ambient one, for the whole async flow beneath it. */
+export declare function withQuerierContext<T>(querier: Querier, callback: () => T): T;
+/**
+ * The querier of the enclosing `@Transactional()` method.
+ *
+ * This is what replaced `@InjectQuerier()`: the standard decorator spec has no parameter decorators, so
+ * the querier can no longer be injected into an argument and is read from the ambient flow instead.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @Transactional()
+ *   async register(data: Partial<User>) {
+ *     await currentQuerier().insertOne(User, data);
+ *   }
+ * }
+ * ```
+ */
+export declare function currentQuerier(): Querier;
+/** The ambient querier, or `undefined` outside a transaction. For callers that can work without one. */
+export declare function currentQuerierIfAny(): Querier | undefined;