uql-orm 0.20.2 → 0.22.0

package/dist/dialect/vectorSqlDialect.d.ts

@@ -1,6 +1,6 @@
-import { type VectorCast } from '../schema/canonicalType.js';
 import type { EntityMeta, FieldOptions, QueryContext, QueryVectorSearch, VectorDistance } from '../type/index.js';
 import { AbstractDialect } from './abstractDialect.js';
+import { type VectorCast } from './vectorCast.js';
 /**
  * Vector similarity search for SQL dialects: the `ORDER BY <distance>` expression, its projection as
  * a named score, and the index metadata the schema generator reads.
@@ -14,8 +14,6 @@ import { AbstractDialect } from './abstractDialect.js';
  * {@link appendVectorSort} or filling {@link vectorDistanceFns}.
  */
 export declare abstract class VectorSqlDialect extends AbstractDialect {
-    /** Vector index operator classes, keyed by distance metric. Partial: not every dialect supports every metric. */
-    readonly vectorOpsClass: ReadonlyMap<VectorDistance, string> | undefined;
     readonly vectorExtension: string | undefined;
     /**
      * Mapping of UQL vector distance metrics to native SQL functions.
@@ -33,8 +31,17 @@ export declare abstract class VectorSqlDialect extends AbstractDialect {
         colName: string;
         distance: VectorDistance;
         field: FieldOptions | undefined;
-        vectorCast: VectorCast;
     };
+    /**
+     * Binds a vector, both as a persisted value and as the query vector of a distance expression, so a
+     * dialect needing a conversion around it (`$1::vector`, `VEC_FromText(?)`) declares it once.
+     */
+    protected appendVectorValue(ctx: QueryContext, value: readonly unknown[], _field?: FieldOptions): void;
+    /**
+     * The vector type this dialect actually has for a declared one, so the cast follows the column
+     * rather than naming a type the engine does not define. See {@link MULTI_VECTOR_TYPE_DIALECTS}.
+     */
+    protected supportedVectorType(cast: VectorCast): VectorCast;
     /**
      * Append a vector similarity function call: `fn(col, ?)`.
      * Used by dialects that express vector distance via SQL functions (SQLite, MariaDB).
@@ -51,4 +58,3 @@ export declare abstract class VectorSqlDialect extends AbstractDialect {
      */
     protected appendVectorSort<E>(ctx: QueryContext, meta: EntityMeta<E>, key: string, search: QueryVectorSearch): void;
 }
-//# sourceMappingURL=vectorSqlDialect.d.ts.map

package/dist/dialect/vectorSqlDialect.js

@@ -1,5 +1,5 @@
-import { resolveVectorCast } from '../schema/canonicalType.js';
 import { AbstractDialect } from './abstractDialect.js';
