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

package/src/connection.ts

@@ -0,0 +1,83 @@
+import {
+  DatasourceError,
+  IsolationLevel,
+  StatementTextRenderer,
+  type DatasourceOptions,
+  type ICommand,
+  type IConnection,
+  type IsolationLevelName,
+  type ITransaction,
+} from "@datasources/core";
+import { createRequire } from "node:module";
+import { SqliteCommand } from "./command.ts";
+import type { SqliteConnectionOptions } from "./connection-options.ts";
+import type { SqliteDatabase, SqliteDatabaseCtor } from "./i-sqlite-driver.ts";
+import { filenameOf } from "./sqlitePath.ts";
+import { SqliteStatementRenderer } from "./SqliteStatementRenderer.ts";
+import { SqliteTransaction } from "./transaction.ts";
+
+const require = createRequire(import.meta.url);
+
+const pragma = (isolation: IsolationLevelName): string =>
+  isolation === IsolationLevel.ReadUncommitted
+    ? "PRAGMA read_uncommitted = 1"
+    : "PRAGMA read_uncommitted = 0";
+
+export class SqliteConnection implements IConnection {
+  readonly provider = "sqlite";
+  filename: string;
+  isOpen = false;
+  private db?: SqliteDatabase;
+  private readonly Database?: SqliteDatabaseCtor;
+
+  static from = (options?: DatasourceOptions): SqliteConnection =>
+    new SqliteConnection({
+      url: options?.DATASOURCE_URL,
+      Database: require("better-sqlite3") as SqliteDatabaseCtor,
+    });
+
+  constructor(options: SqliteConnectionOptions = {}) {
+    this.filename = filenameOf(options);
+    this.Database = options.Database;
+  }
+
+  createCommand = (): ICommand =>
+    new SqliteCommand(this, new StatementTextRenderer(t => new SqliteStatementRenderer(t)));
+
+  async open(): Promise<void> {
+    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(): Promise<void> {
+    this.db?.close();
+    this.db = undefined;
+    this.isOpen = false;
+  }
+
+  [Symbol.asyncDispose] = (): Promise<void> => this.close();
+
+  async startTransaction(
+    isolation: IsolationLevelName = IsolationLevel.ReadCommitted,
+  ): Promise<ITransaction> {
+    this.ensureOpen();
+    this.exec(pragma(isolation));
+    this.exec("BEGIN");
+    return new SqliteTransaction(this, isolation);
+  }
+
+  ensureOpen(): void {
+    if (!this.isOpen) throw new DatasourceError("Connection is not open");
+  }
+
+  require(): SqliteDatabase {
+    if (!this.db) throw new DatasourceError("Connection is not open");
+    return this.db;
+  }
+
+  exec(sql: string): void {
+    this.require().exec(sql);
+  }
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+import { type Cell, type TypeConverter } from "@datasources/core";
+import { BinaryConverter } from "./BinaryConverter.ts";
+import { BoolConverter } from "./BoolConverter.ts";
+import { DateTimeConverter } from "./DateTimeConverter.ts";
+import { DecimalConverter } from "./DecimalConverter.ts";
+import { UuidConverter } from "./UuidConverter.ts";
+
+export const SqliteRowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = {
+  bool: new BoolConverter(),
+  datetime: new DateTimeConverter(),
+  uuid: new UuidConverter(),
+  decimal: new DecimalConverter(),
+  binary: new BinaryConverter(),
+};
+
+export const reverse = (value: Cell): Cell =>
+  typeof value === "boolean"
+    ? SqliteRowTypeConverters.bool.reverseConvert(value)
+    : value instanceof Date
+      ? SqliteRowTypeConverters.datetime.reverseConvert(value)
+      : value instanceof Uint8Array
+        ? SqliteRowTypeConverters.binary.reverseConvert(value)
+        : value;
+

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

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

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

@@ -0,0 +1,21 @@
+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/src/index.ts

@@ -0,0 +1,2 @@
+export { SqliteDriver } from "./SqliteDriver.ts";
+export { SqliteStatementRenderer } from "./SqliteStatementRenderer.ts";