@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/statements/UpdateStatementTextRenderer.ts

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

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

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

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

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

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

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

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

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