@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/statements/UpdateStatementTextRenderer.ts

@@ -1,63 +0,0 @@
-import type { Field } from "../builders/Field.ts";
-import type { Scalar } from "../builders/Scalar.ts";
-import type { Parameter } from "../Parameter.ts";
-import type { IWhere } from "./IWhere.ts";
-import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
-import type { UpdateStatement } from "./UpdateStatement.ts";
-
-const rename = (text: string, name: string, alias: string): string => {
-  const token = `$${name}`;
-  const next = `$${alias}`;
-  let index = 0;
-  let result = "";
-  while (text.indexOf(token, index) >= 0) {
-    const at = text.indexOf(token, index);
-    const end = at + token.length;
-    const nextChar = text.charAt(end);
-    const boundary = nextChar === "" || !/[A-Za-z0-9_]/.test(nextChar);
-    result += text.slice(index, at) + (boundary ? next : token);
-    index = end;
-  }
-  return result + text.slice(index);
-};
-
-const setClause = (fields: Field[]): string =>
-  fields.map((field) => `${field.name} = $${field.name}`).join(", ");
-
-export class UpdateStatementTextRenderer {
-  constructor(private readonly text: StatementTextRenderer) {}
-
-  render(statement: UpdateStatement): string {
-    return this.compose(
-      `UPDATE ${statement.table} SET ${setClause(statement.fields)}`,
-      statement.where,
-      statement.fields,
-    ).text;
-  }
-
-  compose(
-    sql: string,
-    where: IWhere | undefined,
-    fields: Field[],
-  ): { text: string; parameters: Parameter[] } {
-    if (!where) return { text: sql, parameters: fields };
-    const rendered = `${sql} WHERE ${this.text.render(where)}`;
-    const split = rendered.lastIndexOf(" WHERE ");
-    /* v8 ignore next 2 */
-    const head = split < 0 ? rendered : rendered.slice(0, split);
-    let tail = split < 0 ? "" : rendered.slice(split);
-    const parameters: Parameter[] = [...fields];
-    const values = new Map<string, Scalar>();
-    for (const field of fields) values.set(field.name, field.value);
-    for (const parameter of where.parameters ?? []) {
-      if (parameter.value === undefined) continue;
-      const current = values.get(parameter.name);
-      if (values.has(parameter.name) && current !== parameter.value) {
-        const alias = `${parameter.name}__where`;
-        tail = rename(tail, parameter.name, alias);
-        parameters.push({ name: alias, value: parameter.value });
-      } else parameters.push({ name: parameter.name, value: parameter.value });
-    }
-    return { text: head + tail, parameters };
-  }
-}

package/src/statements/Where.ts

