@deterministic-code/datasources-sqlite 0.1.0 → 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,22 +1,26 @@
 {
   "name": "@deterministic-code/datasources-sqlite",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
   },
   "files": [
+    "dist",
     "src"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.0",
     "@types/better-sqlite3": "^7.6.13",
-    "better-sqlite3": "^12.10.0"
+    "better-sqlite3": "^12.10.0",
+    "@deterministic-code/datasources": "^0.1.1"
   }
 }

package/src/SqliteCreateTableStatementRenderer.ts

@@ -1,4 +1,4 @@
-import { CreateTableStatement, CreateTableStatementTextRenderer, PrimaryKey, type Column } from "@deterministic-code/datasources";
+import { CreateTableStatement, CreateTableStatementTextRenderer, PrimaryKey, type Column } from "@datasources/core";
 import { columnTypes } from "./columnTypes.ts";
 
 export class SqliteCreateTableStatementRenderer extends CreateTableStatementTextRenderer {

package/src/SqliteDriver.ts

@@ -10,7 +10,7 @@ import {
   type ITransaction,
   type IsolationLevel,
   type TypeConverter,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { SqliteConnection } from "./connection.ts";
 import { SqliteCommand } from "./command.ts";
 import { SqliteTransaction } from "./transaction.ts";

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

@@ -4,7 +4,7 @@ import {
   SelectInsertedIdStatementTextRenderer,
   StatementRenderer,
   type StatementTextRenderer,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { SqliteCreateTableStatementRenderer } from "./SqliteCreateTableStatementRenderer.ts";
 
 class SqliteSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {

package/src/command.ts

@@ -19,7 +19,7 @@ import {
   type IReader,
   type IStatement,
   type Parameter,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import type { SqliteConnection } from "./connection.ts";
 import type { SqliteStatement } from "./i-sqlite-driver.ts";
 import { reverse, SqliteRowTypeConverters } from "./converters/SqliteRowTypeConverters.ts";

package/src/connection.ts

@@ -7,7 +7,7 @@ import {
   type IConnection,
   type IsolationLevelName,
   type ITransaction,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { createRequire } from "node:module";
 import { SqliteCommand } from "./command.ts";
 import type { SqliteConnectionOptions } from "./connection-options.ts";

package/src/converters/BinaryConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { BinaryConverter } from "./BinaryConverter.ts";
+
+describe("BinaryConverter", () => {
+  it("maps binary", () => {
+    const converter = new BinaryConverter();
+    const bytes = new Uint8Array([1, 2]);
+    expect(converter.convert(bytes)).toBe(bytes);
+    expect(converter.reverseConvert(bytes)).toBe(bytes);
+  });
+});

package/src/converters/BinaryConverter.ts

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

package/src/converters/BoolConverter.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { BoolConverter } from "./BoolConverter.ts";
+
+describe("BoolConverter", () => {
+  it("maps bool", () => {
+    const converter = new BoolConverter();
+    expect(converter.convert(1)).toBe(true);
+    expect(converter.convert(0)).toBe(false);
+    expect(converter.convert("x")).toBe("x");
+    expect(converter.reverseConvert(true)).toBe(1);
+    expect(converter.reverseConvert(false)).toBe(0);
+    expect(converter.reverseConvert("x")).toBe("x");
+  });
+});

package/src/converters/BoolConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 export class BoolConverter extends TypeConverter<Cell, Cell> {
   convert = (from: Cell): Cell => (typeof from === "number" ? from !== 0 : from);

package/src/converters/DateTimeConverter.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { DateTimeConverter } from "./DateTimeConverter.ts";
+
+describe("DateTimeConverter", () => {
+  it("maps datetime", () => {
+    const converter = new DateTimeConverter();
+    const date = new Date("2020-01-02T03:04:05.000Z");
+    expect(converter.convert("2020-01-02T03:04:05.000Z")).toEqual(date);
+    expect(converter.convert(date)).toBe(date);
+    expect(converter.reverseConvert(date)).toBe("2020-01-02T03:04:05.000Z");
+    expect(converter.reverseConvert("x")).toBe("x");
+  });
+});

package/src/converters/DateTimeConverter.ts

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

package/src/converters/DecimalConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DecimalConverter } from "./DecimalConverter.ts";
+
+describe("DecimalConverter", () => {
+  it("maps decimal", () => {
+    const converter = new DecimalConverter();
+    expect(converter.convert("10.5")).toBe("10.5");
+    expect(converter.reverseConvert(10.5)).toBe("10.5");
+    expect(converter.reverseConvert("10.5")).toBe("10.5");
+  });
+});

package/src/converters/DecimalConverter.ts

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

package/src/converters/SqliteRowTypeConverters.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { SqliteDriver } from "../SqliteDriver.ts";
+import { reverse, SqliteRowTypeConverters } from "./SqliteRowTypeConverters.ts";
+
+describe("SqliteRowTypeConverters", () => {
+  it("registers default types", () => {
+    expect(Object.keys(new SqliteDriver().rowTypeConverters)).toEqual(Object.keys(SqliteRowTypeConverters));
+  });
+
+  it("reverses booleans, dates, and bytes", () => {
+    const when = new Date("2024-01-02T00:00:00.000Z");
+    expect(reverse(true)).toBe(1);
+    expect(reverse(false)).toBe(0);
+    expect(reverse(when)).toBe(when.toISOString());
+    expect(reverse(new Uint8Array([1, 2]))).toEqual(new Uint8Array([1, 2]));
+    expect(reverse("a")).toBe("a");
+  });
+});

package/src/converters/SqliteRowTypeConverters.ts

@@ -1,4 +1,4 @@
-import { type Cell, type TypeConverter } from "@deterministic-code/datasources";
+import { type Cell, type TypeConverter } from "@datasources/core";
 import { BinaryConverter } from "./BinaryConverter.ts";
 import { BoolConverter } from "./BoolConverter.ts";
 import { DateTimeConverter } from "./DateTimeConverter.ts";

package/src/converters/UuidConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { UuidConverter } from "./UuidConverter.ts";
+
+describe("UuidConverter", () => {
+  it("maps uuid", () => {
+    const converter = new UuidConverter();
+    const id = "550e8400-e29b-41d4-a716-446655440000";
+    expect(converter.convert(id)).toBe(id);
+    expect(converter.reverseConvert(id)).toBe(id);
+  });
+});

package/src/converters/UuidConverter.ts

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

package/src/createFromDriver.test.ts

@@ -0,0 +1,15 @@
+import { CRUDRepository, Datasource } from "@datasources/core";
+import { expect, it } from "vitest";
+import { SqliteDriver } from "./SqliteDriver.ts";
+
+class Item {
+  id = 0;
+  name = "";
+}
+
+it("create from a driver", () => {
+  const driver = new SqliteDriver();
+  const ds = new Datasource("sqlite", driver, { DATASOURCE_URL: "sqlite:///:memory:" });
+  const repo = ds.createRepository(Item);
+  expect(repo instanceof CRUDRepository).toBe(true);
+});

package/src/expected-repository-console.test.ts

@@ -0,0 +1,95 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { describe, expect, it } from "vitest";
+import {
+  expectedRepositoryConsoleSignatures,
+  repositoryQueries,
+  type RepositorySpec,
+} from "../../../specs/expected-repository-console.ts";
+import { repoRoot } from "../../../sql-spec-runner.ts";
+
+describe("expected repository console", () => {
+  const spec = parse(
+    readFileSync(join(repoRoot(), "specs", "repositories", "user-crud.yaml"), "utf8"),
+  ) as RepositorySpec;
+
+  it("expands user-crud into statement SQL", () => {
+    expect(repositoryQueries(spec)).toEqual([
+      "INSERT INTO user (balance, created, is_enabled, location, username, uuid, version) VALUES ($balance, $created, $is_enabled, $location, $username, $uuid, $version)",
+      "INSERT INTO user (balance, created, is_enabled, location, username, uuid, version) VALUES ($balance, $created, $is_enabled, $location, $username, $uuid, $version)",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE id = $id",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE username = $username",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE uuid = $uuid",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE is_enabled = $is_enabled",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE created = $created",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user",
+      "UPDATE user SET balance = $balance, created = $created, is_enabled = $is_enabled, location = $location, username = $username, uuid = $uuid, version = $version WHERE uuid = $uuid",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE uuid = $uuid",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE created = $created",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE is_enabled = $is_enabled",
+      "DELETE FROM user WHERE created = $created",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user WHERE id = $id",
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM user",
+    ]);
+  });
+
+  it("expands complex-crud-mappings into flattened statement SQL", () => {
+    const mapped = parse(
+      readFileSync(join(repoRoot(), "specs", "repositories", "complex-crud-mappings.yaml"), "utf8"),
+    ) as RepositorySpec;
+    expect(repositoryQueries(mapped)).toEqual([
+      "INSERT INTO users (create_string, decimal_text, username, usertypename, uuid, version) VALUES ($create_string, $decimal_text, $username, $usertypename, $uuid, $version)",
+      "INSERT INTO users (create_string, decimal_text, username, usertypename, uuid, version) VALUES ($create_string, $decimal_text, $username, $usertypename, $uuid, $version)",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE id = $id",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE username = $username",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE uuid = $uuid",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE usertypename = $usertypename",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE create_string = $create_string",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users",
+      "UPDATE users SET create_string = $create_string, decimal_text = $decimal_text, username = $username, usertypename = $usertypename, uuid = $uuid, version = $version WHERE uuid = $uuid",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE uuid = $uuid",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE create_string = $create_string",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE usertypename = $usertypename",
+      "DELETE FROM users WHERE create_string = $create_string",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users WHERE id = $id",
+      "SELECT create_string, decimal_text, id, username, usertypename, uuid, version FROM users",
+    ]);
+  });
+
+  it("expands crud-mapper into remapped statement SQL", () => {
+    const mapped = parse(
+      readFileSync(join(repoRoot(), "specs", "repositories", "crud-mapper.yaml"), "utf8"),
+    ) as RepositorySpec;
+    const select =
+      "SELECT balance, created, id, is_enabled, location, username, uuid, version FROM people";
+    const insert =
+      "INSERT INTO people (balance, created, is_enabled, location, username, uuid, version) VALUES ($balance, $created, $is_enabled, $location, $username, $uuid, $version) RETURNING id";
+    expect(repositoryQueries(mapped)).toEqual([
+      insert,
+      insert,
+      `${select} WHERE id = $id LIMIT 1`,
+      `${select} WHERE username = $username LIMIT 1`,
+      `${select} WHERE username = $username LIMIT 1`,
+      "UPDATE people SET balance = $balance, created = $created, is_enabled = $is_enabled, location = $location, username = $username, uuid = $uuid, version = $version WHERE id = $id RETURNING id",
+      `${select} WHERE id = $id LIMIT 1`,
+      "UPDATE people SET balance = $balance, created = $created, is_enabled = $is_enabled, location = $location, username = $username, uuid = $uuid, version = $version WHERE uuid = $uuid RETURNING id",
+      `${select} WHERE uuid = $uuid LIMIT 1`,
+      "DELETE FROM people WHERE id = $id RETURNING id",
+      `${select} WHERE id = $id LIMIT 1`,
+      "DELETE FROM people WHERE username = $username RETURNING id",
+      `${select} WHERE id = $id LIMIT 1`,
+    ]);
+  });
+
+  it("pairs Start and Finish signatures", () => {
+    const signatures = expectedRepositoryConsoleSignatures(spec);
+    expect(signatures).toHaveLength(30);
+    expect(signatures[0]).toBe(
+      "[datasource][Start]-[INSERT INTO user (balance, created, is_enabled, location, username, uuid, version) VALUES ($balance, $created, $is_enabled, $location, $username, $uuid, $version)]",
+    );
+    expect(signatures[1]).toBe(
+      "[datasource][Finish]-[INSERT INTO user (balance, created, is_enabled, location, username, uuid, version) VALUES ($balance, $created, $is_enabled, $location, $username, $uuid, $version)]",
+    );
+  });
+});

package/src/i-sqlite-driver.ts

@@ -1,4 +1,4 @@
-import type { Cell, Cells, Scalar } from "@deterministic-code/datasources";
+import type { Cell, Cells, Scalar } from "@datasources/core";
 
 export interface SqliteStatement {
   run(params?: Record<string, Scalar>): {

package/src/sqlite.test.ts

@@ -0,0 +1,296 @@
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  CRUDRepository,
+  ReadonlyRepository,
+  untyped,
+  Datasource,
+  DatasourceError,
+  DatasourceFactory,
+  IsolationLevel,
+  type Cell,
+  type Cells,
+  columnType,
+  type IDriver,
+  RowTypeConverter,
+  CreateTableStatement,
+  Native,
+  ReturnStatement,
+  SelectStatement,
+  type Scalar,
+} from "@datasources/core";
+import { SqliteCommand } from "./command.ts";
+import { SqliteConnection } from "./connection.ts";
+import { SqliteRowTypeConverters } from "./converters/SqliteRowTypeConverters.ts";
+import type { SqliteDatabase, SqliteStatement } from "./i-sqlite-driver.ts";
+import { filenameOf, sqliteFilename } from "./sqlitePath.ts";
+import { SqliteDriver } from "./SqliteDriver.ts";
+import { SqliteTransaction } from "./transaction.ts";
+
+class FakeDatabase implements SqliteDatabase {
+  static latest: FakeDatabase | undefined;
+  runs: Array<{ sql: string; params?: Record<string, Scalar> }> = [];
+  alls: Array<{ sql: string; params?: Record<string, Scalar> }> = [];
+  execs: string[] = [];
+  closed = false;
+  rows: Cells[] = [{ id: 1 }];
+  bySql?: Record<string, Cells[]>;
+  omitRowid = false;
+  columns?: Array<{ name: string; column: string | null; table: string | null }>;
+  rawRows?: Array<Array<Cell | null>>;
+
+  constructor(public filename: string) {
+    FakeDatabase.latest = this;
+  }
+
+  prepare(sql: string): SqliteStatement {
+    return {
+      run: (params) => {
+        this.runs.push({ sql, params });
+        return this.omitRowid ? { changes: 1 } : { changes: 2, lastInsertRowid: 5 };
+      },
+      all: (params) => {
+        this.alls.push({ sql, params });
+        return this.bySql?.[sql] ?? this.rows;
+      },
+      iterate: (params) => {
+        this.alls.push({ sql, params });
+        return (this.bySql?.[sql] ?? this.rows)[Symbol.iterator]();
+      },
+      columns: this.columns ? () => this.columns! : undefined,
+      raw: this.rawRows
+        ? () => ({
+            iterate: () => this.rawRows![Symbol.iterator](),
+          })
+        : undefined,
+    };
+  }
+
+  exec(sql: string): void {
+    this.execs.push(sql);
+  }
+
+  close(): void {
+    this.closed = true;
+  }
+}
+
+const opened = async (filename = ":memory:"): Promise<SqliteConnection> => {
+  const connection = new SqliteConnection({ filename, Database: FakeDatabase });
+  await connection.open();
+  return connection;
+};
+
+afterEach(() => {
+  DatasourceFactory.reset();
+  DatasourceFactory.register("sqlite", new SqliteDriver());
+});
+
+describe("sqlitePath", () => {
+  it("parses sqlite URLs and filenames", () => {
+    expect(sqliteFilename("mysql://x")).toBeUndefined();
+    expect(sqliteFilename("sqlite:")).toBe(":memory:");
+    expect(sqliteFilename("sqlite:///:memory")).toBe(":memory:");
+    expect(sqliteFilename("sqlite:///:memory:")).toBe(":memory:");
+    expect(sqliteFilename("sqlite:///tmp/db.sqlite")).toBe("tmp/db.sqlite");
+    expect(filenameOf({})).toBe(":memory:");
+    expect(filenameOf({ filename: "x.db" })).toBe("x.db");
+    expect(filenameOf({ url: "sqlite:///tmp/db.sqlite" })).toBe("tmp/db.sqlite");
+    expect(filenameOf({ url: "mysql://x" })).toBe(":memory:");
+  });
+});
+
+describe("SqliteConnection", () => {
+  it("opens, reopens, transacts, and closes", async () => {
+    const connection = await opened("x.db");
+    const db = FakeDatabase.latest!;
+    await expect(connection.open()).rejects.toThrow("Connection is already open");
+    expect(connection.isOpen).toBe(true);
+    expect(db.filename).toBe("x.db");
+    const txn = await connection.startTransaction();
+    await txn.commit();
+    const txn2 = await connection.startTransaction(IsolationLevel.ReadUncommitted);
+    expect(txn2.isolation).toBe(IsolationLevel.ReadUncommitted);
+    await txn2.abort();
+    expect(db.execs).toEqual([
+      "PRAGMA read_uncommitted = 0",
+      "BEGIN",
+      "COMMIT",
+      "PRAGMA read_uncommitted = 1",
+      "BEGIN",
+      "ROLLBACK",
+    ]);
+    expect(txn.isolation).toBe("readCommitted");
+    await connection.close();
+    expect(db.closed).toBe(true);
+    expect(() => connection.ensureOpen()).toThrow(DatasourceError);
+    expect(() => connection.require()).toThrow("not open");
+    await expect(connection.startTransaction()).rejects.toThrow(DatasourceError);
+    await connection.close();
+  });
+
+  it("defaults the filename and requires a database module to open", async () => {
+    const connection = new SqliteConnection();
+    expect(connection.filename).toBe(":memory:");
+    await expect(connection.open()).rejects.toThrow("SQLite driver is required");
+    await connection.close();
+  });
+});
+
+describe("SqliteCommand", () => {
+  it("executes SQL on the open database", async () => {
+    const connection = await opened();
+    const db = FakeDatabase.latest!;
+    const command = new SqliteCommand(connection);
+    db.rows = [{ id: 1, name: "a" }];
+    expect(await command.execute("DELETE FROM items", [{ name: "id", value: 1 }])).toEqual({
+      result: null,
+      rowsAffected: 2,
+      parameters: [{ name: "id", value: 1 }],
+    });
+    expect(await command.executeNative(new Native(""))).toEqual({ result: undefined, rowsAffected: 0 });
+    db.rows = [{ abs: 3 }];
+    const x = { name: "x", value: -3 };
+    expect(await command.executeStatement(new ReturnStatement("abs", [x]), [x])).toEqual({
+      result: 3,
+      rowsAffected: 1,
+      parameters: [x],
+    });
+    db.rows = [];
+    expect(await command.executeNative(new Native("SELECT 1"))).toEqual({ result: null, rowsAffected: 2 });
+    db.omitRowid = true;
+    expect(await command.executeNative(new Native("INSERT INTO items DEFAULT VALUES"))).toEqual({
+      result: null,
+      rowsAffected: 1,
+    });
+    db.rows = [{ id: 1, name: "a" }, { id: 2, name: "b" }];
+    const reader = await command.executeReader("SELECT * FROM items");
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 1, name: "a" });
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 2, name: "b" });
+    await reader.dispose();
+    const empty = await command.executeReaderNative(new Native(""));
+    expect(await empty.next()).toBe(false);
+    expect(await (await command.executeReaderNative(new Native(";"))).next()).toBe(false);
+    db.bySql = { "SELECT 1 AS id": [{ id: 1 }], "SELECT 2 AS id": [{ id: 2 }] };
+    const sets = await command.executeReaderNative(new Native("SELECT 1 AS id; SELECT 2 AS id"));
+    const first: Cells[] = [];
+    while (await sets.next()) first.push(sets.current!);
+    const moved = await sets.nextResult();
+    const second: Cells[] = [];
+    while (await sets.next()) second.push(sets.current!);
+    expect(moved).toBe(true);
+    expect(first).toEqual([{ id: 1 }]);
+    expect(second).toEqual([{ id: 2 }]);
+    expect(await sets.nextResult()).toBe(false);
+    await sets.dispose();
+    db.bySql = undefined;
+    db.rows = [];
+    expect(await command.executeStatement(new SelectStatement({ table: "dual", fields: ["1"] }))).toEqual({
+      result: null,
+      rowsAffected: 0,
+      parameters: undefined,
+    });
+    db.rows = [{}];
+    expect(await command.executeStatement(new SelectStatement({ table: "dual", fields: ["1"] }))).toMatchObject({ result: null });
+    db.omitRowid = false;
+    expect(await command.executeStatement(new CreateTableStatement("items", [{ name: "id", type: "INTEGER" }]))).toMatchObject({
+      result: null,
+      rowsAffected: 2,
+    });
+    db.columns = [
+      { name: "id", column: "id", table: "a" },
+      { name: "id", column: null, table: null },
+    ];
+    db.rawRows = [[1, null]];
+    const qualified = await command.executeReaderNative(new Native("SELECT a.id, id"));
+    expect(await qualified.next()).toBe(true);
+    expect(qualified.current).toEqual({ "a.id": 1, id: null });
+    expect(await qualified.next()).toBe(false);
+    await qualified.dispose();
+    db.columns = [{ name: "id", column: "id", table: "t" }];
+    db.rawRows = undefined;
+    db.rows = [{ id: 4 }];
+    const plain = await command.executeReaderNative(new Native("SELECT id"));
+    expect(await plain.next()).toBe(true);
+    expect(plain.current).toEqual({ id: 4 });
+    await plain.dispose();
+    await connection.close();
+    await expect(command.execute("DELETE FROM items")).rejects.toThrow("not open");
+  });
+});
+
+describe("Sqlite datasource", () => {
+  it("registers and constructs children", async () => {
+    expect(await new Datasource("sqlite", new SqliteDriver()).createConnection()).toBeInstanceOf(
+      SqliteConnection,
+    );
+    const of = (): IDriver => ({
+      connection: () => new SqliteConnection({ Database: FakeDatabase }),
+      command: (c) => c.createCommand(),
+      transaction: (c, isolation = "readCommitted") =>
+        new SqliteTransaction(c as SqliteConnection, isolation),
+      rowTypeConverters: SqliteRowTypeConverters,
+      columnType,
+    });
+    const ds = new Datasource("sqlite", of());
+    expect(ds.provider).toBe("sqlite");
+    const connection = await ds.createConnection();
+    await (connection as SqliteConnection).open();
+    expect(connection.createCommand()).toBeInstanceOf(SqliteCommand);
+    const command = await ds.createCommand(connection);
+    expect(command).toBeInstanceOf(SqliteCommand);
+    expect(command.connection).toBe(connection);
+    await command.execute("DELETE FROM items");
+    await command.executeReaderNative(new Native("SELECT 1"));
+    await expect(ds.createCommand()).rejects.toThrow("Connection is already open");
+    const repo = ds.createRepository(untyped(), connection);
+    expect(ds.createReadonlyRepository(untyped(), connection).constructor).toBe(ReadonlyRepository);
+    expect(repo).toBeInstanceOf(CRUDRepository);
+    expect(new Datasource("sqlite", of()).createRepository(untyped())).toBeInstanceOf(CRUDRepository);
+    expect(Datasource.create({ PROVIDER: "sqlite" }).provider).toBe("sqlite");
+    expect(SqliteConnection.from({ DATASOURCE_URL: "sqlite:///:memory:" }).filename).toBe(":memory:");
+    expect(SqliteConnection.from().filename).toBe(":memory:");
+    const provider = new SqliteDriver();
+    expect(provider.columnType("int")).toBe("INTEGER");
+    expect(provider.columnType("uuid")).toBe("TEXT");
+    expect(provider.columnType("string")).toBe("TEXT");
+    expect(provider.columnType("bool")).toBe("BOOLEAN");
+    expect(provider.columnType("decimal")).toBe("NUMERIC");
+    expect(provider.columnType("float")).toBe("REAL");
+    expect(provider.columnType("datetime")).toBe("TEXT");
+    expect(provider.columnType("binary")).toBe("BLOB");
+    expect(() => provider.columnType("xml")).toThrow(DatasourceError);
+    expect(provider.command(connection)).toBeInstanceOf(SqliteCommand);
+    expect(provider.transaction(connection as SqliteConnection).isolation).toBe("readCommitted");
+  });
+
+  it("maps property targets", () => {
+    const provider = new SqliteDriver();
+    const created = "2020-01-02T03:04:05.000Z";
+    const converter = RowTypeConverter.from(provider.rowTypeConverters, {
+      Key: "uuid",
+      Active: "bool",
+      Login: "string",
+      Created: "datetime",
+    });
+    const row = converter.convert({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: 1,
+      Login: "ada",
+      Created: created,
+    });
+    expect(row).toEqual({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: true,
+      Login: "ada",
+      Created: new Date(created),
+    });
+    expect(converter.reverseConvert(row)).toEqual({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: 1,
+      Login: "ada",
+      Created: created,
+    });
+  });
+});

package/src/transaction.ts

@@ -2,7 +2,7 @@ import {
   IsolationLevel,
   type ITransaction,
   type IsolationLevelName,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import type { SqliteConnection } from "./connection.ts";
 
 export class SqliteTransaction implements ITransaction {