@deterministic-code/datasources-sqlite 0.0.0-stage → 0.1.1

package/dist/SqliteCreateTableStatementRenderer.d.ts

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

package/dist/SqliteDriver.d.ts

@@ -0,0 +1,12 @@
+import { StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@datasources/core";
+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>>;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/SqliteStatementRenderer.d.ts

@@ -0,0 +1,6 @@
+import { CreateTableStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@datasources/core";
+export declare class SqliteStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
+    protected visitCreateTable(create: CreateTableStatement): string;
+}

package/dist/columnTypes.d.ts

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

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 "@datasources/core";
+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/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.d.ts

@@ -0,0 +1,20 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@datasources/core";
+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/converters/BinaryConverter.d.ts

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

package/dist/converters/BoolConverter.d.ts

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

package/dist/converters/DateTimeConverter.d.ts

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

package/dist/converters/DecimalConverter.d.ts

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

package/dist/converters/SqliteRowTypeConverters.d.ts

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

package/dist/converters/UuidConverter.d.ts

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

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

@@ -0,0 +1,17 @@
+import type { Cell, Cells, Scalar } from "@datasources/core";
+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/index.d.ts

@@ -0,0 +1,2 @@
+export { SqliteDriver } from "./SqliteDriver.js";
+export { SqliteStatementRenderer } from "./SqliteStatementRenderer.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/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@datasources/core";
+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>;
+}

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@deterministic-code/datasources-sqlite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.10.0",
+    "@deterministic-code/datasources": "^0.1.1"
+  }
+}

package/src/SqliteCreateTableStatementRenderer.ts

@@ -0,0 +1,24 @@
+import { CreateTableStatement, CreateTableStatementTextRenderer, PrimaryKey, type Column } from "@datasources/core";
+import { columnTypes } from "./columnTypes.ts";
+
+export class SqliteCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+  override render(statement: CreateTableStatement): string {
+    const identity = new Set(statement.columns.filter((column) => column.identity).map((column) => column.name));
+    const constraints = statement.constraints.filter(
+      (constraint) => !(constraint instanceof PrimaryKey) || !constraint.columns.every((column) => identity.has(column)),
+    );
+    return super.render(
+      constraints.length === statement.constraints.length
+        ? statement
+        : new CreateTableStatement(statement.table, statement.columns, constraints),
+    );
+  }
+
+  protected typeName(column: Column): string {
+    return columnTypes[column.type] ?? column.type;
+  }
+
+  protected identity(column: Column): string {
+    return column.identity ? " PRIMARY KEY AUTOINCREMENT" : "";
+  }
+}

package/src/SqliteDriver.ts

@@ -0,0 +1,53 @@
+import {
+  DatasourceError,
+  StatementTextRenderer,
+  type Cell,
+  type DatasourceOptions,
+  type ICommand,
+  type IConnection,
+  type IDriver,
+  type Information,
+  type ITransaction,
+  type IsolationLevel,
+  type TypeConverter,
+} from "@datasources/core";
+import { SqliteConnection } from "./connection.ts";
+import { SqliteCommand } from "./command.ts";
+import { SqliteTransaction } from "./transaction.ts";
+import { SqliteRowTypeConverters } from "./converters/SqliteRowTypeConverters.ts";
+import { SqliteStatementRenderer } from "./SqliteStatementRenderer.ts";
+import { columnTypes } from "./columnTypes.ts";
+
+export { columnTypes };
+
+const statements = new StatementTextRenderer(t => new SqliteStatementRenderer(t));
+
+export class SqliteDriver implements IDriver {
+  readonly statementRenderer = statements;
+  readonly information: 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: Record<string, TypeConverter<Cell, Cell>> = SqliteRowTypeConverters;
+  columnType = (name: string): string =>
+    columnTypes[name] ??
+    (() => {
+      throw new DatasourceError(`Unknown sqlite type "${name}"`);
+    })();
+  connection = (options?: DatasourceOptions): IConnection =>
+    SqliteConnection.from(options);
+  command = (connection: IConnection): ICommand =>
+    new SqliteCommand(connection as SqliteConnection, statements);
+  transaction = (
+    connection: IConnection,
+    isolation: IsolationLevel = "readCommitted",
+  ): ITransaction =>
+    new SqliteTransaction(connection as SqliteConnection, isolation);
+}