@@ -1,250 +0,0 @@
-import type { Parameter } from "../Parameter.ts";
-import type { Cell } from "../converters/Cell.ts";
-import { ArrayExpression } from "./ArrayExpression.ts";
-import { Identifier } from "./Identifier.ts";
-import type { IConditionVisitor } from "./IConditionVisitor.ts";
-import type { IExpression } from "./IExpression.ts";
-import type { IWhere } from "./IWhere.ts";
-import { Literal } from "./Literal.ts";
-import { Operator } from "./Operator.ts";
-import type { Comparison } from "./Cmp.ts";
-import { eq } from "./Cmp.ts";
-import { SelectStatement } from "./SelectStatement.ts";
-import { Subquery } from "./Subquery.ts";
-
-const pair = (
-  expression: Operator,
-): { left: IExpression; right: IExpression } | undefined =>
-  expression instanceof Operator.Equals ||
-  expression instanceof Operator.NotEquals ||
-  expression instanceof Operator.GreaterThan ||
-  expression instanceof Operator.LessThan ||
-  expression instanceof Operator.GreaterThanOrEqual ||
-  expression instanceof Operator.LessThanOrEqual ||
-  expression instanceof Operator.And ||
-  expression instanceof Operator.Or ||
-  expression instanceof Operator.In ||
-  expression instanceof Operator.Like ||
-  expression instanceof Operator.NotLike
-    ? expression
-    : undefined;
-
-const parameterName = (name: string): string =>
-  parts(name)
-    .map((part) =>
-      part.length >= 2 && part.startsWith('"') && part.endsWith('"')
-        ? part.slice(1, -1).replace(/""/g, '"')
-        : part,
-    )
-    .join(".");
-
-const parts = (name: string): string[] => {
-  const found: string[] = [];
-  let start = 0;
-  let quoted = false;
-  for (let i = 0; i < name.length; i++) {
-    if (name[i] === '"') quoted = !quoted;
-    if (name[i] !== "." || quoted) continue;
-    found.push(name.slice(start, i));
-    start = i + 1;
-  }
-  found.push(name.slice(start));
-  return found;
-};
-
-const side = (
-  expression: IExpression,
-  other: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  expression instanceof Literal && other instanceof Identifier
-    ? new Literal(value(other.name, expression.value))
-    : rewrite(expression, column, value);
-
-const inRight = (
-  left: IExpression,
-  right: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  left instanceof Identifier && right instanceof ArrayExpression
-    ? new ArrayExpression(
-        right.elements.map((element) =>
-          element instanceof Literal
-            ? new Literal(value(left.name, element.value))
-            : rewrite(element, column, value),
-        ),
-      )
-    : rewrite(right, column, value);
-
-const bound = (
-  subject: IExpression,
-  edge: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  subject instanceof Identifier && edge instanceof Literal
-    ? new Literal(value(subject.name, edge.value))
-    : rewrite(edge, column, value);
-
-const rewriteWhere = (
-  where: IWhere | undefined,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IWhere | undefined =>
-  where instanceof Where ? new Where(rewrite(where.condition, column, value)) : where;
-
-const rewriteQuery = (
-  query: SelectStatement,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): SelectStatement =>
-  query.table === undefined
-    ? query
-    : new SelectStatement({
-        distinct: query.distinct,
-        table: query.table,
-        fields: query.fields,
-        where: rewriteWhere(query.where, column, value),
-        joins: query.joins.map((join) =>
-          join.on ? { ...join, on: rewrite(join.on, column, value) } : join,
-        ),
-        groupBy: query.groupBy,
-        having: rewriteWhere(query.having, column, value),
-        orderBy: query.orderBy,
-        limit: query.limit,
-        offset: query.offset,
-      });
-
-const rewrite = (
-  expression: IExpression,
-  column: (name: string) => string,
-  value: (name: string, cell: Cell) => Cell,
-): IExpression =>
-  expression instanceof Where
-    ? rewrite(expression.condition, column, value)
-    : expression instanceof Identifier
-      ? new Identifier(column(expression.name))
-      : expression instanceof Literal
-        ? expression
-        : expression instanceof ArrayExpression
-          ? new ArrayExpression(expression.elements.map((element) => rewrite(element, column, value)))
-          : expression instanceof Subquery
-            ? new Subquery(rewriteQuery(expression.query, column, value))
-            : expression instanceof Operator.Not
-              ? new Operator.Not(rewrite(expression.argument, column, value))
-              : expression instanceof Operator.IsNull
-                ? new Operator.IsNull(rewrite(expression.argument, column, value))
-                : expression instanceof Operator.IsNotNull
-                  ? new Operator.IsNotNull(rewrite(expression.argument, column, value))
-                  : expression instanceof Operator.Exists
-                    ? new Operator.Exists(rewrite(expression.argument, column, value))
-                    : expression instanceof Operator.And
-                      ? new Operator.And(rewrite(expression.left, column, value), rewrite(expression.right, column, value))
-                      : expression instanceof Operator.Or
-                        ? new Operator.Or(rewrite(expression.left, column, value), rewrite(expression.right, column, value))
-                        : expression instanceof Operator.In
-                          ? new Operator.In(rewrite(expression.left, column, value), inRight(expression.left, expression.right, column, value))
-                          : expression instanceof Operator.NotIn
-                            ? new Operator.NotIn(rewrite(expression.left, column, value), inRight(expression.left, expression.right, column, value))
-                            : expression instanceof Operator.Like
-                              ? new Operator.Like(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                              : expression instanceof Operator.NotLike
-                                ? new Operator.NotLike(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                                : expression instanceof Operator.Between
-                                  ? new Operator.Between(rewrite(expression.value, column, value), bound(expression.value, expression.low, column, value), bound(expression.value, expression.high, column, value))
-                                  : expression instanceof Operator.NotBetween
-                                    ? new Operator.NotBetween(rewrite(expression.value, column, value), bound(expression.value, expression.low, column, value), bound(expression.value, expression.high, column, value))
-                                    : expression instanceof Operator.Equals
-                                      ? new Operator.Equals(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                                      : expression instanceof Operator.NotEquals
-                                        ? new Operator.NotEquals(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                                        : expression instanceof Operator.GreaterThan
-                                          ? new Operator.GreaterThan(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                                          : expression instanceof Operator.LessThan
-                                            ? new Operator.LessThan(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                                            : expression instanceof Operator.GreaterThanOrEqual
-                                              ? new Operator.GreaterThanOrEqual(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                                              : expression instanceof Operator.LessThanOrEqual
-                                                ? new Operator.LessThanOrEqual(side(expression.left, expression.right, column, value), side(expression.right, expression.left, column, value))
-                                                : (() => {
-                                                    throw new Error("empty expression");
-                                                  })();
-
-const listed = (name: string, elements: IExpression[]): Parameter<Cell>[] =>
-  elements.map((element, i) =>
-    element instanceof Literal
-      ? { name: `${parameterName(name)}_${i}`, value: element.value }
-      : (() => {
-          throw new Error("empty in");
-        })(),
-  );
-
-const collect = (expression: IExpression): Parameter<Cell>[] => {
-  if (expression instanceof Where) return collect(expression.condition);
-  if (expression instanceof Literal || expression instanceof Identifier) return [];
-  if (expression instanceof Operator.Not || expression instanceof Operator.IsNull || expression instanceof Operator.IsNotNull)
-    return collect(expression.argument);
-  if (expression instanceof Operator.Exists) return collect(expression.argument);
-  if (expression instanceof Subquery)
-    return [
-      ...(expression.query.where ? collect(expression.query.where) : []),
-      ...(expression.query.having ? collect(expression.query.having) : []),
-      ...expression.query.joins.flatMap((join) => (join.on ? collect(join.on) : [])),
-    ];
-  if (expression instanceof Operator.In && expression.left instanceof Identifier && expression.right instanceof ArrayExpression)
-    return listed(expression.left.name, expression.right.elements);
-  if (expression instanceof Operator.NotIn && expression.left instanceof Identifier && expression.right instanceof ArrayExpression)
-    return listed(expression.left.name, expression.right.elements);
-  if (expression instanceof Operator.In || expression instanceof Operator.NotIn)
-    return [...collect(expression.left), ...collect(expression.right)];
-  if (
-    (expression instanceof Operator.Between || expression instanceof Operator.NotBetween) &&
-    expression.value instanceof Identifier &&
-    expression.low instanceof Literal &&
-    expression.high instanceof Literal
-  )
-    return [
-      { name: `${parameterName(expression.value.name)}_0`, value: expression.low.value },
-      { name: `${parameterName(expression.value.name)}_1`, value: expression.high.value },
-    ];
-  if (expression instanceof Operator.Between || expression instanceof Operator.NotBetween)
-    return [...collect(expression.value), ...collect(expression.low), ...collect(expression.high)];
-  const operands = expression instanceof Operator ? pair(expression) : undefined;
-  if (operands && operands.left instanceof Identifier && operands.right instanceof Literal)
-    return [{ name: parameterName(operands.left.name), value: operands.right.value }];
-  if (operands && operands.left instanceof Literal && operands.right instanceof Literal) return [];
-  if (operands) return [...collect(operands.left), ...collect(operands.right)];
-  if (expression instanceof ArrayExpression) return expression.elements.flatMap(collect);
-  throw new Error("empty expression");
-};
-
-export class Where implements IWhere {
-  readonly condition: IExpression;
-
-  constructor(condition: IExpression);
-  constructor(column: string, op: Comparison, value: Cell);
-  constructor(columnOrCondition: IExpression | string, op: Comparison = eq, value: Cell = null) {
-    this.condition =
-      typeof columnOrCondition === "string" ? op(columnOrCondition, value) : columnOrCondition;
-  }
-
-  and(column: string, op: Comparison, value: Cell): Where {
-    return new Where(new Operator.And(this.condition, op(column, value)));
-  }
-
-  or(column: string, op: Comparison, value: Cell): Where {
-    return new Where(new Operator.Or(this.condition, op(column, value)));
-  }
-
-  map(column: (name: string) => string, value: (name: string, cell: Cell) => Cell): Where {
-    return new Where(rewrite(this.condition, column, value));
-  }
-
-  accept = (visitor: IConditionVisitor): string => visitor.visit(this);
-
-  get parameters(): Parameter[] {
-    return collect(this.condition) as Parameter[];
-  }
-}

package/src/statements/WhereText.ts

@@ -1,10 +0,0 @@
-import type { IConditionVisitor } from "./IConditionVisitor.ts";
-import type { IWhere } from "./IWhere.ts";
-
-export class WhereText implements IWhere {
-  constructor(private readonly text: string) {}
-  get rawText(): string {
-    return this.text;
-  }
-  accept = (visitor: IConditionVisitor): string => visitor.visit(this);
-}

package/src/statements/index.ts

@@ -1,75 +0,0 @@
-export type { IExpression } from "./IExpression.ts";
-export type { IStatement } from "./IStatement.ts";
-export type { IStatementVisitor } from "./IStatementVisitor.ts";
-export type { ICondition } from "./ICondition.ts";
-export type { IConditionVisitor } from "./IConditionVisitor.ts";
-export type { IWhere } from "./IWhere.ts";
-export type { ISelectStatement } from "./ISelectStatement.ts";
-export type { IInsertStatement } from "./IInsertStatement.ts";
-export type { IUpdateStatement } from "./IUpdateStatement.ts";
-export type { IDeleteStatement } from "./IDeleteStatement.ts";
-export type { IBulkInsertStatement } from "./IBulkInsertStatement.ts";
-export type { IBulkUpdateStatement } from "./IBulkUpdateStatement.ts";
-export type { IBulkDeleteStatement } from "./IBulkDeleteStatement.ts";
-export type { ICreateTableStatement } from "./ICreateTableStatement.ts";
-export type { ICreateIndexStatement } from "./ICreateIndexStatement.ts";
-export type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.ts";
-export type { IReturnStatement } from "./IReturnStatement.ts";
-export type { Column } from "./Column.ts";
-export type { ITableConstraint, TableConstraintKind } from "./ITableConstraint.ts";
-export { Join } from "./Join.ts";
-export type { JoinKind } from "./Join.ts";
-export { Aggregate } from "./Aggregate.ts";
-export type { SortDirection } from "./OrderBy.ts";
-export { OrderBy } from "./OrderBy.ts";
-export type { SelectStatementOptions } from "./SelectStatementOptions.ts";
-export { Condition } from "./Condition.ts";
-export { Operator } from "./Operator.ts";
-export { eq, ne, gt, lt, ge, le } from "./Cmp.ts";
-export type { Comparison } from "./Cmp.ts";
-export { Identifier } from "./Identifier.ts";
-export { Literal } from "./Literal.ts";
-export { ArrayExpression } from "./ArrayExpression.ts";
-export { Where } from "./Where.ts";
-export { ExpressionEvaluator } from "./ExpressionEvaluator.ts";
-export { StatementEvaluator } from "./StatementEvaluator.ts";
-export { WhereText } from "./WhereText.ts";
-export { SelectStatement } from "./SelectStatement.ts";
-export { StatementParser } from "./StatementParser.ts";
-export { StatementTextRenderer } from "./StatementTextRenderer.ts";
-export { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.ts";
-export { StatementRenderer } from "./StatementRenderer.ts";
-export { ExpressionRenderer } from "./ExpressionRenderer.ts";
-export { ConditionRenderer } from "./ConditionRenderer.ts";
-export { Native, n } from "./Native.ts";
-export { Subquery } from "./Subquery.ts";
-export { InsertStatement } from "./InsertStatement.ts";
-export { UpdateStatement } from "./UpdateStatement.ts";
-export { DeleteStatement } from "./DeleteStatement.ts";
-export { BulkInsertStatement } from "./BulkInsertStatement.ts";
-export { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
-export { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
-export { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.ts";
-export { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.ts";
-export { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.ts";
-export { CreateTableStatement } from "./CreateTableStatement.ts";
-export { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.ts";
-export { CreateIndexStatement } from "./CreateIndexStatement.ts";
-export { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.ts";
-export { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.ts";
-export { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.ts";
-export { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.ts";
-export { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.ts";
-export { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.ts";
-export { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.ts";
-export { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.ts";
-export { ColumnDefault } from "./ColumnDefault.ts";
-export { NotNull } from "./NotNull.ts";
-export { PrimaryKey } from "./PrimaryKey.ts";
-export { ForeignKey, ReferentialAction } from "./ForeignKey.ts";
-export type { ReferentialAction as ReferentialActionName } from "./ForeignKey.ts";
-export { UniqueConstraint } from "./UniqueConstraint.ts";
-export { CheckConstraint } from "./CheckConstraint.ts";
-export { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
-export { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
-export { ReturnStatement } from "./ReturnStatement.ts";

package/src/stubs/StubCommand.ts

@@ -1,30 +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 type { Parameter } from "../Parameter.ts";
-import { CommandMiddlewareHost } from "../CommandMiddlewareHost.ts";
-import { Native } from "../statements/Native.ts";
-import { notImplemented } from "./notImplemented.ts";
-
-export class StubCommand extends CommandMiddlewareHost implements ICommand {
-  constructor(
-    readonly provider: string,
-    readonly connection: IConnection,
-  ) {
-    super();
-  }
-
-  executeReaderNative = (
-    text: Native,
-    parameters?: Parameter[],
-  ): Promise<IReader<Cells>> =>
-    this.run(text.text, parameters, async () => notImplemented(this.provider));
-
-  executeNative = (
-    text: Native,
-    parameters?: Parameter[],
-  ): Promise<Response> =>
-    this.run(text.text, parameters, async () => notImplemented(this.provider));
-}

package/src/stubs/StubConnection.ts

@@ -1,21 +0,0 @@
-import type { ICommand } from "../ICommand.ts";
-import type { IConnection } from "../IConnection.ts";
-import type { ITransaction } from "../ITransaction.ts";
-import { StubCommand } from "./StubCommand.ts";
-import { notImplemented } from "./notImplemented.ts";
-
-export class StubConnection implements IConnection {
-  isOpen = false;
-  constructor(readonly provider: string) {}
-
-  createCommand = (): ICommand => new StubCommand(this.provider, this);
-
-  open = async (): Promise<void> => notImplemented(this.provider);
-
-  close = async (): Promise<void> => notImplemented(this.provider);
-
-  [Symbol.asyncDispose] = (): Promise<void> => this.close();
-
-  startTransaction = async (): Promise<ITransaction> =>
-    notImplemented(this.provider);
-}

package/src/stubs/StubDatasource.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  collectAsync,
-  createStubDatasource,
-  ProviderNotImplementedError,
-  StubCommand,
-  StubConnection,
-  StubDatasource,
-  StubReader,
-  StubRepository,
-  StubTransaction,
-  Native,
-  untyped,
-  WhereText,
-} from "../index.ts";
-
-describe("StubDatasource", () => {
-  it("creates stub objects that throw on IO", async () => {
-    const ds = createStubDatasource("text");
-    expect(ds.provider).toBe("text");
-    const connection = await ds.createConnection();
-    expect(connection).toBeInstanceOf(StubConnection);
-    expect(connection.isOpen).toBe(false);
-    expect(connection.createCommand()).toBeInstanceOf(StubCommand);
-    await expect(connection.open()).rejects.toThrow(ProviderNotImplementedError);
-    await expect(connection.close()).rejects.toThrow(ProviderNotImplementedError);
-    await expect(connection.startTransaction()).rejects.toThrow(
-      ProviderNotImplementedError,
-    );
-
-    await expect(ds.createCommand()).rejects.toThrow(ProviderNotImplementedError);
-    connection.open = async () => {
-      connection.isOpen = true;
-    };
-    expect((await ds.createCommand()).connection).toBe(connection);
-    await expect(ds.createCommand()).rejects.toThrow("Connection is already open");
-    const command = connection.createCommand();
-    expect(command).toBeInstanceOf(StubCommand);
-    await expect(command.executeNative(new Native("x"))).rejects.toThrow(ProviderNotImplementedError);
-    await expect(command.executeReaderNative(new Native("select"), [])).rejects.toThrow(
-      ProviderNotImplementedError,
-    );
-
-    const provided = new StubConnection("text");
-    const bound = await ds.createCommand(provided);
-    expect(bound.connection).toBe(provided);
-
-    const repo = ds.createRepository(untyped(), provided);
-    expect(repo).toBeInstanceOf(StubRepository);
-    await expect(repo.readSingle()).rejects.toThrow(ProviderNotImplementedError);
-    await expect(repo.readSingle(new WhereText("1=1"))).rejects.toThrow(
-      ProviderNotImplementedError,
-    );
-    await expect(collectAsync(repo.read())).rejects.toThrow(
-      ProviderNotImplementedError,
-    );
-    await expect(collectAsync(repo.read(new WhereText("1=1")))).rejects.toThrow(
-      ProviderNotImplementedError,
-    );
-    await expect(repo.create({})).rejects.toThrow(ProviderNotImplementedError);
-    await expect(repo.update({})).rejects.toThrow(ProviderNotImplementedError);
-    await expect(repo.delete({}, new WhereText("1=1"))).rejects.toThrow(
-      ProviderNotImplementedError,
-    );
-
-    expect(ds.createRepository(untyped())).toBeInstanceOf(StubRepository);
-    expect(ds.createReadonlyRepository(untyped(), provided)).toBeInstanceOf(StubRepository);
-    expect(() => repo.readSingleById(1)).toThrow(ProviderNotImplementedError);
-    await expect(collectAsync(repo.read())).rejects.toThrow(ProviderNotImplementedError);
-    await expect(collectAsync(repo.read(new WhereText("1=1")))).rejects.toThrow(
-      ProviderNotImplementedError,
-    );
-    class YieldingStub extends StubRepository<{ id: number }> {
-      override async *read(): AsyncIterable<{ id: number }> {
-        yield { id: 1 };
-      }
-    }
-    expect(await collectAsync(new YieldingStub("text", provided).read())).toEqual([{ id: 1 }]);
-
-    const txn = new StubTransaction("text", provided);
-    await expect(txn.commit()).rejects.toThrow(ProviderNotImplementedError);
-    await expect(txn.abort()).rejects.toThrow(ProviderNotImplementedError);
-
-    const reader = new StubReader("text");
-    expect(reader.current).toBeUndefined();
-    await expect(reader.next()).rejects.toThrow(ProviderNotImplementedError);
-    await expect(Array.fromAsync(reader.read())).rejects.toThrow(ProviderNotImplementedError);
-    await expect(reader.nextResult()).rejects.toThrow(ProviderNotImplementedError);
-    await reader.dispose();
-    await reader[Symbol.asyncDispose]();
-
-    const named = new StubDatasource("yaml");
-    await expect(named.createCommand()).rejects.toThrow(ProviderNotImplementedError);
-    const stub = new StubRepository(named.provider, provided);
-    named.repositories.register("Item", "items", () => stub, () => stub);
-    expect(named.createRepository("items")).toBe(stub);
-    expect(named.createReadonlyRepository("Item")).toBe(stub);
-  });
-});

package/src/stubs/StubDatasource.ts

@@ -1,60 +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 { StubCommand } from "./StubCommand.ts";
-import { StubConnection } from "./StubConnection.ts";
-import { StubRepository } from "./StubRepository.ts";
-export class StubDatasource implements IDatasource {
-  private connection?: IConnection;
-  readonly repositories = new RepositoryFactory();
-
-  constructor(readonly provider: string) {}
-
-  private defaultConnection = (): IConnection =>
-    (this.connection ??= new StubConnection(this.provider));
-
-  createConnection = (): Promise<IConnection> =>
-    Promise.resolve(this.defaultConnection());
-
-  createCommand = async (connection?: IConnection): Promise<ICommand> => {
-    if (!connection) {
-      connection = this.defaultConnection();
-      if (connection.isOpen) throw new DatasourceError("Connection is already open");
-      await connection.open();
-    }
-    return new StubCommand(this.provider, 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> {
-    if (typeof typeOrName === "string")
-      return this.repositories.create(typeOrName, connection ?? this.defaultConnection()) as ICRUDRepository<T>;
-    return new StubRepository<T>(this.provider, connection ?? this.defaultConnection(), 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.defaultConnection()) as IReadonlyRepository<T>;
-    return this.createRepository(typeOrName, connection);
-  }
-}

package/src/stubs/StubReader.ts

@@ -1,25 +0,0 @@
-import type { IReader } from "../IReader.ts";
-import { readerToAsyncIterable } from "../readerToAsyncIterable.ts";
-import { notImplemented } from "./notImplemented.ts";
-
-export class StubReader<T = unknown> implements IReader<T> {
-  current: T | undefined = undefined;
-
-  constructor(readonly provider: string) {}
-
-  async next(): Promise<boolean> {
-    notImplemented(this.provider);
-  }
-
-  read(): AsyncIterable<T> {
-    return readerToAsyncIterable(this);
-  }
-
-  async nextResult(): Promise<boolean> {
-    notImplemented(this.provider);
-  }
-
-  async dispose(): Promise<void> {}
-
-  [Symbol.asyncDispose] = (): Promise<void> => this.dispose();
-}