@deterministic-code/datasources-sqlite 0.1.0 → 0.1.2

package/dist/SqliteAlterTableStatementRenderer.d.ts

@@ -0,0 +1,5 @@
+import { AlterTableStatementTextRenderer, type AlterAction, type Column } from "@deterministic-code/datasources";
+export declare class SqliteAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    protected typeName(column: Column): string;
+    protected actionSql(action: AlterAction): string;
+}

package/dist/SqliteAlterTableStatementRenderer.js

@@ -0,0 +1,27 @@
+import { AlterTableStatementTextRenderer, } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+export class SqliteAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    typeName(column) {
+        return columnTypes[column.type] ?? column.type;
+    }
+    actionSql(action) {
+        return ({
+            alterColumn: () => {
+                throw new Error("SQLite cannot ALTER COLUMN");
+            },
+            addConstraint: () => {
+                throw new Error("SQLite cannot ADD CONSTRAINT");
+            },
+            dropConstraint: () => {
+                throw new Error("SQLite cannot DROP CONSTRAINT");
+            },
+            addColumn: () => super.actionSql(action),
+            dropColumn: () => super.actionSql(action),
+            renameColumn: () => super.actionSql(action),
+            renameTable: () => super.actionSql(action),
+        }[action.kind] ??
+            (() => {
+                throw new Error("empty alter");
+            }))();
+    }
+}

package/dist/SqliteCreateTableStatementRenderer.d.ts

@@ -0,0 +1,6 @@
+import { CreateTableStatement, CreateTableStatementTextRenderer, type Column } from "@deterministic-code/datasources";
+export declare class SqliteCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    render(statement: CreateTableStatement): string;
+    protected typeName(column: Column): string;
+    protected identity(column: Column): string;
+}

package/dist/SqliteCreateTableStatementRenderer.js

@@ -0,0 +1,18 @@
+import { CreateTableStatement, CreateTableStatementTextRenderer } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+const primaryKey = (constraint) => constraint.kind === "primaryKey";
+export class SqliteCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    render(statement) {
+        const identity = new Set(statement.columns.filter((column) => column.identity).map((column) => column.name));
+        const constraints = statement.constraints.filter((constraint) => !primaryKey(constraint) || !constraint.columns.every((column) => identity.has(column)));
+        return super.render(constraints.length === statement.constraints.length
+            ? statement
+            : new CreateTableStatement(statement.table, statement.columns, constraints));
+    }
+    typeName(column) {
+        return columnTypes[column.type] ?? column.type;
+    }
+    identity(column) {
+        return column.identity ? " PRIMARY KEY AUTOINCREMENT" : "";
+    }
+}

package/dist/SqliteCreateTriggerStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { CreateTriggerStatementTextRenderer, type CreateTriggerStatement } from "@deterministic-code/datasources";
+export declare class SqliteCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
+    render(statement: CreateTriggerStatement): string;
+}

package/dist/SqliteCreateTriggerStatementRenderer.js

@@ -0,0 +1,12 @@
+import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+export class SqliteCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
+    render(statement) {
+        return `CREATE TRIGGER ${statement.name}
+AFTER UPDATE ON ${statement.table}
+FOR EACH ROW
+WHEN NEW.${statement.updatedColumn} IS OLD.${statement.updatedColumn}
+BEGIN
+  UPDATE ${statement.table} SET ${statement.updatedColumn} = ${statement.utcNow} WHERE ${statement.keyColumn} = OLD.${statement.keyColumn};
+END`;
+    }
+}

package/dist/SqliteDriver.d.ts

