uql-orm 0.22.0 → 0.23.0

package/dist/mongo/mongodbQuerier.js

@@ -1,15 +1,5 @@
-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 _a;
 import { getMeta } from '../entity/index.js';
-import { AbstractQuerier, enrichError, Log, Serialized } from '../querier/index.js';
+import { AbstractQuerier, enrichError } from '../querier/index.js';
 import { clone, getKeys, getRelationRequestSummary, getSoftDeleteValue, hasKeys, throwNoPendingTransaction, throwPendingTransaction, withoutSoftDeleteFilter, } from '../util/index.js';
 export class MongodbQuerier extends AbstractQuerier {
     dialect;
@@ -23,34 +13,38 @@ export class MongodbQuerier extends AbstractQuerier {
         this.extra = extra;
     }
     async execute(task) {
-        return task(this.session);
+        return this.serialize(async () => {
+            return task(this.session);
+        });
     }
     async internalFindMany(entity, q, opts) {
-        const meta = getMeta(entity);
-        const vectorSort = this.dialect.extractVectorSort(q.$sort);
-        let documents;
-        if (vectorSort) {
-            const pipeline = this.buildVectorPipeline(entity, q, vectorSort, opts);
-            documents = await this.runPipeline(entity, meta, pipeline);
-            // to-many relations need their own query, exactly as in the non-vector path
-            await this.fillToManyRelations(entity, documents, q.$populate);
-        }
-        else {
-            const relationSummary = getRelationRequestSummary(meta, q.$populate);
-            // A relation condition needs `$lookup`, so it forces the aggregation path just like populating
-            // one does; a plain `find` cursor cannot express it.
-            if (relationSummary.requestedKeys.length || this.dialect.constrainsRelations(entity, q.$where)) {
-                const pipeline = this.dialect.aggregationPipeline(entity, q, relationSummary, opts);
+        return this.timed('internalFindMany', undefined, async () => {
+            const meta = getMeta(entity);
+            const vectorSort = this.dialect.extractVectorSort(q.$sort);
+            let documents;
+            if (vectorSort) {
+                const pipeline = this.buildVectorPipeline(entity, q, vectorSort, opts);
                 documents = await this.runPipeline(entity, meta, pipeline);
+                // to-many relations need their own query, exactly as in the non-vector path
                 await this.fillToManyRelations(entity, documents, q.$populate);
             }
             else {
-                const cursor = this.buildFindCursor(entity, q, opts);
-                documents = await this.execute(() => cursor.toArray());
-                documents = this.dialect.normalizeIds(meta, documents) || [];
+                const relationSummary = getRelationRequestSummary(meta, q.$populate);
+                // A relation condition needs `$lookup`, so it forces the aggregation path just like populating
+                // one does; a plain `find` cursor cannot express it.
+                if (relationSummary.requestedKeys.length || this.dialect.constrainsRelations(entity, q.$where)) {
+                    const pipeline = this.dialect.aggregationPipeline(entity, q, relationSummary, opts);
+                    documents = await this.runPipeline(entity, meta, pipeline);
+                    await this.fillToManyRelations(entity, documents, q.$populate);
+                }
+                else {
+                    const cursor = this.buildFindCursor(entity, q, opts);
+                    documents = await this.execute(() => cursor.toArray());
+                    documents = this.dialect.normalizeIds(meta, documents) || [];
+                }
             }
-        }
-        return documents;
+            return documents;
+        });
     }
     async *internalFindManyStream(entity, q, opts) {
         const meta = getMeta(entity);
@@ -71,7 +65,7 @@ export class MongodbQuerier extends AbstractQuerier {
             }
         }
         catch (err) {
-            enrichError(err, this.logger, 'internalFindManyStream');
+            throw enrichError(err, this.logger, 'internalFindManyStream');
         }
     }
     buildScalarProjection(entity, q) {
@@ -144,22 +138,26 @@ export class MongodbQuerier extends AbstractQuerier {
         return pipeline;
     }
     async internalAggregate(entity, q, opts) {
-        const pipeline = this.dialect.buildAggregateStages(entity, q, opts);
-        // biome-ignore lint/suspicious/noExplicitAny: aggregate result type matches QueryAggregateResult at runtime but TS can't verify
-        return this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
+        return this.timed('internalAggregate', undefined, async () => {
+            const pipeline = this.dialect.buildAggregateStages(entity, q, opts);
+            // biome-ignore lint/suspicious/noExplicitAny: aggregate result type matches QueryAggregateResult at runtime but TS can't verify
+            return this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
+        });
     }
     async internalCount(entity, qm = {}, opts) {
-        if (this.dialect.constrainsRelations(entity, qm.$where)) {
-            const { stages, filter } = this.dialect.whereWithRelations(entity, qm.$where, opts);
-            const [counted] = await this.execute((session) => this.collection(entity)
-                .aggregate([...stages, { $match: filter }, { $count: 'n' }], { session })
-                .toArray());
-            return counted?.n ?? 0;
-        }
-        const filter = this.dialect.where(entity, qm.$where, opts);
-        return this.execute((session) => this.collection(entity).countDocuments(filter, {
-            session,
-        }));
+        return this.timed('internalCount', undefined, async () => {
+            if (this.dialect.constrainsRelations(entity, qm.$where)) {
+                const { stages, filter } = this.dialect.whereWithRelations(entity, qm.$where, opts);
+                const [counted] = await this.execute((session) => this.collection(entity)
+                    .aggregate([...stages, { $match: filter }, { $count: 'n' }], { session })
+                    .toArray());
+                return counted?.n ?? 0;
+            }
+            const filter = this.dialect.where(entity, qm.$where, opts);
+            return this.execute((session) => this.collection(entity).countDocuments(filter, {
+                session,
+            }));
+        });
     }
     /**
      * The `_id`s a search matches. Writes need this whenever the `$where` constrains a relation, since a
@@ -174,35 +172,39 @@ export class MongodbQuerier extends AbstractQuerier {
         return (this.dialect.normalizeIds(meta, founds) || []).map((found) => found[meta.id]);
     }
     async internalInsertMany(entity, payloads) {
-        if (!payloads?.length) {
-            return [];
-        }
-        payloads = clone(payloads);
-        const meta = getMeta(entity);
-        const persistables = this.dialect.getPersistables(meta, payloads, 'onInsert');
-        const { insertedIds } = await this.execute((session) => this.collection(entity).insertMany(persistables, { session }));
-        const ids = Object.values(insertedIds);
-        for (const [index, it] of payloads.entries()) {
-            it[meta.id] = ids[index];
-        }
-        await this.insertRelations(entity, payloads);
-        return ids;
+        return this.timed('internalInsertMany', undefined, async () => {
+            if (!payloads?.length) {
+                return [];
+            }
+            payloads = clone(payloads);
+            const meta = getMeta(entity);
+            const persistables = this.dialect.getPersistables(meta, payloads, 'onInsert');
+            const { insertedIds } = await this.execute((session) => this.collection(entity).insertMany(persistables, { session }));
+            const ids = Object.values(insertedIds);
+            for (const [index, it] of payloads.entries()) {
+                it[meta.id] = ids[index];
+            }
+            await this.insertRelations(entity, payloads);
+            return ids;
+        });
     }
     async internalUpdateMany(entity, qm, payload, opts) {
-        payload = clone(payload);
-        const meta = getMeta(entity);
-        const persistable = this.dialect.getPersistable(meta, payload, 'onUpdate');
-        // An `updateMany` filter cannot host a `$lookup`, so a relation condition is resolved to ids first.
-        const where = this.dialect.constrainsRelations(entity, qm.$where)
-            ? { _id: { $in: await this.matchedIds(entity, qm.$where, opts) } }
-            : this.dialect.where(entity, qm.$where, opts);
-        // Maps JSON operators ($set/$unset/$push/$pull) onto their native MongoDB equivalents.
-        const update = this.dialect.getUpdateFilter(persistable);
-        const { matchedCount } = await this.execute((session) => this.collection(entity).updateMany(where, update, {
-            session,
-        }));
-        await this.updateRelations(entity, qm, payload, opts);
-        return matchedCount;
+        return this.timed('internalUpdateMany', undefined, async () => {
+            payload = clone(payload);
+            const meta = getMeta(entity);
+            const persistable = this.dialect.getPersistable(meta, payload, 'onUpdate');
+            // An `updateMany` filter cannot host a `$lookup`, so a relation condition is resolved to ids first.
+            const where = this.dialect.constrainsRelations(entity, qm.$where)
+                ? { _id: { $in: await this.matchedIds(entity, qm.$where, opts) } }
+                : this.dialect.where(entity, qm.$where, opts);
+            // Maps JSON operators ($set/$unset/$push/$pull) onto their native MongoDB equivalents.
+            const update = this.dialect.getUpdateFilter(persistable);
+            const { matchedCount } = await this.execute((session) => this.collection(entity).updateMany(where, update, {
+                session,
+            }));
+            await this.updateRelations(entity, qm, payload, opts);
+            return matchedCount;
+        });
     }
     buildConflictFilter(entity, conflictPaths, item) {
         const where = getKeys(conflictPaths).reduce((acc, key) => {
@@ -212,77 +214,83 @@ export class MongodbQuerier extends AbstractQuerier {
         return this.dialect.where(entity, where);
     }
     async upsertOne(entity, conflictPaths, payload) {
-        payload = clone(payload);
-        const meta = getMeta(entity);
-        const persistable = this.dialect.getPersistable(meta, payload, 'onInsert');
-        const filter = this.buildConflictFilter(entity, conflictPaths, payload);
-        const update = { $set: persistable };
-        const res = await this.execute((session) => this.collection(entity).findOneAndUpdate(filter, update, {
-            upsert: true,
-            returnDocument: 'after',
-            includeResultMetadata: true,
-            session,
-        }));
-        const firstId = res?.value?._id;
-        // `updatedExisting` is false when a new document was inserted (upserted).
-        const created = res?.lastErrorObject?.['updatedExisting'] === false;
-        return { firstId, changes: firstId ? 1 : 0, created };
+        return this.timed('upsertOne', undefined, async () => {
+            payload = clone(payload);
+            const meta = getMeta(entity);
+            const persistable = this.dialect.getPersistable(meta, payload, 'onInsert');
+            const filter = this.buildConflictFilter(entity, conflictPaths, payload);
+            const update = { $set: persistable };
+            const res = await this.execute((session) => this.collection(entity).findOneAndUpdate(filter, update, {
+                upsert: true,
+                returnDocument: 'after',
+                includeResultMetadata: true,
+                session,
+            }));
+            const firstId = res?.value?._id;
+            // `updatedExisting` is false when a new document was inserted (upserted).
+            const created = res?.lastErrorObject?.['updatedExisting'] === false;
+            return { firstId, changes: firstId ? 1 : 0, created };
+        });
     }
     async upsertMany(entity, conflictPaths, payload) {
-        if (!payload?.length) {
-            return { changes: 0 };
-        }
-        payload = clone(payload);
-        const meta = getMeta(entity);
-        const operations = payload.map((item) => {
-            const persistable = this.dialect.getPersistable(meta, item, 'onInsert');
-            const filter = this.buildConflictFilter(entity, conflictPaths, item);
-            const update = { $set: persistable };
-            return {
-                updateOne: {
-                    filter,
-                    update,
-                    upsert: true,
-                },
-            };
+        return this.timed('upsertMany', undefined, async () => {
+            if (!payload?.length) {
+                return { changes: 0 };
+            }
+            payload = clone(payload);
+            const meta = getMeta(entity);
+            const operations = payload.map((item) => {
+                const persistable = this.dialect.getPersistable(meta, item, 'onInsert');
+                const filter = this.buildConflictFilter(entity, conflictPaths, item);
+                const update = { $set: persistable };
+                return {
+                    updateOne: {
+                        filter,
+                        update,
+                        upsert: true,
+                    },
+                };
+            });
+            const res = await this.execute((session) => this.collection(entity).bulkWrite(operations, { session }));
+            const changes = (res.upsertedCount ?? 0) + (res.modifiedCount ?? 0);
+            // `upsertedIds` only covers newly-inserted documents (keyed by operation index); a matched and
+            // updated document's `_id` isn't in the response, so it's simply not represented here - same
+            // "exact where knowable, absent otherwise" convention `RETURNING`-based SQL dialects use for
+            // rows that hit `DO NOTHING`.
+            const ids = Object.values(res.upsertedIds);
+            return { changes, ids, firstId: ids[0] };
         });
-        const res = await this.execute((session) => this.collection(entity).bulkWrite(operations, { session }));
-        const changes = (res.upsertedCount ?? 0) + (res.modifiedCount ?? 0);
-        // `upsertedIds` only covers newly-inserted documents (keyed by operation index); a matched and
-        // updated document's `_id` isn't in the response, so it's simply not represented here - same
-        // "exact where knowable, absent otherwise" convention `RETURNING`-based SQL dialects use for
-        // rows that hit `DO NOTHING`.
-        const ids = Object.values(res.upsertedIds);
-        return { changes, ids, firstId: ids[0] };
     }
     async internalDeleteMany(entity, qm, opts = {}) {
-        const meta = getMeta(entity);
-        // Soft-delete (stamp) unless `hardDelete` is requested or the entity has no soft-delete field.
-        const field = !opts.hardDelete && meta.softDelete ? meta.fields[meta.softDelete] : undefined;
-        // Hard delete targets matching rows regardless of soft-delete state (keeps other filters).
-        const findOpts = field ? opts : { ...opts, filters: withoutSoftDeleteFilter(opts.filters) };
-        // Delete has always resolved its ids first (it stamps or removes them by `_id`), so a relation
-        // condition needs nothing extra here.
-        const ids = await this.matchedIds(entity, qm.$where, findOpts);
-        if (!ids.length) {
-            return 0;
-        }
-        let changes;
-        if (field) {
-            // Stamp the mapped column: reads filter on it, so a `@Field({ name })` mismatch here would
-            // report a successful delete and leave the row visible.
-            const softDeleteColumn = this.dialect.resolveColumnName(meta.softDelete, field);
-            const updateResult = await this.execute((session) => this.collection(entity).updateMany({ _id: { $in: ids } }, { $set: { [softDeleteColumn]: getSoftDeleteValue(field) } }, {
-                session,
-            }));
-            changes = updateResult.matchedCount;
-        }
-        else {
-            const deleteResult = await this.execute((session) => this.collection(entity).deleteMany({ _id: { $in: ids } }, { session }));
-            changes = deleteResult.deletedCount;
-        }
-        await this.deleteRelations(entity, ids, opts);
-        return changes;
+        return this.timed('internalDeleteMany', undefined, async () => {
+            const meta = getMeta(entity);
+            // Soft-delete (stamp) unless `hardDelete` is requested or the entity has no soft-delete field.
+            const field = !opts.hardDelete && meta.softDelete ? meta.fields[meta.softDelete] : undefined;
+            // Hard delete targets matching rows regardless of soft-delete state (keeps other filters).
+            const findOpts = field ? opts : { ...opts, filters: withoutSoftDeleteFilter(opts.filters) };
+            // Delete has always resolved its ids first (it stamps or removes them by `_id`), so a relation
+            // condition needs nothing extra here.
+            const ids = await this.matchedIds(entity, qm.$where, findOpts);
+            if (!ids.length) {
+                return 0;
+            }
+            let changes;
+            if (field) {
+                // Stamp the mapped column: reads filter on it, so a `@Field({ name })` mismatch here would
+                // report a successful delete and leave the row visible.
+                const softDeleteColumn = this.dialect.resolveColumnName(meta.softDelete, field);
+                const updateResult = await this.execute((session) => this.collection(entity).updateMany({ _id: { $in: ids } }, { $set: { [softDeleteColumn]: getSoftDeleteValue(field) } }, {
+                    session,
+                }));
+                changes = updateResult.matchedCount;
+            }
+            else {
+                const deleteResult = await this.execute((session) => this.collection(entity).deleteMany({ _id: { $in: ids } }, { session }));
+                changes = deleteResult.deletedCount;
+            }
+            await this.deleteRelations(entity, ids, opts);
+            return changes;
+        });
     }
     get hasOpenTransaction() {
         return !!this.session?.inTransaction();
@@ -295,27 +303,33 @@ export class MongodbQuerier extends AbstractQuerier {
         return this.conn.db();
     }
     async beginTransaction(_opts) {
-        if (this.hasOpenTransaction) {
-            throwPendingTransaction();
-        }
-        this.logger.logInfo('beginTransaction');
-        await this.session?.endSession();
-        this.session = this.conn.startSession();
-        this.session.startTransaction();
+        return this.serialize(async () => {
+            if (this.hasOpenTransaction) {
+                throwPendingTransaction();
+            }
+            this.logger.logInfo('beginTransaction');
+            await this.session?.endSession();
+            this.session = this.conn.startSession();
+            this.session.startTransaction();
+        });
     }
     async commitTransaction() {
-        if (!this.hasOpenTransaction) {
-            throwNoPendingTransaction();
-        }
-        this.logger.logInfo('commitTransaction');
-        await this.session.commitTransaction();
+        return this.serialize(async () => {
+            if (!this.hasOpenTransaction) {
+                throwNoPendingTransaction();
+            }
+            this.logger.logInfo('commitTransaction');
+            await this.session.commitTransaction();
+        });
     }
     async rollbackTransaction() {
-        if (!this.hasOpenTransaction) {
-            throwNoPendingTransaction();
-        }
-        this.logger.logInfo('rollbackTransaction');
-        await this.session.abortTransaction();
+        return this.serialize(async () => {
+            if (!this.hasOpenTransaction) {
+                throwNoPendingTransaction();
+            }
+            this.logger.logInfo('rollbackTransaction');
+            await this.session.abortTransaction();
+        });
     }
     async internalRelease() {
         if (this.hasOpenTransaction) {
@@ -325,75 +339,3 @@ export class MongodbQuerier extends AbstractQuerier {
         this.session = undefined;
     }
 }
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Function]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "execute", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "internalFindMany", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "internalAggregate", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "internalCount", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Array]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "internalInsertMany", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "internalUpdateMany", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, typeof (_a = typeof E !== "undefined" && E) === "function" ? _a : Object]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "upsertOne", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Array]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "upsertMany", null);
-__decorate([
-    Log(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "internalDeleteMany", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "beginTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "commitTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], MongodbQuerier.prototype, "rollbackTransaction", null);

package/dist/nestjs/uqlContextInterceptor.js

@@ -1,11 +1,36 @@
-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 __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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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;
 };
 import { Injectable } from '@nestjs/common';
 import { Observable } from 'rxjs';
@@ -15,19 +40,30 @@ import { withContext } from '../context/context.js';
  * are scoped automatically for every query in the request - including relations, cascades, and
  * `@Transactional` services. Wired for you by {@link UqlModule.forRoot} when you pass `getContext`.
  */
-let UqlContextInterceptor = class UqlContextInterceptor {
-    getContext;
-    constructor(getContext) {
-        this.getContext = getContext;
-    }
-    intercept(execContext, next) {
-        const context = this.getContext(execContext.switchToHttp().getRequest()) ?? {};
-        // Subscribe inside the context so the handler's async chain (and its queries) inherit it.
-        return new Observable((subscriber) => withContext(context, () => next.handle().subscribe(subscriber)));
-    }
-};
-UqlContextInterceptor = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [Function])
-], UqlContextInterceptor);
+let UqlContextInterceptor = (() => {
+    let _classDecorators = [Injectable()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var UqlContextInterceptor = 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);
+            UqlContextInterceptor = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        getContext;
+        constructor(getContext) {
+            this.getContext = getContext;
+        }
+        intercept(execContext, next) {
+            const context = this.getContext(execContext.switchToHttp().getRequest()) ?? {};
+            // Subscribe inside the context so the handler's async chain (and its queries) inherit it.
+            return new Observable((subscriber) => withContext(context, () => next.handle().subscribe(subscriber)));
+        }
+    };
+    return UqlContextInterceptor = _classThis;
+})();
 export { UqlContextInterceptor };