package/src/SqliteStatementRenderer.test.ts

@@ -0,0 +1,60 @@
+import {
+  ColumnDefault,
+  CreateTableStatement,
+  DefaultStatementTextRenderer,
+  ForeignKey,
+  SelectInsertedIdStatement,
+  NotNull,
+  PrimaryKey,
+  ReferentialAction,
+  SelectStatement,
+  StatementTextRenderer,
+} from "@datasources/core";
+import { describe, expect, it } from "vitest";
+import { SqliteCreateTableStatementRenderer } from "./SqliteCreateTableStatementRenderer.ts";
+import { SqliteStatementRenderer } from "./SqliteStatementRenderer.ts";
+
+describe("SqliteStatementRenderer", () => {
+  const renderer = new StatementTextRenderer(t => new SqliteStatementRenderer(t));
+
+  it("renders inserted id and create table", () => {
+    expect(renderer.render(new SelectInsertedIdStatement("users", "id"))).toBe(
+      "SELECT last_insert_rowid() AS id",
+    );
+
+    const create = new CreateTableStatement(
+      "orders",
+      [
+        { name: "id", type: "INTEGER", default: new ColumnDefault("0", "df_id"), notNull: new NotNull("nn_id") },
+        { name: "user_id", type: "INTEGER" },
+      ],
+      [
+        new PrimaryKey("pk_orders", ["id"]),
+        new ForeignKey("fk_orders_user", ["user_id"], "users", ["id"], ReferentialAction.Cascade),
+      ],
+    );
+    expect(renderer.render(create)).toBe(new SqliteCreateTableStatementRenderer().render(create));
+    expect(renderer.render(new SelectStatement({ table: "users", fields: ["id"] }))).toBe(
+      "SELECT id FROM users",
+    );
+  });
+
+  it("renders canonical types", () => {
+    const create = new CreateTableStatement("users", [
+      { name: "id", type: "int", default: new ColumnDefault("0"), notNull: new NotNull(), identity: true },
+    ]);
+    expect(renderer.render(create)).toBe(
+      "CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT DEFAULT 0 NOT NULL)",
+    );
+    expect(DefaultStatementTextRenderer.instance.render(create)).toBe(
+      "CREATE TABLE users (id int DEFAULT 0 NOT NULL)",
+    );
+
+    const keyed = new CreateTableStatement(
+      "users",
+      [{ name: "id", type: "int", identity: true }],
+      [new PrimaryKey("pk_users", ["id"])],
+    );
+    expect(renderer.render(keyed)).toBe("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT)");
+  });
+});

package/src/SqliteStatementRenderer.ts

@@ -0,0 +1,28 @@
+import {
+  CreateTableStatement,
+  SelectInsertedIdStatement,
+  SelectInsertedIdStatementTextRenderer,
+  StatementRenderer,
+  type StatementTextRenderer,
+} from "@datasources/core";
+import { SqliteCreateTableStatementRenderer } from "./SqliteCreateTableStatementRenderer.ts";
+
+class SqliteSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
+  override render(statement: SelectInsertedIdStatement): string {
+    return `SELECT last_insert_rowid() AS ${statement.column}`;
+  }
+}
+
+export class SqliteStatementRenderer extends StatementRenderer {
+  constructor(text: StatementTextRenderer) {
+    super(text);
+  }
+
+  protected override visitSelectInsertedId(inserted: SelectInsertedIdStatement): string {
+    return new SqliteSelectInsertedIdStatementTextRenderer().render(inserted);
+  }
+
+  protected override visitCreateTable(create: CreateTableStatement): string {
+    return new SqliteCreateTableStatementRenderer().render(create);
+  }
+}

package/src/columnTypes.ts

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

package/src/command.ts

