@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/mocks/MockDatasource.test.ts

@@ -1,40 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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);
-    }
-  });
-});