@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/mocks/MockDatasource.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import {
+  MockCommand,
+  MockConnection,
+  MockDatasource,
+  MockRepository,
+  Native,
+  untyped,
+} from "../index.ts";
+
+describe("MockDatasource", () => {
+  it("builds commands and repositories from a mock datasource", async () => {
+    const ds = new MockDatasource();
+    expect(ds.provider).toBe("mock");
+    expect(await ds.createConnection()).toBe(ds.connection);
+    const mockCommand = await ds.createCommand();
+    expect(mockCommand).toBeInstanceOf(MockCommand);
+    await mockCommand.executeNative(new Native(""));
+    await mockCommand.executeReaderNative(new Native(""));
+    const provided = new MockConnection();
+    expect((await ds.createCommand(provided)).connection).toBe(provided);
+    expect(ds.createRepository(untyped(), provided)).toBeInstanceOf(MockRepository);
+    expect(ds.createRepository(untyped())).toBeInstanceOf(MockRepository);
+
+    await ds.connection.close();
+    ds.command = new MockCommand(ds.connection);
+    ds.repository = new MockRepository(ds.connection);
+    expect(await ds.createCommand()).toBe(ds.command);
+    await expect(ds.createCommand()).rejects.toThrow("Connection is already open");
+    expect(ds.createRepository(untyped())).toBe(ds.repository);
+    expect(ds.createReadonlyRepository(untyped())).toBe(ds.repository);
+
+    const named = new MockDatasource("custom");
+    expect(named.provider).toBe("custom");
+    const customRepo = new MockRepository(named.connection);
+    named.repositories.register("Item", "items", () => customRepo, () => customRepo);
+    expect(named.createRepository("items")).toBe(customRepo);
+    expect(named.createReadonlyRepository("Item")).toBe(customRepo);
+  });
+});

package/src/mocks/MockReader.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { MockReader } from "../index.ts";
+
+describe("MockReader", () => {
+  it("walks mock reader rows and errors", async () => {
+    const reader = new MockReader(["x"]);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toBe("x");
+    expect(await reader.next()).toBe(false);
+    expect(await reader.nextResult()).toBe(false);
+    expect(await Array.fromAsync(new MockReader(["x"]).read())).toEqual(["x"]);
+    await reader.dispose();
+    await reader[Symbol.asyncDispose]();
+    reader.nextError = new Error("next");
+    await expect(reader.next()).rejects.toThrow("next");
+  });
+});

package/src/mocks/MockRepository.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { collectAsync, MockConnection, MockSelectStatement, MockRepository, MockWhere } from "../index.ts";
+
+describe("MockRepository", () => {
+  it("records repository CRUD and errors", async () => {
+    const repo = new MockRepository<{ id: number }>(new MockConnection());
+    expect(await repo.readSingle()).toBeUndefined();
+    repo.items = [{ id: 1 }, { id: 2 }];
+    expect(await repo.readSingle(new MockSelectStatement("id=1"))).toEqual({ id: 1 });
+    expect(await collectAsync(repo.read())).toEqual([{ id: 1 }, { id: 2 }]);
+    expect(await collectAsync(repo.read(new MockSelectStatement("all")))).toHaveLength(2);
+    expect(await repo.readSingle(new MockWhere("id=1"))).toEqual({ id: 1 });
+    expect(await collectAsync(repo.read(new MockWhere("all")))).toHaveLength(2);
+    expect(await repo.readSingleById(1)).toEqual({ id: 1 });
+    expect(await repo.create({ id: 3 })).toEqual({ id: 3 });
+    expect(
+      (await repo.update({ id: 3 }, new MockWhere("id=3"))).rowsAffected,
+    ).toBe(1);
+    expect((await repo.delete({ id: 3 })).rowsAffected).toBe(1);
+
+    repo.readSingleError = new Error("gs");
+    await expect(repo.readSingle()).rejects.toThrow("gs");
+    repo.readError = new Error("g");
+    await expect(collectAsync(repo.read())).rejects.toThrow("g");
+    repo.addError = new Error("ad");
+    await expect(repo.create({ id: 0 })).rejects.toThrow("ad");
+    repo.updateError = new Error("up");
+    await expect(repo.update({ id: 0 })).rejects.toThrow("up");
+    repo.deleteError = new Error("del");
+    await expect(repo.delete({ id: 0 })).rejects.toThrow("del");
+  });
+});

