uql-orm 0.21.0 → 0.22.0

package/dist/schema/canonicalType.js

@@ -9,7 +9,7 @@
 // ============================================================================
 // Vector Category Helpers
 // ============================================================================
-/** Type guard for all vector-family categories. */
+/** Whether a category is one of the vector types, narrowing it to the cast pgvector names use. */
 export function isVectorCategory(category) {
     return category === 'vector' || category === 'halfvec' || category === 'sparsevec';
 }
@@ -86,7 +86,15 @@ const SQL_TO_CANONICAL = {
     halfvec: { category: 'halfvec' },
     sparsevec: { category: 'sparsevec' },
 };
-const PG_TYPE_MAP = {
+/**
+ * pgvector is the only engine with three vector column types, so every other dialect maps all three
+ * canonical categories onto the single type it does have (see {@link MULTI_VECTOR_TYPE_DIALECTS}, the
+ * dialect-side half of the same fact).
+ */
+function withVectorType(scalars, vector) {
+    return { ...scalars, vector, halfvec: vector, sparsevec: vector };
+}
+const PG_SCALAR_MAP = {
     integer: 'INTEGER',
     float: 'REAL',
     decimal: 'NUMERIC',
@@ -98,22 +106,18 @@ const PG_TYPE_MAP = {
     json: 'JSONB',
     uuid: 'UUID',
     blob: 'BYTEA',
+};
+const PG_TYPE_MAP = {
+    ...PG_SCALAR_MAP,
     vector: 'VECTOR',
     halfvec: 'HALFVEC',
     sparsevec: 'SPARSEVEC',
 };
-// CockroachDB's VECTOR type is native (no extension), but it has no HALFVEC/SPARSEVEC types at
-// all - verified live: `CREATE TABLE t (v HALFVEC(3))` is a syntax error, not just unsupported at
-// runtime. Falls back to VECTOR, same as MariaDB (see its own halfvec/sparsevec below).
-const CRDB_TYPE_MAP = {
-    ...PG_TYPE_MAP,
-    halfvec: 'VECTOR',
-    sparsevec: 'VECTOR',
-};
 const CANONICAL_TO_SQL = {
     postgres: PG_TYPE_MAP,
-    cockroachdb: CRDB_TYPE_MAP,
-    mysql: {
+    // CockroachDB's VECTOR is native, no extension needed.
+    cockroachdb: withVectorType(PG_SCALAR_MAP, 'VECTOR'),
+    mysql: withVectorType({
         integer: 'INT',
         float: 'FLOAT',
         decimal: 'DECIMAL',
@@ -125,11 +129,11 @@ const CANONICAL_TO_SQL = {
         json: 'JSON',
         uuid: 'CHAR(36)',
         blob: 'BLOB',
-        vector: 'JSON', // MySQL doesn't have native vector type
-        halfvec: 'JSON',
-        sparsevec: 'JSON',
-    },
-    sqlite: {
+    }, 
+    // MySQL 9.x does have a `VECTOR` type, but no distance function outside HeatWave and no vector
+    // index, so JSON keeps the column queryable with the JSON operators and needs no conversion.
+    'JSON'),
+    sqlite: withVectorType({
         integer: 'INTEGER',
         float: 'REAL',
         decimal: 'REAL',
@@ -141,11 +145,8 @@ const CANONICAL_TO_SQL = {
         json: 'TEXT',
         uuid: 'TEXT',
         blob: 'BLOB',
-        vector: 'TEXT',
-        halfvec: 'TEXT',
-        sparsevec: 'TEXT',
-    },
-    mariadb: {
+    }, 'TEXT'),
+    mariadb: withVectorType({
         integer: 'INT',
         float: 'FLOAT',
         decimal: 'DECIMAL',
@@ -157,12 +158,9 @@ const CANONICAL_TO_SQL = {
         json: 'JSON',
         uuid: 'CHAR(36)',
         blob: 'BLOB',
-        vector: 'VECTOR',
-        halfvec: 'VECTOR', // MariaDB only supports VECTOR; no native halfvec/sparsevec
-        sparsevec: 'VECTOR',
-    },
+    }, 'VECTOR'),
     // MongoDB uses BSON types, not SQL types. These are placeholders for compatibility.
-    mongodb: {
+    mongodb: withVectorType({
         integer: 'int',
         float: 'double',
         decimal: 'decimal128',
@@ -174,10 +172,7 @@ const CANONICAL_TO_SQL = {
         json: 'object',
         uuid: 'binData',
         blob: 'binData',
-        vector: 'array',
-        halfvec: 'array',
-        sparsevec: 'array',
-    },
+    }, 'array'),
 };
 /**
  * Size variant modifiers for SQL types.
@@ -318,6 +313,21 @@ export function sqlToCanonical(sqlType) {
     }
     return result;
 }
+/**
+ * The canonical type for a column an engine reported, merging the metadata columns it reports beside
+ * the type name (`character_maximum_length` and friends) over whatever the name itself carried. This is
+ * the one place a SQL type string is parsed: everything downstream compares and renders canonical
+ * types, so no consumer has to know that `TINYINT(1)` means boolean on MySQL.
+ */
+export function canonicalColumnType(sqlType, reported = {}) {
+    const base = sqlToCanonical(sqlType);
+    return {
+        ...base,
+        length: reported.length ?? base.length,
+        precision: reported.precision ?? base.precision,
+        scale: reported.scale ?? base.scale,
+    };
+}
 /**
  * Convert a canonical type to a SQL type string for a specific dialect instance.
  */

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, ConflictResolution, DetectedRelation, Drift, DriftReport, DriftSeverity, DriftStatus, DriftType, ForeignKeyAction, IndexDiff, IndexNode, IndexSource, IndexSyncStatus, IndexType, RelationshipDiff, RelationshipNode, RelationshipSource, RelationshipType, SchemaAST as ISchemaAST, SchemaDiffResult, SizeVariant, SyncDirection, SyncOptions, TableDiff, TableNode, TypeCategory, ValidationError, ValidationErrorType, } from './types.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';

package/dist/schema/schemaASTBuilder.d.ts

@@ -71,7 +71,14 @@ export declare class SchemaASTBuilder {
      */
     private addRelationshipsFromEntity;
     /**
-     * Add indexes from field options.
+     * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
+     * in common beyond their target table.
      */
     private addIndexesFromEntity;
+    /**
+     * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+     * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
+     * subset, which is what diffing and introspection compare.
+     */
+    private addCompositeIndex;
 }

package/dist/schema/schemaASTBuilder.js

@@ -160,8 +160,12 @@ export class SchemaASTBuilder {
             const relatedTable = this.ast.getTable(relatedTableName);
             if (!relatedTable)
                 continue;
-            // Only create FK for owning side (m1 and owner side of 11)
-            if (relation.cardinality === 'm1' || (relation.cardinality === '11' && relation.references)) {
+            // Only the owning side gets the FK. `mappedBy` marks the inverse side of a one-to-one, whose
+            // `references` describe how to join back (its own primary key against the owner's FK column) -
+            // reading those as a foreign key emitted a reversed constraint (`User(id) REFERENCES
+            // user_profile(creatorId)`), which SQLite rejects outright as a foreign key mismatch.
+            const ownsForeignKey = relation.cardinality === 'm1' || (relation.cardinality === '11' && !!relation.references && !relation.mappedBy);
+            if (ownsForeignKey) {
                 const references = relation.references ?? [{ local: `${key}Id`, foreign: relatedMeta.id }];
                 const localPropName = references[0].local;
                 const foreignPropName = references[0].foreign;
@@ -192,67 +196,72 @@ export class SchemaASTBuilder {
         }
     }
     /**
-     * Add indexes from field options.
+     * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
+     * in common beyond their target table.
      */
     addIndexesFromEntity(entity, meta, resolveTableName, resolveColumnName) {
         const tableName = resolveTableName(entity, meta);
         const table = this.ast.getTable(tableName);
         if (!table)
             return;
-        // 1. Single column indexes from @Field({ index: true })
-        const indexFields = meta.fields;
-        for (const key of Object.keys(indexFields)) {
-            const field = indexFields[key];
+        for (const key of Object.keys(meta.fields)) {
+            const field = meta.fields[key];
             if (!field?.index)
                 continue;
-            const columnName = resolveColumnName(key, field);
-            const column = table.columns.get(columnName);
+            const column = table.columns.get(resolveColumnName(key, field));
             if (!column)
                 continue;
-            const indexName = typeof field.index === 'string' ? field.index : `idx_${tableName}_${columnName}`;
-            const indexNode = {
-                name: indexName,
+            this.ast.addIndex({
+                name: typeof field.index === 'string' ? field.index : `idx_${tableName}_${column.name}`,
                 table,
                 columns: [column],
                 unique: field.unique ?? false,
                 source: 'entity',
                 syncStatus: 'entity_only',
-            };
-            this.ast.addIndex(indexNode);
+            });
         }
-        // 2. Composite indexes from @Index([...])
-        if (meta.indexes) {
-            for (const idxMeta of meta.indexes) {
-                const columns = [];
-                for (const propName of idxMeta.columns) {
-                    const field = meta.fields[propName];
-                    if (!field)
-                        continue;
-                    const colName = resolveColumnName(propName, field);
-                    const column = table.columns.get(colName);
-                    if (column) {
-                        columns.push(column);
-                    }
-                }
-                if (columns.length > 0) {
-                    const indexName = idxMeta.name ?? `idx_${tableName}_${columns.map((c) => c.name).join('_')}`;
-                    const indexNode = {
-                        name: indexName,
-                        table,
-                        columns,
-                        unique: idxMeta.unique ?? false,
-                        type: idxMeta.type,
-                        where: idxMeta.where,
-                        distance: idxMeta.distance,
-                        m: idxMeta.m,
-                        efConstruction: idxMeta.efConstruction,
-                        lists: idxMeta.lists,
-                        source: 'entity',
-                        syncStatus: 'entity_only',
-                    };
-                    this.ast.addIndex(indexNode);
-                }
-            }
+        for (const idxMeta of meta.indexes ?? []) {
+            this.addCompositeIndex(table, meta, idxMeta, resolveColumnName);
         }
     }
+    /**
+     * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+     * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
+     * subset, which is what diffing and introspection compare.
+     */
+    addCompositeIndex(table, meta, idxMeta, resolveColumnName) {
+        // An entry survives if it is an expression (nothing to resolve) or names a column that exists;
+        // an index left with none is dropped, the same as one naming only unknown columns always was.
+        const entries = idxMeta.columns
+            .map((entry) => {
+            if (entry.expression)
+                return entry;
+            const field = meta.fields[entry.column];
+            const column = field && resolveColumnName(entry.column, field);
+            return column && table.columns.has(column) ? { ...entry, column } : undefined;
+        })
+            .filter((entry) => entry !== undefined);
+        if (!entries.length)
+            return;
+        const columns = entries
+            .map((entry) => (entry.expression ? undefined : table.columns.get(entry.column)))
+            .filter((column) => column !== undefined);
+        const named = columns.length ? columns.map((column) => column.name) : entries.map((_, at) => `expr${at}`);
+        this.ast.addIndex({
+            name: idxMeta.name ?? `idx_${table.name}_${named.join('_')}`,
+            table,
+            columns,
+            entries,
+            include: idxMeta.include,
+            unique: idxMeta.unique ?? false,
+            type: idxMeta.type,
+            where: idxMeta.where,
+            distance: idxMeta.distance,
+            m: idxMeta.m,
+            efConstruction: idxMeta.efConstruction,
+            lists: idxMeta.lists,
+            source: 'entity',
+            syncStatus: 'entity_only',
+        });
+    }
 }

package/dist/schema/types.d.ts

@@ -4,7 +4,8 @@
  * A unified graph representation of database schema with relationships as first-class citizens.
  * Enables reliable diffing, smart relation detection, and dialect-agnostic schema operations.
  */
-import type { VectorIndexOptions } from '../type/vector.js';
+import type { IndexColumnSchema } from '../type/entity.js';
+import type { IndexSchema } from '../type/migration.js';
 /**
  * Type categories universal across SQL dialects.
  * These represent logical/semantic types, not specific SQL types.
@@ -148,24 +149,21 @@ export interface RelationshipNode {
  * Index node in the schema graph.
  * Represents a database index on one or more columns.
  */
-export type IndexNode = {
-    /** Index name */
-    readonly name: string;
+export type IndexNode = Omit<IndexSchema, 'columns'> & {
     /** Reference to the table this index belongs to */
     readonly table: TableNode;
-    /** Columns included in the index (order matters) */
+    /** Columns included in the index (order matters). Empty for an index over expressions only. */
     readonly columns: ColumnNode[];
-    /** Whether this is a unique index */
-    readonly unique: boolean;
-    /** Index algorithm/type */
-    readonly type?: IndexType;
-    /** Partial index condition (WHERE clause) */
-    readonly where?: string;
+    /**
+     * The index as authored, with names resolved: expressions, prefix lengths and per-column order that
+     * a `ColumnNode` cannot represent. The generator renders these; `columns` is what diffing compares.
+     */
+    readonly entries?: readonly IndexColumnSchema[];
     /** Where this index was defined */
     readonly source?: IndexSource;
     /** Current sync status */
     readonly syncStatus?: IndexSyncStatus;
-} & VectorIndexOptions;
+};
 /**
  * Root of the schema graph.
  * Contains all tables, relationships, and provides graph operations.
@@ -320,28 +318,3 @@ export interface DriftReport {
         readonly info: number;
     };
 }
-/**
- * Direction for schema synchronization.
- */
-export type SyncDirection = 'bidirectional' | 'entity-to-db' | 'db-to-entity';
-/**
- * Strategy for resolving conflicts in bidirectional sync.
- */
-export type ConflictResolution = 'prompt' | 'entity-wins' | 'db-wins' | 'skip';
-/**
- * Options for sync operations.
- */
-export interface SyncOptions {
-    /** Direction of synchronization */
-    readonly direction?: SyncDirection;
-    /** How to resolve conflicts (for bidirectional) */
-    readonly conflictResolution?: ConflictResolution;
-    /** Prevent destructive changes (DROP, type narrowing) */
-    readonly safe?: boolean;
-    /** Include indexes in sync */
-    readonly includeIndexes?: boolean;
-    /** Include foreign keys in sync */
-    readonly includeForeignKeys?: boolean;
-    /** Dry run - report changes without applying */
-    readonly dryRun?: boolean;
-}

package/dist/sqlite/abstractSqliteQuerier.d.ts

@@ -1,3 +1,42 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
+/** Values every SQLite driver accepts as a bound parameter. */
+export type SqliteBindValue = null | string | number | bigint | boolean | Uint8Array;
+/** Header a SQLite driver returns for a statement without a `RETURNING` clause. */
+export type SqliteRunResult = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
+export declare function toSqliteBindValues(values?: unknown[]): SqliteBindValue[];
+/**
+ * A prepared statement from a driver with better-sqlite3 semantics. `better-sqlite3` and `bun:sqlite`
+ * answer synchronously, `@tursodatabase/database` with promises, and {@link PreparedSqliteQuerier}
+ * awaits either.
+ */
+export type SqlitePreparedStatement = {
+    /** True for any statement returning rows, including one with a `RETURNING` clause. */
+    readonly reader: boolean;
+    all(...values: SqliteBindValue[]): unknown[] | Promise<unknown[]>;
+    run(...values: SqliteBindValue[]): SqliteRunResult | Promise<SqliteRunResult>;
+    iterate(...values: SqliteBindValue[]): Iterable<unknown> | AsyncIterable<unknown>;
+};
 export declare abstract class AbstractSqliteQuerier extends AbstractSqlQuerier {
+    /**
+     * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
+     * a querier returns nothing; it only asserts the unit of work was finished. Drivers owning a
+     * closable per-querier connection override this.
+     */
+    internalRelease(): Promise<void>;
+}
+/**
+ * Querier for the SQLite drivers that expose prepared statements: `better-sqlite3`, `bun:sqlite`
+ * (through `adaptBunSqlite`) and the embedded Turso engine. They differ only in whether preparing and
+ * stepping are synchronous, which `await` and `for await` absorb, so the read/write/stream logic -
+ * including the `reader` rule below, whose loss silently drops inserted ids - is written once.
+ */
+export declare abstract class PreparedSqliteQuerier extends AbstractSqliteQuerier {
+    protected abstract prepare(query: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
+    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
+    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
 }

package/dist/sqlite/abstractSqliteQuerier.js

@@ -1,3 +1,47 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
+import { throwPendingTransaction } from '../util/index.js';
+/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
+export function toSqliteBindValues(values) {
+    return (values || []);
+}
 export class AbstractSqliteQuerier extends AbstractSqlQuerier {
+    /**
+     * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
+     * a querier returns nothing; it only asserts the unit of work was finished. Drivers owning a
+     * closable per-querier connection override this.
+     */
+    async internalRelease() {
+        if (this.hasOpenTransaction) {
+            throwPendingTransaction();
+        }
+    }
+}
+/**
+ * Querier for the SQLite drivers that expose prepared statements: `better-sqlite3`, `bun:sqlite`
+ * (through `adaptBunSqlite`) and the embedded Turso engine. They differ only in whether preparing and
+ * stepping are synchronous, which `await` and `for await` absorb, so the read/write/stream logic -
+ * including the `reader` rule below, whose loss silently drops inserted ids - is written once.
+ */
+export class PreparedSqliteQuerier extends AbstractSqliteQuerier {
+    async internalAll(query, values) {
+        const stmt = await this.prepare(query);
+        return (await stmt.all(...toSqliteBindValues(values)));
+    }
+    async *internalStream(query, values) {
+        const stmt = await this.prepare(query);
+        for await (const row of stmt.iterate(...toSqliteBindValues(values))) {
+            yield row;
+        }
+    }
+    async internalRun(query, values) {
+        const stmt = await this.prepare(query);
+        // `reader` is true for any statement with a RETURNING clause; `.run()` silently discards
+        // returned rows, so those statements must go through `.all()` instead.
+        if (stmt.reader) {
+            const rows = (await stmt.all(...toSqliteBindValues(values)));
+            return this.buildUpdateResult({ rows });
+        }
+        const { changes, lastInsertRowid } = await stmt.run(...toSqliteBindValues(values));
+        return this.buildUpdateResult({ changes, id: lastInsertRowid });
+    }
 }

package/dist/sqlite/bunSqliteAdapter.bun.d.ts

@@ -0,0 +1,26 @@
+import type { SqliteBindValue, SqliteRunResult } from './abstractSqliteQuerier.js';
+import type { SqliteDatabase } from './sqliteQuerier.js';
+/** A `bun:sqlite` statement: better-sqlite3-shaped, except it reports columns instead of `reader`. */
+type BunStatement = {
+    columnNames: string[];
+    all(...values: SqliteBindValue[]): unknown[];
+    run(...values: SqliteBindValue[]): SqliteRunResult;
+    iterate(...values: SqliteBindValue[]): Iterable<unknown>;
+};
+type BunDatabase = {
+    prepare(sql: string): BunStatement;
+    loadExtension(path: string): void;
+    close(): unknown;
+};
+/**
+ * Presents a `bun:sqlite` handle as a {@link SqliteDatabase}.
+ *
+ * @remarks Its statements expose no `reader`, so without deriving one every `RETURNING` statement
+ * would take the `run()` path, which discards returned rows, and inserts would report no ids.
+ * `columnNames` is non-empty for exactly the statements better-sqlite3 marks as readers.
+ *
+ * Lives in a `.bun.ts` file because it only ever executes under Bun: the Node coverage run cannot
+ * reach it, and `sqliteQuerier.bun.test.ts` covers it under `test:bun` instead.
+ */
+export declare function adaptBunSqlite(db: BunDatabase): SqliteDatabase;
+export {};

package/dist/sqlite/bunSqliteAdapter.bun.js

@@ -0,0 +1,25 @@
+/**
+ * Presents a `bun:sqlite` handle as a {@link SqliteDatabase}.
+ *
+ * @remarks Its statements expose no `reader`, so without deriving one every `RETURNING` statement
+ * would take the `run()` path, which discards returned rows, and inserts would report no ids.
+ * `columnNames` is non-empty for exactly the statements better-sqlite3 marks as readers.
+ *
+ * Lives in a `.bun.ts` file because it only ever executes under Bun: the Node coverage run cannot
+ * reach it, and `sqliteQuerier.bun.test.ts` covers it under `test:bun` instead.
+ */
+export function adaptBunSqlite(db) {
+    return {
+        prepare: (sql) => {
+            const stmt = db.prepare(sql);
+            return {
+                reader: stmt.columnNames.length > 0,
+                all: (...values) => stmt.all(...values),
+                run: (...values) => stmt.run(...values),
+                iterate: (...values) => stmt.iterate(...values),
+            };
+        },
+        loadExtension: (path) => db.loadExtension(path),
+        close: () => db.close(),
+    };
+}

package/dist/sqlite/hranaQuerier.d.ts

@@ -0,0 +1,54 @@
+import type { ExtraOptions, TransactionOptions } from '../type/index.js';
+import { AbstractSqliteQuerier, type SqliteBindValue } from './abstractSqliteQuerier.js';
+import type { SqliteDialect } from './sqliteDialect.js';
+/**
+ * Structural subset of the Hrana client API, the wire protocol shared by `@libsql/client` and
+ * `@tursodatabase/serverless/compat`. Declared here rather than imported so a querier works with
+ * any client of this shape (including `@libsql/client/web` and `@libsql/client-wasm`) without
+ * depending on vendor types.
+ */
+export type HranaInValue = SqliteBindValue | ArrayBuffer | Date;
+export type HranaResultSet = {
+    rows: unknown[];
+    rowsAffected: number;
+    lastInsertRowid?: bigint;
+};
+export type HranaExecutor = {
+    execute(stmt: {
+        sql: string;
+        args?: HranaInValue[];
+    }): Promise<HranaResultSet>;
+};
+export type HranaTransaction = HranaExecutor & {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+};
+export type HranaClient = HranaExecutor & {
+    transaction(mode?: 'write' | 'read' | 'deferred'): Promise<HranaTransaction>;
+    close(): void;
+};
+/** Connection lifecycle for a {@link HranaQuerier} (separate from {@link ExtraOptions}). */
+export type HranaQuerierConnectionOptions = {
+    /** When set, {@link release} closes {@link HranaQuerier.client} (one-shot migration connections). */
+    closeClientOnRelease?: boolean;
+};
+/**
+ * Querier for SQLite databases reached through a Hrana client.
+ *
+ * @remarks Transactions use the client's own session handle rather than `BEGIN`/`COMMIT` statements,
+ * because over plain HTTP consecutive requests need not share a connection.
+ */
+export declare class HranaQuerier extends AbstractSqliteQuerier {
+    readonly client: HranaClient;
+    readonly extra?: ExtraOptions | undefined;
+    private tx?;
+    private readonly closeClientOnRelease;
+    constructor(client: HranaClient, dialect: SqliteDialect, extra?: ExtraOptions | undefined, connection?: HranaQuerierConnectionOptions);
+    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>;
+}

package/dist/sqlite/hranaQuerier.js

@@ -0,0 +1,90 @@
+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';
+/**
+ * Querier for SQLite databases reached through a Hrana client.
+ *
+ * @remarks Transactions use the client's own session handle rather than `BEGIN`/`COMMIT` statements,
+ * because over plain HTTP consecutive requests need not share a connection.
+ */
+export class HranaQuerier 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() {
+        await super.internalRelease();
+        if (this.closeClientOnRelease) {
+            this.client.close();
+        }
+    }
+}
+__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);