uql-orm 0.21.0 → 0.23.0

package/dist/entity/decorator/members.js

@@ -0,0 +1,51 @@
+import { memberRegistrations } from './bag.js';
+export function Field(opts) {
+    return (_value, context) => {
+        memberRegistrations(context.metadata).fields[String(context.name)] = opts;
+    };
+}
+/**
+ * Declares the primary key, checked the same way as `@Field`.
+ *
+ * @example `@Id({ type: Number }) id?: number;`
+ * @example `@Id({ type: 'uuid', onInsert: uuidv7 }) id?: string;`
+ */
+export function Id(opts) {
+    return (_value, context) => {
+        memberRegistrations(context.metadata).fields[String(context.name)] = { ...opts, isId: true };
+    };
+}
+function relation(opts) {
+    return (_value, context) => {
+        memberRegistrations(context.metadata).relations[String(context.name)] = opts;
+    };
+}
+export function OneToOne(opts) {
+    return relation({ cardinality: '11', ...opts });
+}
+export function ManyToOne(opts) {
+    return relation({ cardinality: 'm1', ...opts });
+}
+export function OneToMany(opts) {
+    return relation({ cardinality: '1m', ...opts });
+}
+export function ManyToMany(opts) {
+    return relation({ cardinality: 'mm', ...opts });
+}
+function hook(event) {
+    return () => 
+    // Generic in `This` so a hook declared with an explicit `this` parameter still matches; the default
+    // on `ClassMethodDecoratorContext` pins `this` to `unknown` and would reject it.
+    (_value, context) => {
+        const { hooks } = memberRegistrations(context.metadata);
+        hooks[event] ??= [];
+        hooks[event].push(String(context.name));
+    };
+}
+export const BeforeInsert = hook('beforeInsert');
+export const AfterInsert = hook('afterInsert');
+export const BeforeUpdate = hook('beforeUpdate');
+export const AfterUpdate = hook('afterUpdate');
+export const BeforeDelete = hook('beforeDelete');
+export const AfterDelete = hook('afterDelete');
+export const AfterLoad = hook('afterLoad');

package/dist/entity/index.d.ts

@@ -1 +1,3 @@
-export * from './decorator/index.js';
+export * from './decorator/entity.js';
+export * from './decorator/members.js';
+export { defineEntity, defineField, defineFilter, defineHook, defineId, defineIndex, defineRelation, getEntities, getMeta, } from './metadata/definition.js';

package/dist/entity/index.js

@@ -1 +1,3 @@
-export * from './decorator/index.js';
+export * from './decorator/entity.js';
+export * from './decorator/members.js';
+export { defineEntity, defineField, defineFilter, defineHook, defineId, defineIndex, defineRelation, getEntities, getMeta, } from './metadata/definition.js';

package/dist/entity/metadata/definition.d.ts

@@ -1,16 +1,31 @@
-import type { EntityIndexMeta, EntityMeta, EntityOptions, FieldOptions, FilterOptions, HookEvent, RelationOptions, Type } from '../../type/index.js';
-/**
- * Append a composite index entry with normalized `unique` (default false).
- */
-export declare function appendEntityIndex<E>(meta: EntityMeta<E>, index: EntityIndexMeta): void;
+import type { EntityIndexInput, EntityMeta, EntityOptions, FieldKey, FieldOptions, FilterOptions, HookEvent, RelationOptions, Type } from '../../type/index.js';
 export declare function defineField<E>(entity: Type<E>, key: string, opts?: FieldOptions): EntityMeta<E>;
 export declare function defineId<E>(entity: Type<E>, key: string, opts: FieldOptions): EntityMeta<E>;
-export declare function defineRelation<E>(entity: Type<E>, key: string, opts: RelationOptions<E>): EntityMeta<E>;
+export declare function defineRelation<E>(entity: Type<E>, key: string, opts: RelationOptions): EntityMeta<E>;
 export declare function defineHook<E>(entity: Type<E>, methodName: string, event: HookEvent): EntityMeta<E>;
-export declare function defineIndex<E>(entity: Type<E>, index: EntityIndexMeta): EntityMeta<E>;
+/**
+ * Declares a composite index. `unique` and the authored column sugar are normalized here, which is what
+ * lets the dialects render one shape instead of re-parsing it.
+ */
+export declare function defineIndex<E>(entity: Type<E>, index: EntityIndexInput<FieldKey<E>>): EntityMeta<E>;
 export declare function defineFilter<E>(entity: Type<E>, name: string, opts: FilterOptions<E>): EntityMeta<E>;