package/src/mocks/MockSelectStatement.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DefaultStatementTextRenderer, MockSelectStatement } from "../index.ts";
+
+describe("MockSelectStatement", () => {
+  it("tracks accept calls", () => {
+    const query = new MockSelectStatement("q");
+    expect(query.accept({ visit: () => "" })).toBe("q");
+    expect(query.acceptCalls).toBe(1);
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe("q");
+  });
+});

package/src/mocks/MockTransaction.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { MockConnection, MockTransaction } from "../index.ts";
+
+describe("MockTransaction", () => {
+  it("records transaction commit and abort", async () => {
+    const connection = new MockConnection();
+    const txn = new MockTransaction(connection);
+    await txn.commit();
+    expect(txn.committed).toBe(true);
+    await txn.abort();
+    expect(txn.aborted).toBe(true);
+    txn.commitError = new Error("c");
+    await expect(txn.commit()).rejects.toThrow("c");
+    txn.abortError = new Error("a");
+    await expect(txn.abort()).rejects.toThrow("a");
+  });
+});

package/src/mocks/MockWhere.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DefaultStatementTextRenderer, MockWhere } from "../index.ts";
+
+describe("MockWhere", () => {
+  it("tracks accept calls", () => {
+    const where = new MockWhere("w");
+    expect(where.accept({ visit: () => "" })).toBe("w");
+    expect(where.acceptCalls).toBe(1);
+    expect(DefaultStatementTextRenderer.instance.render(where)).toBe("w");
+  });
+});

package/src/mocks/index.ts

@@ -0,0 +1,9 @@
+export { MockCommand } from "./mock-command.ts";
+export { MockConnection } from "./mock-connection.ts";
+export { MockDatasource } from "./mock-datasource.ts";
+export { MockDriver } from "./mock-driver.ts";
+export { MockSelectStatement } from "./mock-select-statement.ts";
+export { MockReader } from "./mock-reader.ts";
+export { MockRepository } from "./mock-repository.ts";
+export { MockTransaction } from "./mock-transaction.ts";
+export { MockWhere } from "./mock-where.ts";

package/src/mocks/mock-command.ts