@@ -0,0 +1,231 @@
+import {
+  ArrayReader,
+  CommandMiddlewareHost,
+  FirstResultReader,
+  DatasourceError,
+  Native,
+  ReturnStatement,
+  SelectStatement,
+  StatementTextRenderer,
+  parametersToRecord,
+  Response,
+  splitStatements,
+  statementParameters,
+  StreamingReader,
+  type Cell,
+  type Cells,
+  type Scalar,
+  type ICommand,
+  type IReader,
+  type IStatement,
+  type Parameter,
+} from "@datasources/core";
+import type { SqliteConnection } from "./connection.ts";
+import type { SqliteStatement } from "./i-sqlite-driver.ts";
+import { reverse, SqliteRowTypeConverters } from "./converters/SqliteRowTypeConverters.ts";
+import { SqliteStatementRenderer } from "./SqliteStatementRenderer.ts";
+
+const bound = (parameters?: Parameter[]): Record<string, Scalar> => {
+  const record = parametersToRecord(parameters);
+  return Object.fromEntries(
+    Object.entries(record).map(([name, value]) => [name, reverse(value)]),
+  ) as Record<string, Scalar>;
+};
+
+const toSqlite = (sql: string, params: Record<string, Scalar>): { text: string; values: Scalar[] } => {
+  const values: Scalar[] = [];
+  const text = sql.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_match, name: string) => {
+    values.push(params[name] ?? null);
+    return "?";
+  });
+  return { text, values };
+};
+
+export class SqliteCommand extends CommandMiddlewareHost implements ICommand {
+  private readonly statements: StatementTextRenderer;
+
+  constructor(readonly connection: SqliteConnection, statements?: StatementTextRenderer) {
+    super();
+    this.statements = statements ?? new StatementTextRenderer(t => new SqliteStatementRenderer(t));
+  }
+
+  async executeReaderNative(
+    text: Native,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> {
+    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] as string, 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: IStatement,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> {
+    return this.executeReaderNative(new Native(this.statements.render(statement)), parameters);
+  }
+
+  async executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
+    return statement instanceof SelectStatement || statement instanceof ReturnStatement
+      ? this.firstCell(statement, parameters)
+      : this.executeNative(new Native(this.statements.render(statement)), parameters);
+  }
+
+  private async firstCell(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
+    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: Native, parameters?: Parameter[]): Promise<Response> {
+    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: [] };
+    });
+  }
+
+  private iterate(sql: string, params: Record<string, Scalar>): IterableIterator<Cells> & {
+    return(): IteratorResult<Cells>;
+  } {
+    const statement = this.connection.require().prepare(sql) as ColumnStatement;
+    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]();
+  }
+}
+
+type SqliteColumn = { name: string; column: string | null; table: string | null; type?: string | null };
+
+const booleanDeclared = (declared?: string | null): boolean =>
+  declared?.toUpperCase() === "BOOLEAN";
+
+const cell = (value: Cell | null | undefined, declared?: string | null): Cell | null =>
+  value == null ? null : booleanDeclared(declared) ? SqliteRowTypeConverters.bool.convert(value) : value;
+
+type ColumnStatement = SqliteStatement & {
+  columns?: () => SqliteColumn[];
+  raw?: (enabled: boolean) => {
+    iterate(params?: Record<string, Scalar>): IterableIterator<Cell[]>;
+  };
+};
+
+const closable = (
+  iter: IterableIterator<Cells>,
+  columns: SqliteColumn[],
+): IterableIterator<Cells> & { return(): IteratorResult<Cells> } => {
+  const stop = iter.return ? iter.return.bind(iter) : undefined;
+  const rows: IterableIterator<Cells> & { return(): IteratorResult<Cells> } = {
+    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),
+        ]),
+      ) as Cells;
+      return { done: false, value };
+    },
+    return: () => {
+      if (stop) stop();
+      return { done: true, value: undefined };
+    },
+    [Symbol.iterator]() {
+      return rows;
+    },
+  };
+  return rows;
+};
+
+const namedRows = (
+  iter: IterableIterator<Cell[]>,
+  names: string[],
+  declared: (string | null)[],
+): IterableIterator<Cells> & { return(): IteratorResult<Cells> } => {
+  /* v8 ignore next */
+  const stop = iter.return ? iter.return.bind(iter) : undefined;
+  const rows: IterableIterator<Cells> & { return(): IteratorResult<Cells> } = {
+    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: SqliteColumn[]): string[] => {
+  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/src/connection-options.ts

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