+/**
+ * What a decorator bag and {@link EntityOptions} have in common at registration time. The keyed mapped
+ * types in `EntityOptions<E>` are what check the imperative call; a member decorator has no class to key
+ * against, so by the time either reaches the primitives the keys are plain strings.
+ */
+type MemberSpecs = {
+    readonly fields?: Readonly<Record<string, FieldOptions | undefined>>;
+    readonly relations?: Readonly<Record<string, RelationOptions | undefined>>;
+    readonly hooks?: Readonly<Partial<Record<HookEvent, readonly string[]>>>;
+};
+/**
+ * Feeds fields, relations and hooks into the `define*` primitives, so the decorators and the imperative
+ * API converge on one registration path before anything is finalized.
+ */
+export declare function applyMembers<E>(entity: Type<E>, specs: MemberSpecs | undefined): void;
 export declare function defineEntity<E>(entity: Type<E>, opts?: EntityOptions<E>): EntityMeta<E>;
 export declare function getEntities(): Type<unknown>[];
 export declare function ensureMeta<E>(entity: Type<E>): EntityMeta<E>;
 export declare function getMeta<E>(entity: Type<E>): EntityMeta<E>;
-export declare function isValidEntityType(type: unknown): type is Type<unknown>;
+export {};

package/dist/entity/metadata/definition.js

@@ -1,51 +1,45 @@
-import { getKeys, hasKeys, lowerFirst, upperFirst } from '../../util/index.js';
-import { LoggerWrapper } from '../../util/logger.js';
+import { getKeys, hasKeys, lowerFirst, normalizeIndexColumn, upperFirst } from '../../util/index.js';
+import { ownRegistrations } from '../decorator/bag.js';
 // Held on `globalThis` via the global symbol registry so a single metadata map survives multiple
-// evaluations of this module (HMR, duplicated/federated bundles, ESM+CJS dual-loading).
+// evaluations of this module (HMR, duplicated/federated bundles, ESM+CJS dual-loading). Version-suffixed
+// because v1 changed the `FieldOptions` shape: a tree holding both majors gets two maps rather than one
+// map with entries the other major cannot read.
 const holder = globalThis;
-const metaKey = Symbol.for('uql-orm/entity/metadata');
+const metaKey = Symbol.for('uql-orm/entity/metadata/v1');
 const metas = holder[metaKey] ?? new Map();
 holder[metaKey] = metas;
