uql-orm 0.22.0 → 0.24.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

@@ -1,5 +1,5 @@
 import type { AbstractDialect } from '../dialect/index.js';
-import type { ExtraOptions, IdValue, PoolRunOptions, Querier, QuerierPool, Query, QueryAggMap, QueryAggregate, QueryAggregateResult, QueryGroupMap, QueryOne, QueryOptions, QuerySearch, TransactionOptions, Type } from '../type/index.js';
+import type { ExtraOptions, IdValue, PoolRunOptions, Querier, QuerierPool, Query, QueryAggMap, QueryAggregate, QueryAggregateResult, QueryConflictPaths, QueryGroupMap, QueryOne, QueryOptions, QuerySearch, QueryUpdateResult, TransactionOptions, Type, UpdatePayload } from '../type/index.js';
 /**
  * Base pool: dialect id and behavior come only from the `dialect` instance (see {@link QuerierPool}).
  */
@@ -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>;
     /**
@@ -24,9 +27,26 @@ export declare abstract class AbstractQuerierPool<Q extends Querier, D extends A
     findOneById<E extends object>(entity: Type<E>, id: IdValue<E>, q?: QueryOne<E>, opts?: QueryOptions): Promise<E | undefined>;
     findOne<E extends object>(entity: Type<E>, q: QueryOne<E>, opts?: QueryOptions): Promise<E | undefined>;
     findMany<E extends object>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): Promise<E[]>;
+    /**
+     * The connection outlives the call here: it is held until the iterator is drained or closed by a
+     * `break`/`throw`. Abandoning the iterator instead leaks it until GC, so consume it in a `for await`.
+     */
+    findManyStream<E extends object>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): AsyncGenerator<E>;
     findManyAndCount<E extends object>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): Promise<[E[], number]>;
     count<E extends object>(entity: Type<E>, q?: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
     aggregate<E extends object, const G extends QueryGroupMap<E>, const A extends QueryAggMap<E>>(entity: Type<E>, q: QueryAggregate<E, G, A>, opts?: QueryOptions): Promise<QueryAggregateResult<E, G, A>[]>;
+    insertOne<E extends object>(entity: Type<E>, payload: E): Promise<IdValue<E> | undefined>;
+    insertMany<E extends object>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
+    updateOneById<E extends object>(entity: Type<E>, id: IdValue<E>, payload: UpdatePayload<E>, opts?: QueryOptions): Promise<number>;
+    updateMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, payload: UpdatePayload<E>, opts?: QueryOptions): Promise<number>;
+    upsertOne<E extends object>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): Promise<QueryUpdateResult>;
+    upsertMany<E extends object>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E[]): Promise<QueryUpdateResult>;
+    saveOne<E extends object>(entity: Type<E>, payload: E): Promise<IdValue<E>>;
+    saveMany<E extends object>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
+    deleteOneById<E extends object>(entity: Type<E>, id: IdValue<E>, opts?: QueryOptions): Promise<number>;
+    deleteMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
+    restoreOneById<E extends object>(entity: Type<E>, id: IdValue<E>): Promise<number>;
+    restoreMany<E extends object>(entity: Type<E>, q: QuerySearch<E>): Promise<number>;
     /**
      * end the pool.
      */

package/dist/querier/abstractQuerierPool.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { withContext } from '../context/context.js';
 /**
  * Base pool: dialect id and behavior come only from the `dialect` instance (see {@link QuerierPool}).
@@ -11,10 +63,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.
@@ -41,6 +95,26 @@ export class AbstractQuerierPool {
     findMany(entity, q, opts) {
         return this.withQuerier((querier) => querier.findMany(entity, q, opts));
     }
+    /**
+     * The connection outlives the call here: it is held until the iterator is drained or closed by a
+     * `break`/`throw`. Abandoning the iterator instead leaks it until GC, so consume it in a `for await`.
+     */
+    async *findManyStream(entity, q, opts) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const querier = __addDisposableResource(env_1, await this.getQuerier(), true);
+            yield* querier.findManyStream(entity, q, opts);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
     findManyAndCount(entity, q, opts) {
         return this.withQuerier((querier) => querier.findManyAndCount(entity, q, opts));
     }
@@ -50,4 +124,40 @@ export class AbstractQuerierPool {
     aggregate(entity, q, opts) {
         return this.withQuerier((querier) => querier.aggregate(entity, q, opts));
     }
+    insertOne(entity, payload) {
+        return this.withQuerier((querier) => querier.insertOne(entity, payload));
+    }
+    insertMany(entity, payload) {
+        return this.withQuerier((querier) => querier.insertMany(entity, payload));
+    }
+    updateOneById(entity, id, payload, opts) {
+        return this.withQuerier((querier) => querier.updateOneById(entity, id, payload, opts));
+    }
+    updateMany(entity, q, payload, opts) {
+        return this.withQuerier((querier) => querier.updateMany(entity, q, payload, opts));
+    }
+    upsertOne(entity, conflictPaths, payload) {
+        return this.withQuerier((querier) => querier.upsertOne(entity, conflictPaths, payload));
+    }
+    upsertMany(entity, conflictPaths, payload) {
+        return this.withQuerier((querier) => querier.upsertMany(entity, conflictPaths, payload));
+    }
+    saveOne(entity, payload) {
+        return this.withQuerier((querier) => querier.saveOne(entity, payload));
+    }
+    saveMany(entity, payload) {
+        return this.withQuerier((querier) => querier.saveMany(entity, payload));
+    }
+    deleteOneById(entity, id, opts) {
+        return this.withQuerier((querier) => querier.deleteOneById(entity, id, opts));
+    }
+    deleteMany(entity, q, opts) {
+        return this.withQuerier((querier) => querier.deleteMany(entity, q, opts));
+    }
+    restoreOneById(entity, id) {
+        return this.withQuerier((querier) => querier.restoreOneById(entity, id));
+    }
+    restoreMany(entity, q) {
+        return this.withQuerier((querier) => querier.restoreMany(entity, q));
+    }
 }

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>;
     /**