package/dist/nestjs/uqlModule.d.ts

@@ -1,4 +1,4 @@
-import { type DynamicModule, type FactoryProvider, type OnApplicationShutdown } from '@nestjs/common';
+import { type DynamicModule, type FactoryProvider } from '@nestjs/common';
 import type { QuerierPool, UqlContext } from '../type/index.js';
 /**
  * Injection token for the configured {@link QuerierPool} - for injecting into your own
@@ -30,16 +30,7 @@ export type UqlModuleAsyncOptions<Req = unknown> = UqlModuleCommon<Req> & {
     /** Providers to inject into `useFactory`. */
     readonly inject?: FactoryProvider['inject'];
 };
-/**
- * NestJS integration: provides the pool via DI, sets it as UQL's default pool (so `getQuerier()`,
- * `querierMiddleware` (express platform), `createFetchHandler`, and `@Transactional` work unchanged),
- * optionally scopes every request to a {@link UqlContext} (multi-tenancy), and ends the pool on
- * application shutdown.
- */
-export declare class UqlModule implements OnApplicationShutdown {
-    private readonly pool;
-    constructor(pool: QuerierPool);
-    onApplicationShutdown(): Promise<void>;
+export declare class UqlModule {
     /** Configure with an already-built pool. */
     static forRoot<Req = unknown>({ pool, global, getContext }: UqlModuleOptions<Req>): DynamicModule;
     /** Configure with a pool built asynchronously from injected providers (e.g. `ConfigService`). */