@@ -0,0 +1,66 @@
+import type { ICommand } from "../ICommand.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { Cells } from "../converters/Cell.ts";
+import type { IReader } from "../IReader.ts";
+import type { Response } from "../Response.ts";
+import { CommandMiddlewareHost } from "../CommandMiddlewareHost.ts";
+import type { Parameter } from "../Parameter.ts";
+import type { Row } from "../Row.ts";
+import type { IStatement } from "../statements/IStatement.ts";
+import { DefaultStatementTextRenderer } from "../statements/DefaultStatementTextRenderer.ts";
+import { Native } from "../statements/Native.ts";
+import { SelectInsertedIdStatement } from "../statements/SelectInsertedIdStatement.ts";
+import { MockReader } from "./mock-reader.ts";
+
+export class MockCommand extends CommandMiddlewareHost implements ICommand {
+  executeCalls: { text: string; parameters?: Parameter[] }[] = [];
+  executeReaderCalls: { text: string; parameters?: Parameter[] }[] = [];
+  executeError?: unknown;
+  executeReaderError?: unknown;
+  response: Response = { result: undefined, rowsAffected: 0 };
+  reader: IReader<Cells> = new MockReader();
+
+  constructor(readonly connection: IConnection) {
+    super();
+  }
+
+  executeReaderStatement = (
+    statement: IStatement,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> =>
+    this.executeReaderNative(
+      new Native(
+        statement instanceof SelectInsertedIdStatement
+          ? `${statement.table}.${statement.column}`
+          : DefaultStatementTextRenderer.instance.render(statement),
+      ),
+      parameters,
+    );
+
+  async executeReaderNative(
+    text: Native,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> {
+    return this.run(text.text, parameters, async (query, params) => {
+      this.executeReaderCalls.push({ text: query, parameters: params });
+      if (this.executeReaderError) {
+        throw this.executeReaderError;
+      }
+      const rows =
+        this.reader instanceof MockReader
+          ? (this.reader.rows as readonly Row[])
+          : [];
+      return { value: this.reader, rows };
+    });
+  }
+
+  async executeNative(text: Native, parameters?: Parameter[]): Promise<Response> {
+    return this.run(text.text, parameters, async (query, params) => {
+      this.executeCalls.push({ text: query, parameters: params });
+      if (this.executeError) {
+        throw this.executeError;
+      }
+      return { value: this.response, rows: [] };
+    });
+  }
+}

package/src/mocks/mock-connection.ts

@@ -0,0 +1,57 @@
+import { DatasourceError } from "../DatasourceError.ts";
+import type { ICommand } from "../ICommand.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { ITransaction } from "../ITransaction.ts";
+import { IsolationLevel, type IsolationLevel as Isolation } from "../IsolationLevel.ts";
+import { MockCommand } from "./mock-command.ts";
+import { MockTransaction } from "./mock-transaction.ts";
+
+export class MockConnection implements IConnection {
+  readonly provider: string;
+  openCalls = 0;
+  closeCalls = 0;
+  startTransactionCalls = 0;
+  openError?: unknown;
+  closeError?: unknown;
+  startTransactionError?: unknown;
+  transaction: ITransaction;
+  command?: ICommand;
+  isOpen = false;
+
+  constructor(transaction?: ITransaction, provider = "mock") {
+    this.provider = provider;
+    this.transaction = transaction ?? new MockTransaction(this);
+  }
+
+  createCommand = (): ICommand => this.command ?? new MockCommand(this);
+
+  async open(): Promise<void> {
+    if (this.isOpen) throw new DatasourceError("Connection is already open");
+    this.openCalls += 1;
+    if (this.openError) {
+      throw this.openError;
+    }
+    this.isOpen = true;
+  }
+
+  async close(): Promise<void> {
+    this.closeCalls += 1;
+    if (this.closeError) {
+      throw this.closeError;
+    }
+    this.isOpen = false;
+  }
+
+  [Symbol.asyncDispose] = (): Promise<void> => this.close();
+
+  async startTransaction(isolation: Isolation = IsolationLevel.ReadCommitted): Promise<ITransaction> {
+    this.startTransactionCalls += 1;
+    if (this.startTransactionError) {
+      throw this.startTransactionError;
+    }
+    if (this.transaction instanceof MockTransaction) {
+      this.transaction.isolation = isolation;
+    }
+    return this.transaction;
+  }
+}

package/src/mocks/mock-datasource.ts

@@ -0,0 +1,65 @@
+import type { Constructable } from "../converters/Constructable.ts";
+import type { ICommand } from "../ICommand.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { IDatasource } from "../IDatasource.ts";
+import type { IReadonlyRepository } from "../IReadonlyRepository.ts";
+import type { ICRUDRepository } from "../ICRUDRepository.ts";
+import { DatasourceError } from "../DatasourceError.ts";
+import { RepositoryFactory } from "../RepositoryFactory.ts";
+import { MockCommand } from "./mock-command.ts";
+import { MockConnection } from "./mock-connection.ts";
+import { MockRepository } from "./mock-repository.ts";
+export class MockDatasource implements IDatasource {
+  createConnectionCalls = 0;
+  createCommandCalls: Array<IConnection | undefined> = [];
+  createRepositoryCalls: Array<IConnection | undefined> = [];
+  connection: IConnection;
+  command?: ICommand;
+  repository?: ICRUDRepository;
+  readonly repositories = new RepositoryFactory();
+
+  constructor(readonly provider = "mock") {
+    this.connection = new MockConnection();
+  }
+
+  createConnection(): Promise<IConnection> {
+    this.createConnectionCalls += 1;
+    return Promise.resolve(this.connection);
+  }
+
+  async createCommand(connection?: IConnection): Promise<ICommand> {
+    this.createCommandCalls.push(connection);
+    if (connection === undefined) {
+      if (this.connection.isOpen) throw new DatasourceError("Connection is already open");
+      await this.connection.open();
+    }
+    return this.command ?? new MockCommand(connection ?? this.connection);
+  }
+
+  createRepository<T>(type: Constructable<T>, connection?: IConnection): ICRUDRepository<T>;
+  createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+  createRepository<T>(
+    typeOrName: Constructable<T> | string,
+    connection?: IConnection,
+  ): ICRUDRepository<T> {
+    this.createRepositoryCalls.push(connection);
+    if (typeof typeOrName === "string")
+      return this.repositories.create(typeOrName, connection ?? this.connection) as ICRUDRepository<T>;
+    return (this.repository as ICRUDRepository<T> | undefined) ??
+      new MockRepository<T>(connection ?? this.connection, typeOrName);
+  }
+
+  createReadonlyRepository<T>(
+    type: Constructable<T>,
+    connection?: IConnection,
+  ): IReadonlyRepository<T>;
+  createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+  createReadonlyRepository<T>(
+    typeOrName: Constructable<T> | string,
+    connection?: IConnection,
+  ): IReadonlyRepository<T> {
+    if (typeof typeOrName === "string")
+      return this.repositories.createReadonly(typeOrName, connection ?? this.connection) as IReadonlyRepository<T>;
+    return this.createRepository(typeOrName, connection);
+  }
+}

package/src/mocks/mock-driver.ts

@@ -0,0 +1,27 @@
+import { columnType as identityColumnType } from "../IDriver.ts";
+import type { DatasourceOptions } from "../DatasourceOptions.ts";
+import type { ICommand } from "../ICommand.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { IDriver } from "../IDriver.ts";
+import type { ITransaction } from "../ITransaction.ts";
+import type { IsolationLevel } from "../IsolationLevel.ts";
+import type { Cell } from "../converters/Cell.ts";
+import type { TypeConverter } from "../converters/TypeConverter.ts";
+import { MockCommand } from "./mock-command.ts";
+import { MockConnection } from "./mock-connection.ts";
+import { MockTransaction } from "./mock-transaction.ts";
+
+export class MockDriver implements IDriver {
+  rowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = {};
+  columnType = identityColumnType;
+  connection = (_options?: DatasourceOptions): IConnection => new MockConnection();
+  command = (connection: IConnection): ICommand => new MockCommand(connection);
+  transaction = (
+    connection: IConnection,
+    isolation: IsolationLevel = "readCommitted",
+  ): ITransaction => {
+    const txn = new MockTransaction(connection);
+    txn.isolation = isolation;
+    return txn;
+  };
+}

package/src/mocks/mock-reader.ts

@@ -0,0 +1,38 @@
+import type { IReader } from "../IReader.ts";
+import { readerToAsyncIterable } from "../readerToAsyncIterable.ts";
+
+export class MockReader<T = unknown> implements IReader<T> {
+  current: T | undefined = undefined;
+  nextCalls = 0;
+  nextError?: unknown;
+  private index = -1;
+
+  constructor(public rows: readonly T[] = []) {}
+
+  async next(): Promise<boolean> {
+    this.nextCalls += 1;
+    if (this.nextError) {
+      throw this.nextError;
+    }
+    this.index += 1;
+    if (this.index < this.rows.length) {
+      this.current = this.rows[this.index];
+      return true;
+    }
+    this.current = undefined;
+    return false;
+  }
+
+  read(): AsyncIterable<T> {
+    return readerToAsyncIterable(this);
+  }
+
+  async nextResult(): Promise<boolean> {
+    this.current = undefined;
+    return false;
+  }
+
+  async dispose(): Promise<void> {}
+
+  [Symbol.asyncDispose] = (): Promise<void> => this.dispose();
+}

package/src/mocks/mock-repository.ts

@@ -0,0 +1,91 @@
+import type { Scalar } from "../builders/Scalar.ts";
+import type { Cells } from "../converters/Cell.ts";
+import type { Constructable } from "../converters/Constructable.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { Parameter } from "../Parameter.ts";
+import type { IExecuteStoredProcedureStatement } from "../statements/IExecuteStoredProcedureStatement.ts";
+import type { ISelectStatement } from "../statements/ISelectStatement.ts";
+import type { ICRUDRepository } from "../ICRUDRepository.ts";
+import { ReadonlyRepository, untyped } from "../ReadonlyRepository.ts";
+import type { ReadonlyRepositoryMappingOptions } from "../ReadonlyRepositoryMappingOptions.ts";
+import type { Response } from "../Response.ts";
+import type { IWhere } from "../statements/IWhere.ts";
+
+export class MockRepository<T = unknown> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+  readonly ids: readonly string[] = [];
+  items: T[] = [];
+  readSingleCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined> = [];
+  readCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined> = [];
+  addCalls: T[] = [];
+  updateCalls: Array<{ item: T; byWhere?: IWhere }> = [];
+  deleteCalls: Array<{ item: T; byWhere?: IWhere }> = [];
+  readSingleError?: unknown;
+  readError?: unknown;
+  addError?: unknown;
+  updateError?: unknown;
+  deleteError?: unknown;
+  addResponse: Response = { result: undefined, rowsAffected: 1 };
+  updateResponse: Response = { result: undefined, rowsAffected: 1 };
+  deleteResponse: Response = { result: undefined, rowsAffected: 1 };
+
+  constructor(
+    _connection: IConnection,
+    type: Constructable<T> = untyped<T>(),
+  ) {
+    super(type);
+  }
+
+  async readSingle(
+    query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement,
+    _parameters?: Parameter[],
+    _options?: ReadonlyRepositoryMappingOptions<T>,
+  ): Promise<T | undefined> {
+    this.readSingleCalls.push(query);
+    if (this.readSingleError) {
+      throw this.readSingleError;
+    }
+    return this.items[0];
+  }
+
+  async *read(
+    query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement,
+    _parameters?: Parameter[],
+    _options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<T> {
+    this.readCalls.push(query);
+    if (this.readError) {
+      throw this.readError;
+    }
+    for (const item of this.items) {
+      yield item;
+    }
+  }
+
+  async create(item: T): Promise<T> {
+    this.addCalls.push(item);
+    if (this.addError) {
+      throw this.addError;
+    }
+    this.items.push(item);
+    this.addResponse = { result: item, rowsAffected: 1 };
+    return item;
+  }
+
+  async update(item: T, byWhere?: IWhere): Promise<Response> {
+    this.updateCalls.push({ item, byWhere });
+    if (this.updateError) {
+      throw this.updateError;
+    }
+    return this.updateResponse;
+  }
+
+  async delete(item: T, byWhere?: IWhere): Promise<Response> {
+    this.deleteCalls.push({ item, byWhere });
+    if (this.deleteError) {
+      throw this.deleteError;
+    }
+    return this.deleteResponse;
+  }
+
+  readSingleById = (_id: Scalar | Cells): Promise<T | undefined> => this.readSingle();
+}

package/src/mocks/mock-select-statement.ts

@@ -0,0 +1,17 @@
+import type { ISelectStatement } from "../statements/ISelectStatement.ts";
+import type { IStatementVisitor } from "../statements/IStatementVisitor.ts";
+import type { IWhere } from "../statements/IWhere.ts";
+
+export class MockSelectStatement implements ISelectStatement {
+  acceptCalls = 0;
+
+  constructor(
+    public text: string,
+    public where?: IWhere,
+  ) {}
+
+  accept(_visitor: IStatementVisitor): string {
+    this.acceptCalls += 1;
+    return this.text;
+  }
+}

package/src/mocks/mock-transaction.ts

@@ -0,0 +1,31 @@
+import type { IConnection } from "../IConnection.ts";
+import type { ITransaction } from "../ITransaction.ts";
+import { IsolationLevel } from "../IsolationLevel.ts";
+
+export class MockTransaction implements ITransaction {
+  commitCalls = 0;
+  abortCalls = 0;
+  commitError?: unknown;
+  abortError?: unknown;
+  committed = false;
+  aborted = false;
+  isolation: IsolationLevel = IsolationLevel.ReadCommitted;
+
+  constructor(readonly connection: IConnection) {}
+
+  async commit(): Promise<void> {
+    this.commitCalls += 1;
+    if (this.commitError) {
+      throw this.commitError;
+    }
+    this.committed = true;
+  }
+
+  async abort(): Promise<void> {
+    this.abortCalls += 1;
+    if (this.abortError) {
+      throw this.abortError;
+    }
+    this.aborted = true;
+  }
+}

package/src/mocks/mock-where.ts

@@ -0,0 +1,13 @@
+import type { IConditionVisitor } from "../statements/IConditionVisitor.ts";
+import type { IWhere } from "../statements/IWhere.ts";
+
+export class MockWhere implements IWhere {
+  acceptCalls = 0;
+
+  constructor(public text: string) {}
+
+  accept(_visitor: IConditionVisitor): string {
+    this.acceptCalls += 1;
+    return this.text;
+  }
+}

package/src/parametersToRecord.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { parametersToRecord } from "./index.ts";
+
+describe("parametersToRecord", () => {
+  it("returns an empty record when parameters are omitted", () => {
+    expect(parametersToRecord()).toEqual({});
+    expect(parametersToRecord(null)).toEqual({});
+    expect(parametersToRecord(undefined)).toEqual({});
+  });
+
+  it("maps names to values", () => {
+    expect(
+      parametersToRecord([
+        { name: "id", value: 1 },
+        { name: "label", value: "a" },
+      ]),
+    ).toEqual({ id: 1, label: "a" });
+  });
+});

package/src/parametersToRecord.ts

@@ -0,0 +1,11 @@
+import type { Parameter } from "./Parameter.ts";
+
+export function parametersToRecord<T>(
+  parameters?: Parameter<T>[] | null,
+): Record<string, T> {
+  if (!parameters) return {};
+  const record: Record<string, T> = {};
+  for (const parameter of parameters)
+    if (parameter.value !== undefined) record[parameter.name] = parameter.value;
+  return record;
+}

package/src/public-surface.test.ts

@@ -0,0 +1,23 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const providers = join(dirname(fileURLToPath(import.meta.url)), "../../providers");
+
+describe("provider public surface", () => {
+  it("exports only the provider", () => {
+    const names = readdirSync(providers, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name !== "node_modules")
+      .map((entry) => entry.name);
+    expect(names.length).toBeGreaterThanOrEqual(11);
+    for (const name of names) {
+      const source = readFileSync(join(providers, name, "src/index.ts"), "utf8");
+      const match = source.match(
+        /^export \{ ([A-Za-z0-9]+) \} from "\.\/\1\.ts";\n$/,
+      );
+      expect(match, name).not.toBeNull();
+      expect(match?.[1]?.endsWith("Driver"), name).toBe(true);
+    }
+  });
+});