+import { MULTI_VECTOR_TYPE_DIALECTS } from './vectorCast.js';
 /**
  * Vector similarity search for SQL dialects: the `ORDER BY <distance>` expression, its projection as
  * a named score, and the index metadata the schema generator reads.
@@ -13,8 +13,6 @@ import { AbstractDialect } from './abstractDialect.js';
  * {@link appendVectorSort} or filling {@link vectorDistanceFns}.
  */
 export class VectorSqlDialect extends AbstractDialect {
-    /** Vector index operator classes, keyed by distance metric. Partial: not every dialect supports every metric. */
-    vectorOpsClass = undefined;
     vectorExtension = undefined;
     /**
      * Mapping of UQL vector distance metrics to native SQL functions.
@@ -30,21 +28,34 @@ export class VectorSqlDialect extends AbstractDialect {
         const field = meta.fields[key];
         const colName = this.resolveColumnName(key, field);
         const distance = search.$distance ?? field?.distance ?? 'cosine';
-        const vectorCast = resolveVectorCast(field);
-        return { colName, distance, field, vectorCast };
+        return { colName, distance, field };
+    }
+    /**
+     * Binds a vector, both as a persisted value and as the query vector of a distance expression, so a
+     * dialect needing a conversion around it (`$1::vector`, `VEC_FromText(?)`) declares it once.
+     */
+    appendVectorValue(ctx, value, _field) {
+        ctx.addValue(`[${value.join(',')}]`);
+    }
+    /**
+     * The vector type this dialect actually has for a declared one, so the cast follows the column
+     * rather than naming a type the engine does not define. See {@link MULTI_VECTOR_TYPE_DIALECTS}.
+     */
+    supportedVectorType(cast) {
+        return MULTI_VECTOR_TYPE_DIALECTS.has(this.dialectName) ? cast : 'vector';
     }
     /**
      * Append a vector similarity function call: `fn(col, ?)`.
      * Used by dialects that express vector distance via SQL functions (SQLite, MariaDB).
      */
     appendFunctionVectorSort(ctx, meta, key, search) {
-        const { colName, distance } = this.resolveVectorSortParams(meta, key, search);
+        const { colName, distance, field } = this.resolveVectorSortParams(meta, key, search);
         const fn = this.vectorDistanceFns.get(distance);
         if (!fn) {
             throw Error(`${this.dialectName} does not support vector distance metric: ${distance}`);
         }
         ctx.append(`${fn}(${this.escapeId(colName)}, `);
-        ctx.addValue(`[${search.$vector.join(',')}]`);
+        this.appendVectorValue(ctx, search.$vector, field);
         ctx.append(')');
     }
     /**
@@ -64,7 +75,6 @@ export class VectorSqlDialect extends AbstractDialect {
             this.appendFunctionVectorSort(ctx, meta, key, search);
             return;
         }
-        throw new TypeError('Vector similarity sort is not supported by this dialect. Use raw() for vector queries.');
+        throw new TypeError(`${this.dialectName} does not support vector similarity sort. Use raw() for vector queries.`);
     }
 }
-//# sourceMappingURL=vectorSqlDialect.js.map

package/dist/entity/decorator/entity.d.ts

@@ -1,3 +1,2 @@
 import type { EntityOptions, Type } from '../../type/index.js';
 export declare function Entity<E>(opts?: EntityOptions<E>): (entity: Type<E>) => void;
-//# sourceMappingURL=entity.d.ts.map

package/dist/entity/decorator/entity.js

@@ -4,4 +4,3 @@ export function Entity(opts) {
         defineEntity(entity, opts);
     };
 }
-//# sourceMappingURL=entity.js.map

package/dist/entity/decorator/field.d.ts

@@ -1,3 +1,2 @@
 import type { FieldOptions } from '../../type/index.js';
 export declare function Field<E>(opts?: FieldOptions): (target: object, key: string) => void;
-//# sourceMappingURL=field.d.ts.map

package/dist/entity/decorator/field.js

@@ -5,4 +5,3 @@ export function Field(opts) {
         defineField(entity, key, opts);
     };
 }
-//# sourceMappingURL=field.js.map

package/dist/entity/decorator/filter.d.ts

@@ -5,4 +5,3 @@ import type { FilterOptions, Type } from '../../type/index.js';
  * @example `@Filter('active', { condition: { status: 'active' }, default: false })`
  */
 export declare function Filter<E>(name: string, opts: FilterOptions<E>): (entity: Type<E>) => void;
-//# sourceMappingURL=filter.d.ts.map

package/dist/entity/decorator/filter.js

@@ -9,4 +9,3 @@ export function Filter(name, opts) {
         defineFilter(entity, name, opts);
     };
 }
-//# sourceMappingURL=filter.js.map

package/dist/entity/decorator/hook.d.ts

@@ -5,4 +5,3 @@ export declare const AfterUpdate: () => MethodDecorator;
 export declare const BeforeDelete: () => MethodDecorator;
 export declare const AfterDelete: () => MethodDecorator;
 export declare const AfterLoad: () => MethodDecorator;
-//# sourceMappingURL=hook.d.ts.map

package/dist/entity/decorator/hook.js

@@ -12,4 +12,3 @@ export const AfterUpdate = createHookDecorator('afterUpdate');
 export const BeforeDelete = createHookDecorator('beforeDelete');
 export const AfterDelete = createHookDecorator('afterDelete');
 export const AfterLoad = createHookDecorator('afterLoad');
