uql-orm 0.22.0 → 0.24.0

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();
@@ -75,6 +64,9 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         if (toManyKeys.length) {
             throw new TypeError(`findManyStream does not load to-many relations (${toManyKeys.join(', ')}). Use findMany so fillToManyRelations can run, or omit those keys from the stream query.`);
         }
+        // The one path that does not go through `all`/`run`, so it connects on its own: streaming first on
+        // a freshly acquired querier used to reach `getConn()` with nothing acquired.
+        await this.lazyConnect();
         const ctx = this.dialect.createContext();
         this.dialect.find(ctx, entity, q, opts);
         const normalizedParams = this.dialect.normalizeValues(ctx.values);
@@ -86,7 +78,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 +235,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;

package/dist/querier/querierContext.js

@@ -0,0 +1,42 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * The querier `@Transactional()` opened for the current async flow.
+ *
+ * Separate from the `UqlContext` storage in `context/context.ts` on purpose: that one is remapped to a
+ * synchronous browser shim which cannot propagate across `await`, and a querier handle must. Nothing in
+ * a browser bundle opens a transaction, so this stays server-only and `verify-dist` keeps it out of the
+ * browser-facing graph.
+ */
+const querierStorage = new AsyncLocalStorage();
+/** Runs `callback` with `querier` as the ambient one, for the whole async flow beneath it. */
+export function withQuerierContext(querier, callback) {
+    return querierStorage.run(querier, callback);
+}
+/**
+ * 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 function currentQuerier() {
+    const querier = querierStorage.getStore();
+    if (!querier) {
+        throw new TypeError('currentQuerier() found no active querier. Call it inside a @Transactional() method, or take a querier ' +
+            'from the pool yourself with `await using querier = await pool.getQuerier()`.');
+    }
+    return querier;
+}
+/** The ambient querier, or `undefined` outside a transaction. For callers that can work without one. */
+export function currentQuerierIfAny() {
+    return querierStorage.getStore();
+}

package/dist/querier/queryError.d.ts

@@ -0,0 +1,22 @@
+import type { LoggerWrapper } from '../util/logger.js';
+/**
+ * A driver error enriched with context by {@link enrichError}. `query` is always attached; `values`
+ * only when the querier's logger is configured to surface them (see {@link enrichError}) - they can
+ * carry sensitive data (PII, tokens, etc.) and would otherwise leak into whatever error-tracking
+ * pipeline (Sentry, console.error, ...) serializes the error, without the developer opting in.
+ */
+export interface QueryError extends Error {
+    query?: string;
+    values?: unknown[];
+}
+/**
+ * Tags `err` with the query it failed on (as {@link QueryError}) and hands it back for the caller to
+ * throw. `values` is only attached when `logger?.willLogValues()` is true, i.e. the app already has
+ * query values surfacing somewhere (query-level or slow-query logging), so attaching them here does not
+ * introduce a new leak surface. Shared by every query call site (timed queries, streams, transaction
+ * statements) so the logic lives in one place.
+ *
+ * Returns rather than throws so `throw enrichError(...)` reads as the control flow it is, which also
+ * means callers need no `never` annotation and no unreachable-code suppression.
+ */
+export declare function enrichError(err: unknown, logger: LoggerWrapper | undefined, query: string, values?: unknown[]): unknown;

package/dist/querier/queryError.js

@@ -0,0 +1,20 @@
+/**
+ * Tags `err` with the query it failed on (as {@link QueryError}) and hands it back for the caller to
+ * throw. `values` is only attached when `logger?.willLogValues()` is true, i.e. the app already has
+ * query values surfacing somewhere (query-level or slow-query logging), so attaching them here does not
+ * introduce a new leak surface. Shared by every query call site (timed queries, streams, transaction
+ * statements) so the logic lives in one place.
+ *
+ * Returns rather than throws so `throw enrichError(...)` reads as the control flow it is, which also
+ * means callers need no `never` annotation and no unreachable-code suppression.
+ */
+export function enrichError(err, logger, query, values) {
+    if (err instanceof Error) {
+        const queryError = err;
+        queryError.query ??= query;
+        if (values !== undefined && logger?.willLogValues()) {
+            queryError.values ??= values;
+        }
+    }
+    return err;
+}

