uql-orm 0.32.1 → 0.33.0

package/dist/express/querierMiddleware.d.ts

@@ -7,5 +7,5 @@ export type MiddlewareOptions = RequestHandlerOptions<Request>;
  * composes with custom routes; errors go to `next(err)` so user error
  * middleware (e.g. {@link errorHandler}) keeps working.
  */
-export declare function querierMiddleware(opts?: MiddlewareOptions): Router;
+export declare function querierMiddleware(opts: MiddlewareOptions): Router;
 export declare function errorHandler(err: unknown, _req: Request, res: Response, _next: NextFunction): void;

package/dist/express/querierMiddleware.js

@@ -7,7 +7,7 @@ import { createRequestHandler } from '../http/handler.js';
  * composes with custom routes; errors go to `next(err)` so user error
  * middleware (e.g. {@link errorHandler}) keeps working.
  */
-export function querierMiddleware(opts = {}) {
+export function querierMiddleware(opts) {
     const handle = createRequestHandler(opts);
     const router = expressRouter();
     router.all('/:entityPath{/:subPath}', async (req, res, next) => {

package/dist/http/fetchHandler.d.ts

@@ -10,4 +10,4 @@ export type FetchHandlerOptions = RequestHandlerOptions<Request> & {
  * `(request: Request) => Promise<Response>` in any fetch-native runtime
  * (Hono, Next.js route handlers, Bun.serve, Deno.serve, Cloudflare Workers, SvelteKit).
  */
-export declare function createFetchHandler(opts?: FetchHandlerOptions): (request: Request) => Promise<Response>;
+export declare function createFetchHandler(opts: FetchHandlerOptions): (request: Request) => Promise<Response>;

package/dist/http/fetchHandler.js

@@ -5,7 +5,7 @@ import { createRequestHandler } from './handler.js';
  * `(request: Request) => Promise<Response>` in any fetch-native runtime
  * (Hono, Next.js route handlers, Bun.serve, Deno.serve, Cloudflare Workers, SvelteKit).
  */
-export function createFetchHandler(opts = {}) {
+export function createFetchHandler(opts) {
     const { basePath = '', ...handlerOpts } = opts;
     const handle = createRequestHandler(handlerOpts);
     return async (request) => {

package/dist/http/handler.d.ts

@@ -1,4 +1,4 @@
-import type { EntityMeta, Query, Type, UqlContext } from '../type/index.js';
+import type { EntityMeta, QuerierPool, Query, Type, UqlContext } from '../type/index.js';
 import { type CrudOperation, type HttpMethod, type RequestSuccessResponse } from './contract.js';
 /**
  * Framework-normalized request: adapters (express, fetch, ...) reduce their native
@@ -76,6 +76,12 @@ export type RequestHandlerOptions<Ctx = unknown> = {
      * automatically. Derive tenant/auth from a verified source (session, JWT) - never trust the client.
      */
     getContext?: (context: Ctx) => UqlContext | undefined | Promise<UqlContext | undefined>;
+    /**
+     * The pool this handler runs on. A function is called per request, after `getContext`, with the
+     * adapter's request and the context that resolved from it - which is what lets one deployment
+     * serve a database per tenant, where a process-wide default could only serve one.
+     */
+    pool: QuerierPool | ((context: Ctx, appContext: UqlContext) => QuerierPool | Promise<QuerierPool>);
 };
 /**
  * Returns `undefined` synchronously for an unknown entity or route so adapters can fall through
@@ -83,4 +89,4 @@ export type RequestHandlerOptions<Ctx = unknown> = {
  * (e.g. `toErrorResponse`).
  */
 export type RequestHandler<Ctx = unknown> = (req: HandlerRequest<Ctx>) => Promise<HandlerResponse> | undefined;
-export declare function createRequestHandler<Ctx = unknown>(opts?: RequestHandlerOptions<Ctx>): RequestHandler<Ctx>;
+export declare function createRequestHandler<Ctx = unknown>(opts: RequestHandlerOptions<Ctx>): RequestHandler<Ctx>;

package/dist/http/handler.js

@@ -1,10 +1,9 @@
 import { withContext } from '../context/context.js';
 import { getEntities, getMeta } from '../entity/index.js';
-import { getQuerierPool } from '../options.js';
 import { entityPath, matchRoute, } from './contract.js';
 import { parseQueryParams } from './query.js';
-export function createRequestHandler(opts = {}) {
-    const { include, exclude, pre, preSave, preFilter, post, getContext } = opts;
+export function createRequestHandler(opts) {
+    const { include, exclude, pre, preSave, preFilter, post, getContext, pool } = opts;
     let entities = include ?? getEntities();
     if (exclude) {
         entities = entities.filter((entity) => !exclude.includes(entity));
@@ -38,6 +37,13 @@ export function createRequestHandler(opts = {}) {
             context: req.context,
         };
         const appContext = (await getContext?.(req.context)) ?? {};
+        // Resolved where the statement runs, not up front: a hook that aborts the request must not reach
+        // the pool at all, and picking one per request may cost a lookup this request will never use.
+        const resolvePool = async () => (typeof pool === 'function' ? pool(req.context, appContext) : pool);
+        /** Read paths: the pool acquires and releases; nothing here owns a connection. */
+        const withQuerier = async (fn) => (await resolvePool()).withQuerier(fn);
+        /** Write paths: one transaction per request, so a cascade that fails takes its parent with it. */
+        const withTransaction = async (fn) => (await resolvePool()).transaction(fn);
         // Scope the whole request (hooks + querier + relation/cascade queries) to the resolved context.
         return withContext(appContext, async () => {
             await pre?.(hookCtx);
@@ -135,10 +141,6 @@ export function createRequestHandler(opts = {}) {
 function ok(body) {
     return { status: 200, body };
 }
-/** Read paths: the pool acquires and releases; nothing here owns a connection. */
-const withQuerier = (fn) => getQuerierPool().withQuerier(fn);
-/** Write paths: same, plus commit on success and rollback on failure. */
-const withTransaction = (fn) => getQuerierPool().transaction(fn);
 function buildIdQuery(meta, id, query) {
     const idKey = meta.id;
     const where = query.$where;

package/dist/index.d.ts

@@ -2,7 +2,6 @@ export * from './context/context.js';
 export * from './dialect/index.js';
 export * from './entity/index.js';
 export * from './namingStrategy/index.js';
-export * from './options.js';
 export * from './querier/index.js';
 export * from './type/index.js';
 export * from './util/index.js';

package/dist/index.js

@@ -2,7 +2,6 @@ export * from './context/context.js';
 export * from './dialect/index.js';
 export * from './entity/index.js';
 export * from './namingStrategy/index.js';
-export * from './options.js';
 export * from './querier/index.js';
 export * from './type/index.js';
 export * from './util/index.js';

package/dist/nestjs/uqlModule.d.ts

@@ -31,9 +31,10 @@ export type UqlModuleAsyncOptions<Req = unknown> = UqlModuleCommon<Req> & {
     readonly inject?: FactoryProvider['inject'];
 };
 /**
- * NestJS integration: provides the pool via DI, sets it as UQL's default pool (so `getQuerier()`,
- * `querierMiddleware` (express platform) and `createFetchHandler` work unchanged), optionally scopes
+ * NestJS integration: provides the pool via DI under {@link UQL_QUERIER_POOL}, optionally scopes
  * every request to a {@link UqlContext} (multi-tenancy), and ends the pool on application shutdown.
+ * Inject the pool where you need it, `querierMiddleware`/`createFetchHandler` included: those take
+ * it as an option rather than reading a process-wide default.
  */
 export declare class UqlModule {
     /** Configure with an already-built pool. */

package/dist/nestjs/uqlModule.js

@@ -34,7 +34,6 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { Module, } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
-import { setQuerierPool } from '../options.js';
 import { UqlContextInterceptor } from './uqlContextInterceptor.js';
 /**
  * Injection token for the configured {@link QuerierPool} - for injecting into your own
@@ -62,9 +61,10 @@ class UqlPoolLifecycle {
     }
 }
 /**
- * NestJS integration: provides the pool via DI, sets it as UQL's default pool (so `getQuerier()`,
- * `querierMiddleware` (express platform) and `createFetchHandler` work unchanged), optionally scopes
+ * NestJS integration: provides the pool via DI under {@link UQL_QUERIER_POOL}, optionally scopes
  * every request to a {@link UqlContext} (multi-tenancy), and ends the pool on application shutdown.
+ * Inject the pool where you need it, `querierMiddleware`/`createFetchHandler` included: those take
+ * it as an option rather than reading a process-wide default.
  */
 let UqlModule = (() => {
     let _classDecorators = [Module({})];
@@ -82,18 +82,13 @@ let 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;
-                },
+                useFactory,
                 inject,
             };
             return UqlModule.build(global, poolProvider, getContext, imports);

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "JSON-native TypeScript ORM for Node.js, Bun and Deno. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.32.1",
+  "version": "0.33.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -27,7 +27,6 @@
     "./util": "./dist/util/index.js",
     "./namingStrategy": "./dist/namingStrategy/index.js",
     "./migrate": "./dist/migrate/index.js",
-    "./options": "./dist/options.js",
     "./mysql": "./dist/mysql/index.js",
     "./postgres": "./dist/postgres/index.js",
     "./postgres/wireCapabilities": "./dist/postgres/postgresWireDriverCapabilities.js",

package/dist/options.d.ts

@@ -1,4 +0,0 @@
-import type { Querier, QuerierPool } from './type/index.js';
-export declare function setQuerierPool<T extends QuerierPool = QuerierPool>(pool: T): void;
-export declare function getQuerierPool(): QuerierPool;
-export declare function getQuerier(): Promise<Querier>;

package/dist/options.js

@@ -1,13 +0,0 @@
-let defaultPool;
-export function setQuerierPool(pool) {
-    defaultPool = pool;
-}
-export function getQuerierPool() {
-    if (!defaultPool) {
-        throw new TypeError('A default querier-pool has to be set first');
-    }
-    return defaultPool;
-}
-export function getQuerier() {
-    return defaultPool.getQuerier();
-}