-//# sourceMappingURL=hook.js.map

package/dist/entity/decorator/id.d.ts

@@ -1,3 +1,2 @@
 import type { FieldOptions } from '../../type/index.js';
 export declare function Id<E>(opts?: FieldOptions): (target: object, key: string) => void;
-//# sourceMappingURL=id.d.ts.map

package/dist/entity/decorator/id.js

@@ -5,4 +5,3 @@ export function Id(opts = {}) {
         defineId(entity, key, opts);
     };
 }
-//# sourceMappingURL=id.js.map

package/dist/entity/decorator/index-decorator.d.ts

@@ -1,11 +1,4 @@
-import type { DistributiveOmit, EntityIndexMeta, Type } from '../../type/index.js';
-/**
- * Options for the @Index decorator - {@link EntityIndexMeta} minus `columns`, which the decorator
- * takes as its own positional argument. `DistributiveOmit` (not plain `Omit`) keeps `type`/`distance`
- * a discriminated pair - `EntityIndexMeta`'s vector-index invariant, that omitting `distance` on a
- * vector index type is a compile error.
- */
-export type IndexDecoratorOptions = DistributiveOmit<EntityIndexMeta, 'columns'>;
+import type { IndexColumnInput, IndexOptions, Type } from '../../type/index.js';
 /**
  * Define a composite index on an entity class.
  *
@@ -26,5 +19,4 @@ export type IndexDecoratorOptions = DistributiveOmit<EntityIndexMeta, 'columns'>
  * export class User { ... }
  * ```
  */
-export declare function Index<E>(columns: string[], options?: IndexDecoratorOptions): (target: Type<E>) => void;
-//# sourceMappingURL=index-decorator.d.ts.map
+export declare function Index<E>(columns: readonly IndexColumnInput[], options?: IndexOptions): (target: Type<E>) => void;

package/dist/entity/decorator/index-decorator.js

@@ -24,4 +24,3 @@ export function Index(columns, options = {}) {
         defineIndex(target, { ...options, columns });
     };
 }
-//# sourceMappingURL=index-decorator.js.map

package/dist/entity/decorator/index.d.ts

@@ -6,4 +6,3 @@ export * from './hook.js';
 export * from './id.js';
 export * from './index-decorator.js';
 export * from './relation.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/entity/decorator/index.js

@@ -6,4 +6,3 @@ export * from './hook.js';
 export * from './id.js';
 export * from './index-decorator.js';
 export * from './relation.js';
-//# sourceMappingURL=index.js.map

package/dist/entity/decorator/relation.d.ts

@@ -6,4 +6,3 @@ export declare function ManyToOne<E>(opts?: RelationManyToOneOptions<E>): Relati
 export declare function OneToMany<E>(opts: RelationOneToManyOptions<E>): RelationReturn;
 export declare function ManyToMany<E>(opts: RelationManyToManyOptions<E>): RelationReturn;
 export {};
-//# sourceMappingURL=relation.d.ts.map

package/dist/entity/decorator/relation.js