package/dist/querier/transactional.d.ts

@@ -0,0 +1,26 @@
+import type { IsolationLevel, QuerierPool } from '../type/index.js';
+export type TransactionalOptions = {
+    /** `required` opens a transaction when none is active; `supported` joins one but never starts one. */
+    readonly propagation?: 'supported' | 'required';
+    readonly pool?: QuerierPool;
+    readonly isolationLevel?: IsolationLevel;
+};
+/**
+ * Wraps the method in a transaction and publishes its querier for {@link currentQuerier} to pick up.
+ *
+ * @remarks Replaces the `@InjectQuerier()` parameter that used to receive the querier. The standard
+ * decorator spec has no parameter decorators, and the separate TC39 proposal for them is still Stage 1,
+ * so the querier travels through async-local storage instead. A nested call joins the transaction
+ * already in flight rather than opening a second one.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @Transactional()
+ *   async register(data: Partial<User>) {
+ *     await currentQuerier().insertOne(User, data);
+ *   }
+ * }
+ * ```
+ */
+export declare function Transactional({ propagation, pool, isolationLevel }?: TransactionalOptions): <This, Args extends unknown[], R>(original: (this: This, ...args: Args) => Promise<R>, context: ClassMethodDecoratorContext<This>) => (this: This, ...args: Args) => Promise<R>;

package/dist/querier/transactional.js

@@ -0,0 +1,43 @@
+import { getQuerierPool } from '../options.js';
+import { currentQuerierIfAny, withQuerierContext } from './querierContext.js';
+/**
+ * Wraps the method in a transaction and publishes its querier for {@link currentQuerier} to pick up.
+ *
+ * @remarks Replaces the `@InjectQuerier()` parameter that used to receive the querier. The standard
+ * decorator spec has no parameter decorators, and the separate TC39 proposal for them is still Stage 1,
+ * so the querier travels through async-local storage instead. A nested call joins the transaction
+ * already in flight rather than opening a second one.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @Transactional()
+ *   async register(data: Partial<User>) {
+ *     await currentQuerier().insertOne(User, data);
+ *   }
+ * }
+ * ```
+ */
+export function Transactional({ propagation = 'required', pool, isolationLevel } = {}) {
+    return (original, context) => {
+        // Checked at decoration time rather than on the first call: a synchronous method cannot be wrapped in
+        // a transaction, and finding that out at startup beats finding out mid-request.
+        if (original.constructor.name !== 'AsyncFunction') {
+            throw new TypeError(`@Transactional() needs an async method, but '${String(context.name)}' is not one.`);
+        }
+        return async function (...args) {
+            // Already inside a transactional flow: join it and let the outermost call own commit and release.
+            if (currentQuerierIfAny()) {
+                return original.apply(this, args);
+            }
+            // `withQuerier` releases; `transaction` commits or rolls back. `supported` joins a transaction but
+            // never starts one, so it takes only the first half.
+            return (pool ?? getQuerierPool()).withQuerier((querier) => {
+                const run = () => original.apply(this, args);
+                return withQuerierContext(querier, () => propagation === 'supported'
+                    ? run()
+                    : querier.transaction(run, isolationLevel ? { isolationLevel } : undefined));
+            });
+        };
+    };
+}

package/dist/schema/index.d.ts

@@ -22,4 +22,4 @@ export type { BuildFromEntitiesOptions } from './schemaASTBuilder.js';
 export { SchemaASTBuilder } from './schemaASTBuilder.js';
 export type { DiffOptions } from './schemaASTDiffer.js';
 export { diffSchemas, SchemaASTDiffer } from './schemaASTDiffer.js';
-export type { CanonicalType, ColumnDiff, ColumnNode, DetectedRelation, Drift, DriftReport, DriftSeverity, DriftStatus, DriftType, ForeignKeyAction, IndexDiff, IndexNode, IndexSource, IndexSyncStatus, IndexType, RelationshipDiff, RelationshipNode, RelationshipSource, RelationshipType, SchemaAST as ISchemaAST, SchemaDiffResult, SizeVariant, TableDiff, TableNode, TypeCategory, ValidationError, ValidationErrorType, } from './types.js';
+export type { CanonicalType, ColumnDiff, ColumnNode, Drift, DriftReport, DriftSeverity, DriftStatus, DriftType, ForeignKeyAction, IndexDiff, IndexNode, IndexSource, IndexSyncStatus, IndexType, RelationshipDiff, RelationshipNode, RelationshipSource, RelationshipType, SchemaAST as ISchemaAST, SchemaDiffResult, SizeVariant, TableDiff, TableNode, TypeCategory, ValidationError, ValidationErrorType, } from './types.js';