@@ -0,0 +1,16 @@
+import { DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+export { columnTypes };
+export declare class SqliteDriver implements IDriver {
+    readonly statementRenderer: StatementTextRenderer;
+    readonly information: Information;
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    readonly quoteLeft = "\"";
+    readonly quoteRight = "\"";
+    readonly typeConverter: DeterministicTypeConverter;
+    readonly defaultValueConverter: DefaultValueConverter;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/SqliteDriver.js

@@ -0,0 +1,64 @@
+import { DatasourceError, DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { SqliteConnection } from "./connection.js";
+import { SqliteCommand } from "./command.js";
+import { SqliteTransaction } from "./transaction.js";
+import { SqliteRowTypeConverters } from "./converters/SqliteRowTypeConverters.js";
+import { SqliteStatementRenderer } from "./SqliteStatementRenderer.js";
+import { columnTypes } from "./columnTypes.js";
+export { columnTypes };
+const statements = new StatementTextRenderer(t => new SqliteStatementRenderer(t));
+export class SqliteDriver {
+    statementRenderer = statements;
+    information = {
+        descriptions: [
+            "Embedded SQL database for local development and tests.",
+            "Full connection, command, transaction, and repository support.",
+        ],
+        overrides: [
+            "Overrides SelectInsertedIdStatement to SELECT last_insert_rowid() AS {column}",
+            "Overrides CreateTableStatement type mapping (int→INTEGER, bool→BOOLEAN, uuid/string/datetime→TEXT, decimal→NUMERIC, float→REAL, binary→BLOB)",
+        ],
+        changeLogs: [],
+    };
+    rowTypeConverters = SqliteRowTypeConverters;
+    quoteLeft = '"';
+    quoteRight = '"';
+    typeConverter = new DeterministicTypeConverter({
+        string: "TEXT",
+        character: "TEXT",
+        number: "INTEGER",
+        integer: "INTEGER",
+        unsignedinteger: "INTEGER",
+        smallinteger: "INTEGER",
+        unsignedsmallinteger: "INTEGER",
+        biginteger: "INTEGER",
+        unsignedbiginteger: "INTEGER",
+        float: "REAL",
+        decimal: "NUMERIC",
+        boolean: "BOOLEAN",
+        datetime: "TEXT",
+        binary: "BLOB",
+        uuid: "TEXT",
+        reference: "INTEGER",
+    }, {
+        dialectName: "sqlite",
+        stringUnlimited: "TEXT",
+        stringSized: (n) => `VARCHAR(${n})`,
+    });
+    defaultValueConverter = new DefaultValueConverter({
+        newId: () => "",
+        now: () => `(strftime('%Y-%m-%dT%H:%M:%f', 'now', 'localtime'))`,
+        utcNow: () => `(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`,
+        booleanOn: "1",
+        booleanOff: "0",
+        hex: (arg) => `X'${arg}'`,
+        hexReverse: /^X'(.*)'$/,
+    });
+    columnType = (name) => columnTypes[name] ??
+        (() => {
+            throw new DatasourceError(`Unknown sqlite type "${name}"`);
+        })();
+    connection = (options) => SqliteConnection.from(options);
+    command = (connection) => new SqliteCommand(connection, statements);
+    transaction = (connection, isolation = "readCommitted") => new SqliteTransaction(connection, isolation);
+}

package/dist/SqliteStatementRenderer.d.ts

@@ -0,0 +1,8 @@
+import { AlterTableStatement, CreateTableStatement, CreateTriggerStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
+export declare class SqliteStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
+    protected visitCreateTable(create: CreateTableStatement): string;
+    protected visitAlterTable(alter: AlterTableStatement): string;
+    protected visitCreateTrigger(trigger: CreateTriggerStatement): string;
+}

package/dist/SqliteStatementRenderer.js

@@ -0,0 +1,26 @@
+import { SelectInsertedIdStatementTextRenderer, StatementRenderer, } from "@deterministic-code/datasources";
+import { SqliteAlterTableStatementRenderer } from "./SqliteAlterTableStatementRenderer.js";
+import { SqliteCreateTableStatementRenderer } from "./SqliteCreateTableStatementRenderer.js";
+import { SqliteCreateTriggerStatementRenderer } from "./SqliteCreateTriggerStatementRenderer.js";
+class SqliteSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
+    render(statement) {
+        return `SELECT last_insert_rowid() AS ${statement.column}`;
+    }
+}
+export class SqliteStatementRenderer extends StatementRenderer {
+    constructor(text) {
+        super(text);
+    }
+    visitSelectInsertedId(inserted) {
+        return new SqliteSelectInsertedIdStatementTextRenderer().render(inserted);
+    }
+    visitCreateTable(create) {
+        return new SqliteCreateTableStatementRenderer().render(create);
+    }
+    visitAlterTable(alter) {
+        return new SqliteAlterTableStatementRenderer().renderAlter(alter);
+    }
+    visitCreateTrigger(trigger) {
+        return new SqliteCreateTriggerStatementRenderer().render(trigger);
+    }
+}

package/dist/columnTypes.d.ts

@@ -0,0 +1 @@
+export declare const columnTypes: Record<string, string>;

package/dist/columnTypes.js

@@ -0,0 +1,10 @@
+export const columnTypes = {
+    int: "INTEGER",
+    uuid: "TEXT",
+    string: "TEXT",
+    bool: "BOOLEAN",
+    decimal: "NUMERIC",
+    float: "REAL",
+    datetime: "TEXT",
+    binary: "BLOB",
+};

package/dist/command.d.ts

@@ -0,0 +1,13 @@
+import { CommandMiddlewareHost, Native, StatementTextRenderer, Response, type Cells, type ICommand, type IReader, type IStatement, type Parameter } from "@deterministic-code/datasources";
+import type { SqliteConnection } from "./connection.js";
+export declare class SqliteCommand extends CommandMiddlewareHost implements ICommand {
+    readonly connection: SqliteConnection;
+    private readonly statements;
+    constructor(connection: SqliteConnection, statements?: StatementTextRenderer);
+    executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeReaderStatement(statement: IStatement, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
+    private firstCell;
+    executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
+    private iterate;
+}

package/dist/command.js

@@ -0,0 +1,163 @@
+import { ArrayReader, CommandMiddlewareHost, FirstResultReader, DatasourceError, Native, ReturnStatement, SelectStatement, StatementTextRenderer, parametersToRecord, Response, splitStatements, statementParameters, StreamingReader, } from "@deterministic-code/datasources";
+import { reverse, SqliteRowTypeConverters } from "./converters/SqliteRowTypeConverters.js";
+import { SqliteStatementRenderer } from "./SqliteStatementRenderer.js";
+const bound = (parameters) => {
+    const record = parametersToRecord(parameters);
+    return Object.fromEntries(Object.entries(record).map(([name, value]) => [name, reverse(value)]));
+};
+const toSqlite = (sql, params) => {
+    const values = [];
+    const text = sql.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_match, name) => {
+        values.push(params[name] ?? null);
+        return "?";
+    });
+    return { text, values };
+};
+export class SqliteCommand extends CommandMiddlewareHost {
+    connection;
+    statements;
+    constructor(connection, statements) {
+        super();
+        this.connection = connection;
+        this.statements = statements ?? new StatementTextRenderer(t => new SqliteStatementRenderer(t));
+    }
+    async executeReaderNative(text, parameters) {
+        return this.run(text.text, parameters, async (query, params) => {
+            if (!query.trim())
+                return { value: new ArrayReader([]), rows: [] };
+            this.connection.ensureOpen();
+            const statements = splitStatements(query);
+            if (statements.length === 0)
+                return { value: new ArrayReader([]), rows: [] };
+            const paramsBound = bound(params);
+            let index = 0;
+            let iter = this.iterate(statements[0], paramsBound);
+            return FirstResultReader.capture(new StreamingReader(async () => {
+                const step = iter.next();
+                return step.done ? undefined : step.value;
+            }, async () => {
+                iter.return();
+                index += 1;
+                const sql = statements[index];
+                if (!sql)
+                    return false;
+                iter = this.iterate(sql, paramsBound);
+                return true;
+            }, async () => {
+                iter.return();
+            }));
+        });
+    }
+    async executeReaderStatement(statement, parameters) {
+        return this.executeReaderNative(new Native(this.statements.render(statement)), parameters);
+    }
+    async executeStatement(statement, parameters) {
+        return statement instanceof SelectStatement || statement instanceof ReturnStatement
+            ? this.firstCell(statement, parameters)
+            : this.executeNative(new Native(this.statements.render(statement)), parameters);
+    }
+    async firstCell(statement, parameters) {
+        const reader = await this.executeReaderStatement(statement, parameters);
+        try {
+            if (!(await reader.next()))
+                return new Response(null, 0, parameters);
+            const row = reader.current;
+            /* v8 ignore next */
+            if (!row)
+                throw new DatasourceError("Reader current must be a row");
+            const values = Object.values(row);
+            return new Response(values.length === 0 ? null : values[0], 1, parameters);
+        }
+        finally {
+            await reader.dispose();
+        }
+    }
+    async executeNative(text, parameters) {
+        return this.run(text.text, parameters, async (query, params) => {
+            if (!query.trim())
+                return { value: new Response(undefined, 0, params), rows: [] };
+            this.connection.ensureOpen();
+            const db = this.connection.require();
+            const named = bound(params);
+            let changes = 0;
+            for (const sql of splitStatements(query)) {
+                const names = new Set(statementParameters(sql));
+                const used = Object.fromEntries(Object.entries(named).filter(([name]) => names.has(name.replace(/^[$:@]/, ""))));
+                const { text, values } = toSqlite(sql, used);
+                changes += db.prepare(text).run(...values).changes;
+            }
+            return { value: new Response(null, changes, params), rows: [] };
+        });
+    }
+    iterate(sql, params) {
+        const statement = this.connection.require().prepare(sql);
+        const columns = statement.columns?.() ?? [];
+        const names = qualified(columns);
+        const declared = columns.map((column) => column.type ?? null);
+        const raw = names.some((name, index) => name !== columns[index]?.name)
+            ? statement.raw?.(true).iterate(params)
+            : undefined;
+        const rows = raw ? namedRows(raw, names, declared) : closable(statement.iterate(params), columns);
+        return rows[Symbol.iterator]();
+    }
+}
+const booleanDeclared = (declared) => declared?.toUpperCase() === "BOOLEAN";
+const cell = (value, declared) => value == null ? null : booleanDeclared(declared) ? SqliteRowTypeConverters.bool.convert(value) : value;
+const closable = (iter, columns) => {
+    const stop = iter.return ? iter.return.bind(iter) : undefined;
+    const rows = {
+        next: () => {
+            const step = iter.next();
+            if (step.done || !step.value)
+                return step;
+            const value = Object.fromEntries(Object.entries(step.value).map(([name, item]) => [
+                name,
+                cell(item, columns.find((column) => column.name === name)?.type),
+            ]));
+            return { done: false, value };
+        },
+        return: () => {
+            if (stop)
+                stop();
+            return { done: true, value: undefined };
+        },
+        [Symbol.iterator]() {
+            return rows;
+        },
+    };
+    return rows;
+};
+const namedRows = (iter, names, declared) => {
+    /* v8 ignore next */
+    const stop = iter.return ? iter.return.bind(iter) : undefined;
+    const rows = {
+        next: () => {
+            const step = iter.next();
+            return step.done
+                ? { done: true, value: undefined }
+                : {
+                    done: false,
+                    value: Object.fromEntries(names.map((name, index) => [name, cell(step.value[index], declared[index])])),
+                };
+        },
+        return: () => {
+            /* v8 ignore next */
+            if (stop)
+                stop();
+            return { done: true, value: undefined };
+        },
+        [Symbol.iterator]() {
+            return rows;
+        },
+    };
+    return rows;
+};
+const qualified = (columns) => {
+    const names = columns.map((column) => column.name);
+    const duplicated = new Set(names.filter((name, index) => names.indexOf(name) !== index));
+    return duplicated.size === 0
+        ? names
+        : columns.map((column, index) => duplicated.has(names[index]) && column.table && column.column
+            ? `${column.table}.${column.column}`
+            : names[index]);
+};

package/dist/connection-options.d.ts

@@ -0,0 +1,6 @@
+import type { SqliteDatabaseCtor } from "./i-sqlite-driver.js";
+export interface SqliteConnectionOptions {
+    filename?: string;
+    url?: string;
+    Database?: SqliteDatabaseCtor;
+}

package/dist/connection-options.js

@@ -0,0 +1 @@
+export {};

package/dist/connection.d.ts

@@ -0,0 +1,20 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@deterministic-code/datasources";
+import type { SqliteConnectionOptions } from "./connection-options.js";
+import type { SqliteDatabase } from "./i-sqlite-driver.js";
+export declare class SqliteConnection implements IConnection {
+    readonly provider = "sqlite";
+    filename: string;
+    isOpen: boolean;
+    private db?;
+    private readonly Database?;
+    static from: (options?: DatasourceOptions) => SqliteConnection;
+    constructor(options?: SqliteConnectionOptions);
+    createCommand: () => ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction(isolation?: IsolationLevelName): Promise<ITransaction>;
+    ensureOpen(): void;
+    require(): SqliteDatabase;
+    exec(sql: string): void;
+}

package/dist/connection.js

@@ -0,0 +1,58 @@
+import { DatasourceError, IsolationLevel, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { createRequire } from "node:module";
+import { SqliteCommand } from "./command.js";
+import { filenameOf } from "./sqlitePath.js";
+import { SqliteStatementRenderer } from "./SqliteStatementRenderer.js";
+import { SqliteTransaction } from "./transaction.js";
+const require = createRequire(import.meta.url);
+const pragma = (isolation) => isolation === IsolationLevel.ReadUncommitted
+    ? "PRAGMA read_uncommitted = 1"
+    : "PRAGMA read_uncommitted = 0";
+export class SqliteConnection {
+    provider = "sqlite";
+    filename;
+    isOpen = false;
+    db;
+    Database;
+    static from = (options) => new SqliteConnection({
+        url: options?.DATASOURCE_URL,
+        Database: require("better-sqlite3"),
+    });
+    constructor(options = {}) {
+        this.filename = filenameOf(options);
+        this.Database = options.Database;
+    }
+    createCommand = () => new SqliteCommand(this, new StatementTextRenderer(t => new SqliteStatementRenderer(t)));
+    async open() {
+        if (this.isOpen)
+            throw new DatasourceError("Connection is already open");
+        if (!this.Database)
+            throw new DatasourceError("SQLite driver is required");
+        this.db = new this.Database(this.filename, { timeout: 0 });
+        this.isOpen = true;
+    }
+    async close() {
+        this.db?.close();
+        this.db = undefined;
+        this.isOpen = false;
+    }
+    [Symbol.asyncDispose] = () => this.close();
+    async startTransaction(isolation = IsolationLevel.Serializable) {
+        this.ensureOpen();
+        this.exec(pragma(isolation));
+        this.exec("BEGIN");
+        return new SqliteTransaction(this, isolation);
+    }
+    ensureOpen() {
+        if (!this.isOpen)
+            throw new DatasourceError("Connection is not open");
+    }
+    require() {
+        if (!this.db)
+            throw new DatasourceError("Connection is not open");
+        return this.db;
+    }
+    exec(sql) {
+        this.require().exec(sql);
+    }
+}

package/dist/converters/BinaryConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+export declare class BinaryConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/BinaryConverter.js

@@ -0,0 +1,5 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export class BinaryConverter extends TypeConverter {
+    convert = (from) => from;
+    reverseConvert = (to) => to;
+}

package/dist/converters/BoolConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+export declare class BoolConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/BoolConverter.js

@@ -0,0 +1,5 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export class BoolConverter extends TypeConverter {
+    convert = (from) => (typeof from === "number" ? from !== 0 : from);
+    reverseConvert = (to) => (typeof to === "boolean" ? (to ? 1 : 0) : to);
+}

package/dist/converters/DateTimeConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+export declare class DateTimeConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/DateTimeConverter.js

@@ -0,0 +1,5 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export class DateTimeConverter extends TypeConverter {
+    convert = (from) => typeof from === "string" ? new Date(from) : from;
+    reverseConvert = (to) => to instanceof Date ? to.toISOString() : to;
+}

package/dist/converters/DecimalConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+export declare class DecimalConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/DecimalConverter.js

@@ -0,0 +1,5 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export class DecimalConverter extends TypeConverter {
+    convert = (from) => from;
+    reverseConvert = (to) => typeof to === "number" ? String(to) : to;
+}

package/dist/converters/SqliteRowTypeConverters.d.ts

@@ -0,0 +1,3 @@
+import { type Cell, type TypeConverter } from "@deterministic-code/datasources";
+export declare const SqliteRowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+export declare const reverse: (value: Cell) => Cell;

package/dist/converters/SqliteRowTypeConverters.js

@@ -0,0 +1,19 @@
+import { BinaryConverter } from "./BinaryConverter.js";
+import { BoolConverter } from "./BoolConverter.js";
+import { DateTimeConverter } from "./DateTimeConverter.js";
+import { DecimalConverter } from "./DecimalConverter.js";
+import { UuidConverter } from "./UuidConverter.js";
+export const SqliteRowTypeConverters = {
+    bool: new BoolConverter(),
+    datetime: new DateTimeConverter(),
+    uuid: new UuidConverter(),
+    decimal: new DecimalConverter(),
+    binary: new BinaryConverter(),
+};
+export const reverse = (value) => typeof value === "boolean"
+    ? SqliteRowTypeConverters.bool.reverseConvert(value)
+    : value instanceof Date
+        ? SqliteRowTypeConverters.datetime.reverseConvert(value)
+        : value instanceof Uint8Array
+            ? SqliteRowTypeConverters.binary.reverseConvert(value)
+            : value;

package/dist/converters/UuidConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+export declare class UuidConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/UuidConverter.js

@@ -0,0 +1,5 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export class UuidConverter extends TypeConverter {
+    convert = (from) => from;
+    reverseConvert = (to) => to;
+}

package/dist/i-sqlite-driver.d.ts

@@ -0,0 +1,17 @@
+import type { Cell, Cells, Scalar } from "@deterministic-code/datasources";
+export interface SqliteStatement {
+    run(params?: Record<string, Scalar>): {
+        changes: number;
+        lastInsertRowid?: Cell;
+    };
+    all(params?: Record<string, Scalar>): Cells[];
+    iterate(params?: Record<string, Scalar>): IterableIterator<Cells>;
+}
+export interface SqliteDatabase {
+    prepare(sql: string): SqliteStatement;
+    exec(sql: string): void;
+    close(): void;
+}
+export type SqliteDatabaseCtor = new (filename: string, options?: {
+    timeout?: number;
+}) => SqliteDatabase;

package/dist/i-sqlite-driver.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { SqliteDriver } from "./SqliteDriver.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { SqliteDriver } from "./SqliteDriver.js";

package/dist/sqlitePath.d.ts

@@ -0,0 +1,5 @@
+export declare const sqliteFilename: (url: string) => string | undefined;
+export declare const filenameOf: (options: {
+    filename?: string;
+    url?: string;
+}) => string;

package/dist/sqlitePath.js

@@ -0,0 +1,7 @@
+export const sqliteFilename = (url) => {
+    if (!/^sqlite:/i.test(url))
+        return undefined;
+    const path = url.replace(/^sqlite:(?:\/\/\/|\/\/)?/i, "");
+    return path === "" || path === ":memory" || path === ":memory:" ? ":memory:" : path;
+};
+export const filenameOf = (options) => options.filename ?? (options.url ? sqliteFilename(options.url) ?? ":memory:" : ":memory:");

package/dist/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@deterministic-code/datasources";
+import type { SqliteConnection } from "./connection.js";
+export declare class SqliteTransaction implements ITransaction {
+    readonly connection: SqliteConnection;
+    readonly isolation: IsolationLevelName;
+    constructor(connection: SqliteConnection, isolation?: IsolationLevelName);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}