@@ -17,4 +17,3 @@ export function OneToMany(opts) {
 export function ManyToMany(opts) {
     return Relation({ cardinality: 'mm', ...opts });
 }
-//# sourceMappingURL=relation.js.map

package/dist/entity/index.d.ts

@@ -1,2 +1 @@
 export * from './decorator/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/entity/index.js

@@ -1,2 +1 @@
 export * from './decorator/index.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,18 +1,17 @@
-import 'reflect-metadata';
-import type { EntityIndexMeta, EntityMeta, EntityOptions, FieldOptions, FilterOptions, HookEvent, RelationOptions, Type } from '../../type/index.js';
+import type { EntityIndexInput, EntityMeta, EntityOptions, FieldOptions, FilterOptions, HookEvent, RelationOptions, Type } from '../../type/index.js';
 /**
- * Append a composite index entry with normalized `unique` (default false).
+ * Append a composite index entry with normalized `unique` (default false) and columns. Normalizing
+ * here is what lets the dialects render one shape instead of re-parsing the authored sugar.
  */
-export declare function appendEntityIndex<E>(meta: EntityMeta<E>, index: EntityIndexMeta): void;
+export declare function appendEntityIndex<E>(meta: EntityMeta<E>, index: EntityIndexInput): void;
 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 defineHook<E>(entity: Type<E>, methodName: string, event: HookEvent): EntityMeta<E>;
-export declare function defineIndex<E>(entity: Type<E>, index: EntityIndexMeta): EntityMeta<E>;
+export declare function defineIndex<E>(entity: Type<E>, index: EntityIndexInput): EntityMeta<E>;
 export declare function defineFilter<E>(entity: Type<E>, name: string, opts: FilterOptions<E>): EntityMeta<E>;
 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>;
-//# sourceMappingURL=definition.d.ts.map

package/dist/entity/metadata/definition.js

@@ -1,5 +1,4 @@
-import 'reflect-metadata';
-import { getKeys, hasKeys, lowerFirst, upperFirst } from '../../util/index.js';
+import { getKeys, hasKeys, lowerFirst, normalizeIndexColumn, upperFirst } from '../../util/index.js';
 import { LoggerWrapper } from '../../util/logger.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).
@@ -9,12 +8,13 @@ const metas = holder[metaKey] ?? new Map();
 holder[metaKey] = metas;
 const registrationLogger = new LoggerWrapper(true);
 /**
- * Append a composite index entry with normalized `unique` (default false).
+ * Append a composite index entry with normalized `unique` (default false) and columns. Normalizing
+ * here is what lets the dialects render one shape instead of re-parsing the authored sugar.
  */
 export function appendEntityIndex(meta, index) {
     if (!meta.indexes)
         meta.indexes = [];
-    meta.indexes.push({ ...index, unique: index.unique ?? false });
+    meta.indexes.push({ ...index, unique: index.unique ?? false, columns: index.columns.map(normalizeIndexColumn) });
 }
 export function defineField(entity, key, opts = {}) {
     const meta = ensureMeta(entity);
@@ -342,8 +342,13 @@ function extendMeta(target, source) {
         }
     }
 }