package/dist/schema/schemaASTBuilder.d.ts

@@ -54,7 +54,7 @@ export declare class SchemaASTBuilder {
      * foreign key column whose type doesn't match the UUID primary key it
      * references, which Postgres (and most databases) reject outright.
      *
-     * `field.typeInferred` (set by `defineField`, see entity/metadata/definition.ts)
+     * `field.typeFromReference` (set by `defineField`, see entity/metadata/definition.ts)
      * is what distinguishes "no type was given" from "the decorator explicitly set
      * a type" - including explicit constructor overrides like `type: BigInt`, which
      * a value-based check (e.g. `typeof field.type === 'string'`) would miss since

package/dist/schema/schemaASTBuilder.js

@@ -74,7 +74,7 @@ export class SchemaASTBuilder {
      * foreign key column whose type doesn't match the UUID primary key it
      * references, which Postgres (and most databases) reject outright.
      *
-     * `field.typeInferred` (set by `defineField`, see entity/metadata/definition.ts)
+     * `field.typeFromReference` (set by `defineField`, see entity/metadata/definition.ts)
      * is what distinguishes "no type was given" from "the decorator explicitly set
      * a type" - including explicit constructor overrides like `type: BigInt`, which
      * a value-based check (e.g. `typeof field.type === 'string'`) would miss since
@@ -82,7 +82,7 @@ export class SchemaASTBuilder {
      * `columnType` remains the unambiguous, always-respected explicit override.
      */
     resolveColumnCanonicalType(field, seen = new Set()) {
-        const hasExplicitType = !!field.columnType || !field.typeInferred;
+        const hasExplicitType = !!field.columnType || !field.typeFromReference;
         if (!hasExplicitType && field.references && !seen.has(field.references)) {
             seen.add(field.references);
             const referencedMeta = getMeta(field.references());

package/dist/schema/types.d.ts

@@ -256,27 +256,6 @@ export interface ValidationError {
     readonly relationship?: RelationshipNode;
     readonly tables?: TableNode[];
 }
-/**
- * A detected/inferred relationship with confidence score.
- */
-export interface DetectedRelation {
-    readonly type: RelationshipType;
-    readonly from: {
-        readonly table: TableNode;
-        readonly columns: ColumnNode[];
-    };
-    readonly to: {
-        readonly table: TableNode;
-        readonly columns: ColumnNode[];
-    };
-    readonly through?: TableNode;
-    /** Confidence level (0-1) */
-    readonly confidence: number;
-    /** How this relation was detected */
-    readonly source: RelationshipSource;
-    /** Suggested constraint name */
-    readonly suggestedName?: string;
-}
 /**
  * Severity level for schema drift issues.
  */

package/dist/sqlite/abstractSqliteQuerier.d.ts

@@ -1,6 +1,13 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
-/** Values every SQLite driver accepts as a bound parameter. */
-export type SqliteBindValue = null | string | number | bigint | boolean | Uint8Array;
+/**
+ * Values every SQLite driver accepts as a bound parameter.
+ *
+ * @remarks No `boolean`: SQLite has no boolean storage class, and both `better-sqlite3` ("SQLite3 can
+ * only bind numbers, strings, bigints, buffers, and null") and `node:sqlite` reject one outright. The
+ * dialect already binds booleans as integers (`booleanLiteral: 'integer'`), so nothing reaches a
+ * driver as one; leaving `boolean` here only invited a runtime throw that is now a compile error.
+ */
+export type SqliteBindValue = null | string | number | bigint | Uint8Array;
 /** Header a SQLite driver returns for a statement without a `RETURNING` clause. */
 export type SqliteRunResult = {
     changes: number;

package/dist/sqlite/hranaQuerier.js

@@ -1,13 +1,3 @@
-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 { Serialized } from '../querier/decorator/index.js';
 import { throwNoPendingTransaction, throwPendingTransaction } from '../util/index.js';
 import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
 /**
@@ -44,24 +34,30 @@ export class HranaQuerier extends AbstractSqliteQuerier {
         return !!this.tx;
     }
     async beginTransaction(_opts) {
-        if (this.tx) {
-            throwPendingTransaction();
-        }
-        this.tx = await this.client.transaction('write');
+        return this.serialize(async () => {
+            if (this.tx) {
+                throwPendingTransaction();
+            }
+            this.tx = await this.client.transaction('write');
+        });
     }
     async commitTransaction() {
-        if (!this.tx) {
-            throwNoPendingTransaction();
-        }
-        await this.tx.commit();
-        this.tx = undefined;
+        return this.serialize(async () => {
+            if (!this.tx) {
+                throwNoPendingTransaction();
+            }
+            await this.tx.commit();
+            this.tx = undefined;
+        });
     }
     async rollbackTransaction() {
-        if (!this.tx) {
-            throwNoPendingTransaction();
-        }
-        await this.tx.rollback();
-        this.tx = undefined;
+        return this.serialize(async () => {
+            if (!this.tx) {
+                throwNoPendingTransaction();
+            }
+            await this.tx.rollback();
+            this.tx = undefined;
+        });
     }
     async internalRelease() {
         await super.internalRelease();
@@ -70,21 +66,3 @@ export class HranaQuerier extends AbstractSqliteQuerier {
         }
     }
 }
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], HranaQuerier.prototype, "beginTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], HranaQuerier.prototype, "commitTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], HranaQuerier.prototype, "rollbackTransaction", null);

package/dist/sqlite/index.d.ts

@@ -1,6 +1,7 @@
 export * from './abstractSqliteQuerier.js';
 export * from './hranaQuerier.js';
 export * from './hranaQuerierPool.js';
+export * from './nodeSqliteQuerierPool.js';
 export * from './sqliteDialect.js';
 export * from './sqliteQuerier.js';
 export * from './sqliteQuerierPool.js';

package/dist/sqlite/index.js

@@ -1,6 +1,7 @@
 export * from './abstractSqliteQuerier.js';
 export * from './hranaQuerier.js';
 export * from './hranaQuerierPool.js';
+export * from './nodeSqliteQuerierPool.js';
 export * from './sqliteDialect.js';
 export * from './sqliteQuerier.js';
 export * from './sqliteQuerierPool.js';

package/dist/sqlite/localSqliteQuerierPool.d.ts

@@ -0,0 +1,31 @@
+import { AbstractSqlQuerierPool } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+import { SqliteDialect } from './sqliteDialect.js';
+import { type SqliteDatabase, SqliteQuerier } from './sqliteQuerier.js';
+/** What every local SQLite pool accepts on top of its driver's own options. */
+export type LocalSqlitePoolOptions = {
+    /**
+     * Paths of loadable extensions to install when the connection opens - e.g. what `sqlite-vec`'s
+     * `getLoadablePath()` returns, which vector search needs because SQLite itself has no vector
+     * functions.
+     */
+    extensions?: readonly string[];
+};
+/**
+ * Pool for a SQLite database opened in this process, whichever driver provides it.
+ *
+ * The handle is shared - SQLite gives one connection per file - but each acquisition gets its own
+ * querier, so transaction state stays per unit of work. Subclasses supply only {@link createDb}: the
+ * lifecycle, and loading the extensions on the way up, are the same for `better-sqlite3`, `bun:sqlite`
+ * and `node:sqlite`, and were written out once per pool before.
+ */
+export declare abstract class AbstractLocalSqliteQuerierPool<O extends LocalSqlitePoolOptions> extends AbstractSqlQuerierPool<SqliteQuerier, SqliteDialect> {
+    readonly opts?: O | undefined;
+    private db?;
+    constructor(opts?: O | undefined, extra?: ExtraOptions);
+    /** Opens the driver's database. Extensions are loaded by the caller, not here. */
+    protected abstract createDb(): Promise<SqliteDatabase>;
+    getQuerier(): Promise<SqliteQuerier>;
+    private openDb;
+    end(): Promise<void>;
+}