-const registrationLogger = new LoggerWrapper(true);
-/**
- * Append a composite index entry with normalized `unique` (default false).
- */
-export function appendEntityIndex(meta, index) {
-    if (!meta.indexes)
-        meta.indexes = [];
-    meta.indexes.push({ ...index, unique: index.unique ?? false });
-}
 export function defineField(entity, key, opts = {}) {
     const meta = ensureMeta(entity);
-    if (opts.type) {
-        opts = { ...opts, typeInferred: false };
-    }
-    else {
-        opts = { ...opts, type: inferType(entity, key), typeInferred: true };
+    if (!opts.type && !opts.references && !opts.virtual) {
+        throw new TypeError(`'${entity.name}.${key}' needs a 'type'. Declare it - '@Field({ type: String })' - or point the field ` +
+            "at another entity with 'references', which resolves the column type from its primary key.");
     }
     const fieldKey = key;
-    meta.fields[fieldKey] = { ...meta.fields[fieldKey], ...{ name: key, ...opts } };
+    // Flagged when the author gave `references` but no `type`, so schema generation knows to resolve the
+    // column from the referenced primary key (picking up its `columnType`, length and chained keys)
+    // instead of treating whatever ends up in `type` as deliberate.
+    const resolved = opts.type ? opts : { ...opts, typeFromReference: true };
+    meta.fields[fieldKey] = { ...meta.fields[fieldKey], ...{ name: key, ...resolved } };
     return meta;
 }
 export function defineId(entity, key, opts) {
     const meta = ensureMeta(entity);
     const id = getIdKey(meta);
     if (id) {
-        registrationLogger.logInfo(`Overriding ID property for '${entity.name}' from '${id}' to '${key}'`);
+        // A subclass narrowing the inherited primary key: drop the old one so exactly one stays marked.
         delete meta.fields[id];
     }
     return defineField(entity, key, { ...opts, isId: true });
 }
+// `RelationOptions` is parameterized by the *target* entity, which is independent of the owner `E`, so it
+// is left at its default here rather than tied to the class being registered.
 export function defineRelation(entity, key, opts) {
-    const resolved = opts.entity
-        ? opts
-        : (() => {
-            const inferredType = inferEntityType(entity, key);
-            return { ...opts, entity: () => inferredType };
-        })();
+    if (!opts.entity) {
+        throw new TypeError(`'${entity.name}.${key}' needs an 'entity' getter, e.g. '@ManyToOne({ entity: () => Company })'.`);
+    }
     const meta = ensureMeta(entity);
     const relKey = key;
-    meta.relations[relKey] = { ...meta.relations[relKey], ...resolved };
+    meta.relations[relKey] = { ...meta.relations[relKey], ...opts };
     return meta;
 }
 export function defineHook(entity, methodName, event) {
@@ -57,9 +51,15 @@ export function defineHook(entity, methodName, event) {
     meta.hooks[event].push({ methodName });
     return meta;
 }
+/**
+ * Declares a composite index. `unique` and the authored column sugar are normalized here, which is what
+ * lets the dialects render one shape instead of re-parsing it.
+ */
 export function defineIndex(entity, index) {
     const meta = ensureMeta(entity);
-    appendEntityIndex(meta, index);
+    if (!meta.indexes)
+        meta.indexes = [];
+    meta.indexes.push({ ...index, unique: index.unique ?? false, columns: index.columns.map(normalizeIndexColumn) });
     return meta;
 }
 export function defineFilter(entity, name, opts) {
@@ -75,9 +75,12 @@ export function defineFilter(entity, name, opts) {
     meta.filters[name] = opts;
     return meta;
 }
-function applyBulkFields(entity, fields) {
-    for (const key of Object.keys(fields)) {
-        const spec = fields[key];
+/**
+ * Feeds fields, relations and hooks into the `define*` primitives, so the decorators and the imperative
+ * API converge on one registration path before anything is finalized.
+ */
+export function applyMembers(entity, specs) {
+    for (const [key, spec] of Object.entries(specs?.fields ?? {})) {
         if (!spec)
             continue;
         if (spec.isId) {
@@ -87,64 +90,43 @@ function applyBulkFields(entity, fields) {
             defineField(entity, key, spec);
         }
     }
-}
-function applyBulkRelations(entity, relations) {
-    for (const key of Object.keys(relations)) {
-        const spec = relations[key];
+    for (const [key, spec] of Object.entries(specs?.relations ?? {})) {
         if (spec)
             defineRelation(entity, key, spec);
     }
-}
-function applyBulkIndexes(entity, indexes) {
-    const meta = ensureMeta(entity);
-    for (const idx of indexes) {
-        appendEntityIndex(meta, idx);
-    }
-}
-function applyBulkHooks(entity, hooks) {
-    for (const event of Object.keys(hooks)) {
-        const methodNames = hooks[event];
-        if (!methodNames?.length)
-            continue;
-        for (const methodName of methodNames) {
+    for (const [event, methodNames] of Object.entries(specs?.hooks ?? {})) {
+        for (const methodName of methodNames ?? []) {
             defineHook(entity, methodName, event);
         }
     }
 }
-function applyBulkFilters(entity, filters) {
-    for (const name of Object.keys(filters)) {
-        const spec = filters[name];
+export function defineEntity(entity, opts = {}) {
+    const meta = ensureMeta(entity);
+    // Covers `defineEntity(Decorated)` called on a class whose members carry decorators. `@Entity()`
+    // drains `context.metadata` itself, because TypeScript only attaches `Symbol.metadata` to the class
+    // after class decorators return; draining empties the bag, so whichever runs second is a no-op.
+    applyMembers(entity, ownRegistrations(entity));
+    applyMembers(entity, opts);
+    for (const index of opts.indexes ?? []) {
+        defineIndex(entity, index);
+    }
+    for (const [name, spec] of Object.entries(opts.filters ?? {})) {
         if (spec)
             defineFilter(entity, name, spec);
     }
-}
-/**
- * Applies `fields`, `relations`, `indexes`, and `hooks` from {@link EntityOptions} before
- * entity finalization. Used by `defineEntity` for decorator-free registration.
- */
-function applyBulkEntityOptions(entity, opts) {
-    if (opts.fields)
-        applyBulkFields(entity, opts.fields);
-    if (opts.relations)
-        applyBulkRelations(entity, opts.relations);
-    if (opts.indexes?.length)
-        applyBulkIndexes(entity, opts.indexes);
-    if (opts.hooks)
-        applyBulkHooks(entity, opts.hooks);
-    if (opts.filters)
-        applyBulkFilters(entity, opts.filters);
-}
-export function defineEntity(entity, opts = {}) {
-    const meta = ensureMeta(entity);
-    applyBulkEntityOptions(entity, opts);
     if (!hasKeys(meta.fields)) {
         throw TypeError(`'${entity.name}' must have fields`);
     }
     meta.name = opts.name ?? entity.name;
     let proto = Object.getPrototypeOf(entity.prototype);
     while (proto.constructor !== Object) {
-        const parentMeta = ensureMeta(proto.constructor);
-        extendMeta(meta, parentMeta);
+        const parent = proto.constructor;
+        // An `abstract class BaseEntity` carrying `@Field`s but no `@Entity()` has nobody to drain its
+        // registrations, so do it here. Walking the *class* prototype chain rather than reading through the
+        // metadata object's is what makes this work on every transformer: tsc and esbuild chain metadata
+        // across `extends`, SWC does not.
+        applyMembers(parent, ownRegistrations(parent));
+        extendMeta(meta, ensureMeta(parent));
         proto = Object.getPrototypeOf(proto);
     }
     // Derive soft-delete from the (inheritance-merged) fields, so own and inherited markers are handled
@@ -240,7 +222,7 @@ function fillRelations(meta) {
                     name: fkKey,
                     type: relatedIdField?.type ?? Number,
                     references: relOpts.entity,
-                    typeInferred: true,
+                    typeFromReference: true,
                 };
             }
         }
@@ -341,29 +323,3 @@ function extendMeta(target, source) {
         }
     }
 }
-/** Reads the `design:type` emitted by `emitDecoratorMetadata`, if the optional polyfill is loaded. */
-function inferType(entity, key) {
-    const { getMetadata } = Reflect;
-    if (!getMetadata) {
-        throw new TypeError(`'${entity.name}.${key}' has no explicit type and 'design:type' metadata is unavailable. Either declare the type - '@Field({ type: String })' or '@Relation({ entity: () => Other })' - or install 'reflect-metadata' and add 'import "reflect-metadata"' once at your app entry point.`);
-    }
-    return getMetadata('design:type', entity.prototype, key);
-}
-// biome-ignore lint/suspicious/noExplicitAny: reflected type is unknown at compile time
-function inferEntityType(entity, key) {
-    const inferredType = inferType(entity, key);
-    const isValidType = isValidEntityType(inferredType);
-    if (!isValidType) {
-        throw TypeError(`'${entity.name}.${key}' type was auto-inferred with invalid type '${inferredType?.name}'`);
-    }
-    return inferredType;
-}
-export function isValidEntityType(type) {
-    return (typeof type === 'function' &&
-        type !== Boolean &&
-        type !== String &&
-        type !== Number &&
-        type !== BigInt &&
-        type !== Date &&
-        type !== Symbol);
-}

package/dist/http/contract.js

@@ -1,5 +1,4 @@
-// import from the specific util modules (not the barrel) to keep entity
-// metadata and reflect-metadata out of the browser bundle
+// the specific util modules, not the barrel, so the browser bundle does not pull in entity metadata
 import { getKeys } from '../util/object.util.js';
 import { kebabCase } from '../util/string.util.js';
 /**

package/dist/http/handler.js

@@ -1,6 +1,6 @@
 import { withContext } from '../context/context.js';
 import { getEntities, getMeta } from '../entity/index.js';
-import { getQuerier } from '../options.js';
+import { getQuerierPool } from '../options.js';
 import { entityPath, matchRoute, } from './contract.js';
 import { parseQueryParams } from './query.js';
 export function createRequestHandler(opts = {}) {
@@ -135,31 +135,10 @@ export function createRequestHandler(opts = {}) {
 function ok(body) {
     return { status: 200, body };
 }
-async function withQuerier(fn) {
-    const querier = await getQuerier();
-    try {
-        return await fn(querier);
-    }
-    finally {
-        await querier.release();
-    }
-}
-async function withTransaction(fn) {
-    const querier = await getQuerier();
-    try {
-        await querier.beginTransaction();
-        const resp = await fn(querier);
-        await querier.commitTransaction();
-        return resp;
-    }
-    catch (err) {
-        await querier.rollbackTransaction().catch(() => { });
-        throw err;
-    }
-    finally {
-        await querier.release();
-    }
-}
+/** 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/http/query.js

@@ -1,4 +1,4 @@
-// specific util module (not the barrel) to keep reflect-metadata out of the browser bundle
+// the specific util module, not the barrel, so the browser bundle does not pull in entity metadata
 import { getKeys } from '../util/object.util.js';
 const JSON_QUERY_KEYS = [
     '$select',

package/dist/libsql/libsqlDialect.d.ts

@@ -1,9 +1,19 @@
 import { SqliteDialect } from '../sqlite/sqliteDialect.js';
+import type { VectorDistance } from '../type/index.js';
 /**
  * SQLite Dialect specialization for the `@libsql/client` driver.
  *
- * @remarks Empty subclass by design: distinct type for `LibsqlQuerierPool` and a hook
- * for future libsql-specific behavior.
+ * @remarks Distinct type for `LibsqlQuerierPool` and the home of the libSQL engine's built-in vector
+ * functions, which `TursoDialect` inherits.
  */
 export declare class LibsqlDialect extends SqliteDialect {
+    /**
+     * libSQL has vector search built in, under its own names, so the sqlite-vec `vec_distance_*`
+     * functions this dialect would otherwise inherit are never present.
+     *
+     * @remarks `inner` and `l1` are left out: `vector_distance_dot` only exists in the newer Rust
+     * engine (see `TursoDialect`) and no libSQL build has an L1 metric. Both raise the same
+     * "does not support vector distance metric" error as any other unsupported metric.
+     */
+    protected readonly vectorDistanceFns: ReadonlyMap<VectorDistance, string>;
 }

package/dist/libsql/libsqlDialect.js

@@ -2,8 +2,20 @@ import { SqliteDialect } from '../sqlite/sqliteDialect.js';
 /**
  * SQLite Dialect specialization for the `@libsql/client` driver.
  *
- * @remarks Empty subclass by design: distinct type for `LibsqlQuerierPool` and a hook
- * for future libsql-specific behavior.
+ * @remarks Distinct type for `LibsqlQuerierPool` and the home of the libSQL engine's built-in vector
+ * functions, which `TursoDialect` inherits.
  */
 export class LibsqlDialect extends SqliteDialect {
+    /**
+     * libSQL has vector search built in, under its own names, so the sqlite-vec `vec_distance_*`
+     * functions this dialect would otherwise inherit are never present.
+     *
+     * @remarks `inner` and `l1` are left out: `vector_distance_dot` only exists in the newer Rust
+     * engine (see `TursoDialect`) and no libSQL build has an L1 metric. Both raise the same
+     * "does not support vector distance metric" error as any other unsupported metric.
+     */
+    vectorDistanceFns = new Map([
+        ['cosine', 'vector_distance_cos'],
+        ['l2', 'vector_distance_l2'],
+    ]);
 }

package/dist/libsql/libsqlQuerier.d.ts

@@ -1,23 +1,10 @@
-import type { Client } from '@libsql/client';
-import { AbstractSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
-import type { SqliteDialect } from '../sqlite/sqliteDialect.js';
-import type { ExtraOptions, TransactionOptions } from '../type/index.js';
-/** Connection lifecycle for a {@link LibsqlQuerier} (separate from {@link ExtraOptions}). */
-export type LibsqlQuerierConnectionOptions = {
-    /** When set, {@link release} closes {@link LibsqlQuerier.client} (one-shot migration connections). */
-    closeClientOnRelease?: boolean;
-};
-export declare class LibsqlQuerier extends AbstractSqliteQuerier {
-    readonly client: Client;
-    readonly extra?: ExtraOptions | undefined;
-    private tx?;
-    private readonly closeClientOnRelease;
-    constructor(client: Client, dialect: SqliteDialect, extra?: ExtraOptions | undefined, connection?: LibsqlQuerierConnectionOptions);
-    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
-    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
-    get hasOpenTransaction(): boolean;
-    beginTransaction(_opts?: TransactionOptions): Promise<void>;
-    commitTransaction(): Promise<void>;
-    rollbackTransaction(): Promise<void>;
-    internalRelease(): Promise<void>;
+import { HranaQuerier } from '../sqlite/hranaQuerier.js';
+/**
+ * Querier for the `@libsql/client` driver.
+ *
+ * @remarks Empty subclass by design: that client speaks the Hrana protocol, so the whole
+ * implementation is inherited. Kept as a distinct type for `LibsqlQuerierPool` and as a hook for
+ * future libsql-specific behavior.
+ */
+export declare class LibsqlQuerier extends HranaQuerier {
 }

package/dist/libsql/libsqlQuerier.js

@@ -1,86 +1,10 @@
-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 { AbstractSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
-import { throwNoPendingTransaction, throwPendingTransaction } from '../util/index.js';
-export class LibsqlQuerier extends AbstractSqliteQuerier {
-    client;
-    extra;
-    tx;
-    closeClientOnRelease;
-    constructor(client, dialect, extra, connection) {
-        super(dialect, extra);
-        this.client = client;
-        this.extra = extra;
-        this.closeClientOnRelease = connection?.closeClientOnRelease ?? false;
-    }
-    async internalAll(query, values) {
-        const target = this.tx || this.client;
-        const res = await target.execute({ sql: query, args: values });
-        return res.rows;
-    }
-    async internalRun(query, values) {
-        const target = this.tx || this.client;
-        const res = await target.execute({ sql: query, args: values });
-        const rows = res.rows;
-        // `rowsAffected` is unreliably 0 whenever the statement has a RETURNING clause, so prefer
-        // the actual row count when rows were returned.
-        return this.buildUpdateResult({ rows, changes: rows.length || res.rowsAffected, id: res.lastInsertRowid });
-    }
-    get hasOpenTransaction() {
-        return !!this.tx;
-    }
-    async beginTransaction(_opts) {
-        if (this.tx) {
-            throwPendingTransaction();
-        }
-        this.tx = await this.client.transaction('write');
-    }
-    async commitTransaction() {
-        if (!this.tx) {
-            throwNoPendingTransaction();
-        }
-        await this.tx.commit();
-        this.tx = undefined;
-    }
-    async rollbackTransaction() {
-        if (!this.tx) {
-            throwNoPendingTransaction();
-        }
-        await this.tx.rollback();
-        this.tx = undefined;
-    }
-    async internalRelease() {
-        if (this.tx) {
-            throwPendingTransaction();
-        }
-        if (this.closeClientOnRelease) {
-            this.client.close();
-        }
-    }
+import { HranaQuerier } from '../sqlite/hranaQuerier.js';
+/**
+ * Querier for the `@libsql/client` driver.
+ *
+ * @remarks Empty subclass by design: that client speaks the Hrana protocol, so the whole
+ * implementation is inherited. Kept as a distinct type for `LibsqlQuerierPool` and as a hook for
+ * future libsql-specific behavior.
+ */
+export class LibsqlQuerier extends HranaQuerier {
 }
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], LibsqlQuerier.prototype, "beginTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], LibsqlQuerier.prototype, "commitTransaction", null);
-__decorate([
-    Serialized(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], LibsqlQuerier.prototype, "rollbackTransaction", null);

package/dist/libsql/libsqlQuerierPool.d.ts

@@ -1,19 +1,21 @@
-import { type Client, type Config } from '@libsql/client';
-import { AbstractSqlQuerierPool } from '../querier/index.js';
+import type { Config } from '@libsql/client';
+import type { HranaClient, HranaQuerierConnectionOptions } from '../sqlite/hranaQuerier.js';
+import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import type { ExtraOptions } from '../type/index.js';
 import { LibsqlDialect } from './libsqlDialect.js';
 import { LibsqlQuerier } from './libsqlQuerier.js';
 /** Embedded replica: local `file:` DB + `syncUrl` remote - DDL should run on the remote (sqld). */
 export declare function libsqlUseRemoteForMigrations(config: Pick<Config, 'url' | 'syncUrl'>): boolean;
-export declare class LibsqlQuerierPool extends AbstractSqlQuerierPool<LibsqlQuerier, LibsqlDialect> {
-    readonly client: Client;
-    private readonly libsqlConfig;
+export declare class LibsqlQuerierPool extends AbstractHranaQuerierPool<LibsqlQuerier, LibsqlDialect> {
+    private readonly conf;
     constructor(conf: Config, extra?: ExtraOptions);
-    getQuerier(): Promise<LibsqlQuerier>;
+    protected openClient(): Promise<HranaClient>;
+    protected buildQuerier(client: HranaClient, connection?: HranaQuerierConnectionOptions): LibsqlQuerier;
     /**
      * For embedded replicas (`file:` + `syncUrl`), returns a querier connected to `syncUrl` so migrations hit sqld.
-     * Otherwise same as {@link getQuerier}. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
+     * Otherwise same as `getQuerier`. The migrator calls this for `up`/`down`, `syncForce`, and `autoSync` DDL.
      */
     getMigrationQuerier(): Promise<LibsqlQuerier>;
-    end(): Promise<void>;
+    /** Imported on use, so `uql-orm/libsql` loads without the optional `@libsql/client` peer installed. */
+    private createClient;
 }