+/** Reads the `design:type` emitted by `emitDecoratorMetadata`, if the optional polyfill is loaded. */
 function inferType(entity, key) {
-    return Reflect.getMetadata('design:type', entity.prototype, 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) {
@@ -363,4 +368,3 @@ export function isValidEntityType(type) {
         type !== Date &&
         type !== Symbol);
 }
-//# sourceMappingURL=definition.js.map

package/dist/express/index.d.ts

@@ -1,2 +1 @@
 export * from './querierMiddleware.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/express/index.js

@@ -1,2 +1 @@
 export * from './querierMiddleware.js';
-//# sourceMappingURL=index.js.map

package/dist/express/querierMiddleware.d.ts

@@ -9,4 +9,3 @@ export type MiddlewareOptions = RequestHandlerOptions<Request>;
  */
 export declare function querierMiddleware(opts?: MiddlewareOptions): Router;
 export declare function errorHandler(err: unknown, _req: Request, res: Response, _next: NextFunction): void;
-//# sourceMappingURL=querierMiddleware.d.ts.map

package/dist/express/querierMiddleware.js

@@ -37,4 +37,3 @@ export function errorHandler(err, _req, res, _next) {
     const { status, body } = toErrorResponse(err);
     res.status(status).json(body);
 }
-//# sourceMappingURL=querierMiddleware.js.map

package/dist/http/contract.d.ts

@@ -99,4 +99,3 @@ export declare function toErrorResponse(err: unknown): {
     status: number;
     body: RequestErrorResponse;
 };
-//# sourceMappingURL=contract.d.ts.map

package/dist/http/contract.js

@@ -69,4 +69,3 @@ export function toErrorResponse(err) {
     const message = err instanceof Error ? err.message : 'Internal Server Error';
     return { status, body: { error: { message, code: status } } };
 }
-//# sourceMappingURL=contract.js.map

package/dist/http/fetchHandler.d.ts

@@ -11,4 +11,3 @@ export type FetchHandlerOptions = RequestHandlerOptions<Request> & {
  * (Hono, Next.js route handlers, Bun.serve, Deno.serve, Cloudflare Workers, SvelteKit).
  */
 export declare function createFetchHandler(opts?: FetchHandlerOptions): (request: Request) => Promise<Response>;
-//# sourceMappingURL=fetchHandler.d.ts.map

package/dist/http/fetchHandler.js

@@ -60,4 +60,3 @@ function notFound() {
     const body = { error: { message: 'not found', code: 404 } };
     return Response.json(body, { status: 404 });
 }
-//# sourceMappingURL=fetchHandler.js.map

package/dist/http/handler.d.ts

@@ -84,4 +84,3 @@ export type RequestHandlerOptions<Ctx = unknown> = {
  */
 export type RequestHandler<Ctx = unknown> = (req: HandlerRequest<Ctx>) => Promise<HandlerResponse> | undefined;
 export declare function createRequestHandler<Ctx = unknown>(opts?: RequestHandlerOptions<Ctx>): RequestHandler<Ctx>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/http/handler.js

@@ -174,4 +174,3 @@ function buildIdQuery(meta, id, query) {
     }
     return query;
 }
-//# sourceMappingURL=handler.js.map

package/dist/http/index.d.ts

@@ -2,4 +2,3 @@ export * from './contract.js';
 export * from './fetchHandler.js';
 export * from './handler.js';
 export * from './query.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/http/index.js

@@ -2,4 +2,3 @@ export * from './contract.js';
 export * from './fetchHandler.js';
 export * from './handler.js';
 export * from './query.js';
-//# sourceMappingURL=index.js.map

package/dist/http/query.d.ts

@@ -9,4 +9,3 @@ export declare function parseQueryParams(params?: Record<string, unknown>): Quer
  * are JSON-stringified. Symmetric counterpart of {@link parseQueryParams}.
  */
 export declare function stringifyQuery(query?: Record<string, unknown>): string;
-//# sourceMappingURL=query.d.ts.map

package/dist/http/query.js

@@ -64,4 +64,3 @@ export function stringifyQuery(query) {
     const qs = params.toString();
     return qs ? `?${qs}` : '';
 }
-//# sourceMappingURL=query.js.map

package/dist/index.d.ts

@@ -6,4 +6,3 @@ export * from './options.js';
 export * from './querier/index.js';
 export * from './type/index.js';
 export * from './util/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -6,4 +6,3 @@ export * from './options.js';
 export * from './querier/index.js';
 export * from './type/index.js';
 export * from './util/index.js';
-//# sourceMappingURL=index.js.map

package/dist/libsql/index.d.ts

@@ -1,4 +1,3 @@
 export * from './libsqlDialect.js';
 export * from './libsqlQuerier.js';
 export * from './libsqlQuerierPool.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/libsql/index.js

@@ -1,4 +1,3 @@
 export * from './libsqlDialect.js';
 export * from './libsqlQuerier.js';
 export * from './libsqlQuerierPool.js';
-//# sourceMappingURL=index.js.map

package/dist/libsql/libsqlDialect.d.ts

@@ -1,10 +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>;
 }
-//# sourceMappingURL=libsqlDialect.d.ts.map

package/dist/libsql/libsqlDialect.js

@@ -2,9 +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'],
+    ]);
 }
-//# sourceMappingURL=libsqlDialect.js.map

package/dist/libsql/libsqlQuerier.d.ts

@@ -1,24 +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 {
 }
-//# sourceMappingURL=libsqlQuerier.d.ts.map

package/dist/libsql/libsqlQuerier.js

@@ -1,79 +1,10 @@
-import { __decorate, __metadata } from "tslib";
-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);
-//# sourceMappingURL=libsqlQuerier.js.map

package/dist/libsql/libsqlQuerierPool.d.ts

@@ -1,20 +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;
 }
-//# sourceMappingURL=libsqlQuerierPool.d.ts.map