@deterministic-code/datasources 0.0.0-stage → 0.1.0

package/src/index.ts

@@ -0,0 +1,222 @@
+export type { ICommand } from "./ICommand.ts";
+export { execute, executeReader } from "./ICommand.ts";
+export type { ICommandMiddleware } from "./ICommandMiddleware.ts";
+export type { IConnection } from "./IConnection.ts";
+export type { IDatasource } from "./IDatasource.ts";
+export type { IDriver } from "./IDriver.ts";
+export { columnType } from "./IDriver.ts";
+export type { Information } from "./Information.ts";
+export type { DatasourceOptions } from "./DatasourceOptions.ts";
+export { DatasourceFactory } from "./DatasourceFactory.ts";
+export { ProviderCatalog } from "./ProviderCatalog.ts";
+export type {
+  ICreateTableStatement,
+  ICreateIndexStatement,
+  IDeleteStatement,
+  IExpression,
+  IBulkDeleteStatement,
+  IBulkInsertStatement,
+  IBulkUpdateStatement,
+  IInsertStatement,
+  ISelectStatement,
+  IStatement,
+  IStatementVisitor,
+  ICondition,
+  IConditionVisitor,
+  IExecuteStoredProcedureStatement,
+  IReturnStatement,
+  ITableConstraint,
+  TableConstraintKind,
+  IUpdateStatement,
+  IWhere,
+} from "./statements/index.ts";
+export type { IReader } from "./IReader.ts";
+export type { IRepository } from "./IRepository.ts";
+export type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+export type { ICRUDRepository } from "./ICRUDRepository.ts";
+export { ReadonlyRepository, untyped } from "./ReadonlyRepository.ts";
+export type { IRepositoryFactory } from "./IRepositoryFactory.ts";
+export type { ICRUDRepositoryFactory } from "./ICRUDRepositoryFactory.ts";
+export { RepositoryFactory } from "./RepositoryFactory.ts";
+export { RepositoryAccess } from "./RepositoryAccess.ts";
+export { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.ts";
+export type { IEnriched } from "./IEnriched.ts";
+export type { IRepositoryTree } from "./IRepositoryTree.ts";
+export type { IRepositoryTreeNode } from "./IRepositoryTreeNode.ts";
+export type { Association, Enrichment } from "./Enrichment.ts";
+export { EnrichmentPropertyType } from "./EnrichmentPropertyType.ts";
+export type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.ts";
+export type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.ts";
+export type { WriteMode } from "./WriteMode.ts";
+export { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
+export { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+export { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.ts";
+export { CascadeDeleteEnrichmentStrategy } from "./CascadeDeleteEnrichmentStrategy.ts";
+export { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.ts";
+export { DefaultUpdateEnrichmentStrategy } from "./DefaultUpdateEnrichmentStrategy.ts";
+export { CreateEnrichmentStrategy } from "./CreateEnrichmentStrategy.ts";
+export { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.ts";
+export { CascadeDeleteUpdateEnrichmentStrategy } from "./CascadeDeleteUpdateEnrichmentStrategy.ts";
+export { LazyWriteEnrichmentStrategy } from "./LazyWriteEnrichmentStrategy.ts";
+export { HashsetOptimizedReadonlyEnrichmentStrategy } from "./HashsetOptimizedReadonlyEnrichmentStrategy.ts";
+export { NestedToObjectEnrichmentStrategy } from "./NestedToObjectEnrichmentStrategy.ts";
+export { BulkCRUDRepository } from "./BulkCRUDRepository.ts";
+export type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
+export type { BulkCommand } from "./BulkCommand.ts";
+export { SingleCommandIBulkWriteStrategy } from "./SingleCommandIBulkWriteStrategy.ts";
+export { BatchCommandIBulkWriteStrategy } from "./BatchCommandIBulkWriteStrategy.ts";
+export { StoredProcedureBulkWriteStrategy } from "./StoredProcedureBulkWriteStrategy.ts";
+export { RepositoryTree } from "./RepositoryTree.ts";
+export { RepositoryTreeNode } from "./RepositoryTreeNode.ts";
+export { CRUDRepository } from "./CRUDRepository.ts";
+export { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.ts";
+export { CRUDRepositoryBuilder } from "./CRUDRepositoryBuilder.ts";
+export { StatementMappers } from "./StatementMappers.ts";
+export { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
+export { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.ts";
+export type { BuiltRepository } from "./BuiltRepository.ts";
+export { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.ts";
+export { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.ts";
+export type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+export type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+export { Response } from "./Response.ts";
+export type { ITransaction } from "./ITransaction.ts";
+export type { IUnitOfWork } from "./IUnitOfWork.ts";
+export { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.ts";
+export { IsolationLevel } from "./IsolationLevel.ts";
+export type { IsolationLevel as IsolationLevelName } from "./IsolationLevel.ts";
+export type { Comparison } from "./statements/index.ts";
+export {
+  ArrayExpression,
+  CheckConstraint,
+  ColumnDefault,
+  Condition,
+  ConditionRenderer,
+  ExpressionRenderer,
+  CreateIndexStatement,
+  CreateTableStatement,
+  CreateTableStatementTextRenderer,
+  CreateIndexStatementTextRenderer,
+  SelectStatementTextRenderer,
+  InsertStatementTextRenderer,
+  UpdateStatementTextRenderer,
+  DeleteStatementTextRenderer,
+  BulkInsertStatementTextRenderer,
+  BulkUpdateStatementTextRenderer,
+  BulkDeleteStatementTextRenderer,
+  ExecuteStoredProcedureStatementTextRenderer,
+  ReturnStatementTextRenderer,
+  SelectInsertedIdStatementTextRenderer,
+  DefaultStatementTextRenderer,
+  DeleteStatement,
+  ForeignKey,
+  Identifier,
+  InsertStatement,
+  BulkInsertStatement,
+  BulkUpdateStatement,
+  BulkDeleteStatement,
+  Literal,
+  NotNull,
+  Operator,
+  eq,
+  ne,
+  gt,
+  lt,
+  ge,
+  le,
+  PrimaryKey,
+  Aggregate,
+  OrderBy,
+  SelectStatement,
+  StatementParser,
+  StatementRenderer,
+  StatementTextRenderer,
+  Native,
+  n,
+  Subquery,
+  ReferentialAction,
+  ExpressionEvaluator,
+  StatementEvaluator,
+  ExecuteStoredProcedureStatement,
+  SelectInsertedIdStatement,
+  ReturnStatement,
+  UniqueConstraint,
+  UpdateStatement,
+  WhereText,
+  Where,
+  Join,
+} from "./statements/index.ts";
+export type { IDatasourceFactory } from "./IDatasourceFactory.ts";
+export type { Parameter } from "./Parameter.ts";
+export { ParameterDirection } from "./ParameterDirection.ts";
+export type { ParameterDirection as ParameterDirectionName } from "./ParameterDirection.ts";
+export type { Row } from "./Row.ts";
+export { ArrayReader } from "./ArrayReader.ts";
+export { FirstResultReader } from "./FirstResultReader.ts";
+export { StreamingReader, statementReader } from "./StreamingReader.ts";
+export { splitStatements } from "./splitStatements.ts";
+export { statementParameters } from "./statementParameters.ts";
+export { statementUsesParameter } from "./statementUsesParameter.ts";
+export { collectAsync } from "./collectAsync.ts";
+export { CommandMiddlewareHost } from "./CommandMiddlewareHost.ts";
+export {
+  ConsoleCommandMiddleware,
+  formatElapsed,
+} from "./ConsoleCommandMiddleware.ts";
+export { ExpectConsoleMiddleware } from "./ExpectConsoleMiddleware.ts";
+export { Datasource } from "./Datasource.ts";
+export { DatasourceUrl } from "./DatasourceUrl.ts";
+export { DatasourceUrlParser } from "./DatasourceUrlParser.ts";
+import { Datasource } from "./Datasource.ts";
+import { DatasourceFactory } from "./DatasourceFactory.ts";
+Datasource.create = (options) => DatasourceFactory.create(options) as Datasource;
+export { DatasourceError } from "./DatasourceError.ts";
+export type { Cell, Cells } from "./converters/Cell.ts";
+export type { Constructable } from "./converters/Constructable.ts";
+export { TypeConverter } from "./converters/TypeConverter.ts";
+export { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+export { RowTypeConverter } from "./converters/RowTypeConverter.ts";
+export { ToLowerCaseConverter } from "./converters/ToLowerCaseConverter.ts";
+export { ToUpperCaseConverter } from "./converters/ToUpperCaseConverter.ts";
+export { ChangeCasingConverter, type Casing } from "./converters/ChangeCasingConverter.ts";
+export { PluralizerConverter } from "./converters/PluralizerConverter.ts";
+export { RegexConverter } from "./converters/RegexConverter.ts";
+export { ReplaceConverter } from "./converters/ReplaceConverter.ts";
+export type { IMapper } from "./mappers/IMapper.ts";
+export type { IFlatToNestedMapper } from "./mappers/IFlatToNestedMapper.ts";
+export type { TypeMap, TypeMapFields } from "./mappers/TypeMap.ts";
+export type { TypeMapGroup } from "./mappers/TypeMapGroup.ts";
+export { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.ts";
+export { ChangeCasingMapper } from "./mappers/ChangeCasingMapper.ts";
+export { DictionaryMapper } from "./mappers/DictionaryMapper.ts";
+export { IdentityMapper } from "./mappers/IdentityMapper.ts";
+export { PluralizerMapper } from "./mappers/PluralizerMapper.ts";
+export { TransformMapper } from "./mappers/TransformMapper.ts";
+export { TransformConverterMapper } from "./mappers/TransformConverterMapper.ts";
+export { RowTypeMapper } from "./mappers/RowTypeMapper.ts";
+export { parametersToRecord } from "./parametersToRecord.ts";
+export { ProviderNotImplementedError } from "./ProviderNotImplementedError.ts";
+export { ProviderNotInstalledError } from "./ProviderNotInstalledError.ts";
+export type { Column, JoinKind, SelectStatementOptions, ReferentialAction as ReferentialActionName, SortDirection } from "./statements/index.ts";
+export type { Field, Scalar } from "./builders/index.ts";
+export { readerToAsyncIterable } from "./readerToAsyncIterable.ts";
+export {
+  StubCommand,
+  StubConnection,
+  StubDatasource,
+  StubReader,
+  StubRepository,
+  StubTransaction,
+  createStubDatasource,
+} from "./stubs/index.ts";
+export {
+  MockCommand,
+  MockConnection,
+  MockDatasource,
+  MockDriver,
+  MockSelectStatement,
+  MockReader,
+  MockRepository,
+  MockTransaction,
+  MockWhere,
+} from "./mocks/index.ts";

package/src/mappers/ChangeCasingMapper.ts

@@ -0,0 +1,15 @@
+import { ChangeCasingConverter, type Casing } from "../converters/ChangeCasingConverter.ts";
+import type { IMapper } from "./IMapper.ts";
+
+export class ChangeCasingMapper implements IMapper<string, string> {
+  private readonly forward: ChangeCasingConverter;
+  private readonly reverse: ChangeCasingConverter;
+
+  constructor(from: Casing, to: Casing) {
+    this.forward = new ChangeCasingConverter(to);
+    this.reverse = new ChangeCasingConverter(from);
+  }
+
+  map = (value: string): string => this.forward.convert(value);
+  reverseMap = (value: string): string => this.reverse.convert(value);
+}

package/src/mappers/DictionaryMapper.ts

@@ -0,0 +1,16 @@
+import type { IMapper } from "./IMapper.ts";
+
+export class DictionaryMapper<T extends string | number> implements IMapper<T, T> {
+  private readonly forward = new Map<T, T>();
+  private readonly reverse = new Map<T, T>();
+
+  constructor(map: readonly (readonly [T, T])[]) {
+    for (const [from, to] of map) {
+      this.forward.set(from, to);
+      if (!this.reverse.has(to)) this.reverse.set(to, from);
+    }
+  }
+
+  map = (value: T): T => this.forward.get(value) ?? value;
+  reverseMap = (value: T): T => this.reverse.get(value) ?? value;
+}

package/src/mappers/FlatToNestedMapper.ts

@@ -0,0 +1,127 @@
+import type { Cell, Cells } from "../converters/Cell.ts";
+import type { IFlatToNestedMapper } from "./IFlatToNestedMapper.ts";
+import type { TypeMap, TypeMapFields } from "./TypeMap.ts";
+import type { TypeMapGroup } from "./TypeMapGroup.ts";
+
+type GroupPlan = { key: string; fields: Record<string, string>; destKey: string };
+
+const stringFields = (fields: TypeMapFields<object>): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(fields).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
+  );
+
+const destOf = (fields: Record<string, string>, column: string) =>
+  Object.entries(fields).find(([, source]) => source === column)?.[0] ?? column;
+
+const cellKey = (value: Cell | undefined) => (value == null ? null : String(value));
+
+export class FlatToNestedMapper<T> implements IFlatToNestedMapper<T> {
+  readonly spec: TypeMap<T>;
+  private readonly scalars: Record<string, string>;
+  private readonly groups: Record<string, GroupPlan>;
+  private readonly parentDest: string;
+
+  constructor(spec: TypeMap<T>) {
+    this.spec = spec;
+    this.scalars = {};
+    this.groups = {};
+    for (const [name, value] of Object.entries(spec.fields) as [string, string | TypeMapGroup<object>][]) {
+      if (typeof value === "string") this.scalars[name] = value;
+      else {
+        const fields = stringFields(value.fields);
+        this.groups[name] = { key: value.key, fields, destKey: destOf(fields, value.key) };
+      }
+    }
+    this.parentDest = destOf(this.scalars, spec.key);
+  }
+
+  map = (rows: Iterable<T | Cells>): T[] => this._collapse(rows);
+
+  reverseMap = (values: T[]): Cells[] => [...values].flatMap((value) => this.explode(value));
+
+  private _map = (row: Cells): T => {
+    const dest = {} as Record<string, Cell | Cells[]>;
+    for (const [name, column] of Object.entries(this.scalars)) dest[name] = row[column] ?? null;
+    for (const [name, group] of Object.entries(this.groups)) {
+      const key = row[group.key];
+      dest[name] =
+        key == null
+          ? []
+          : [
+              Object.fromEntries(
+                Object.entries(group.fields).map(([field, column]) => [field, row[column] ?? null]),
+              ),
+            ];
+    }
+    return dest as T;
+  };
+
+  private _collapse = (rows: Iterable<T | Cells>): T[] => {
+    const byParent = new Map<string, T>();
+    const seen = new Set<string>();
+    for (const raw of rows) {
+      const item = this.mapped(raw) ? raw : this._map(raw);
+      const parent = cellKey((item as Record<string, Cell>)[this.parentDest]);
+      if (parent == null) continue;
+      const existing = byParent.get(parent);
+      if (!existing) {
+        byParent.set(parent, item);
+        this.mark(seen, parent, item);
+        continue;
+      }
+      this.merge(existing, item, parent, seen);
+    }
+    return [...byParent.values()];
+  };
+
+  private explode = (value: T): Cells[] => {
+    const record = value as Record<string, Cell | Cells[]>;
+    let rows: Cells[] = [this.scalarsOf(record)];
+    for (const [name, group] of Object.entries(this.groups)) {
+      const children = (record[name] as Cells[] | undefined)?.length
+        ? (record[name] as Cells[])
+        : [undefined];
+      rows = rows.flatMap((row) => children.map((child) => this.withChild(row, group, child)));
+    }
+    return rows;
+  };
+
+  private scalarsOf = (record: Record<string, Cell | Cells[]>): Cells => {
+    const row: Cells = {};
+    for (const [name, column] of Object.entries(this.scalars))
+      row[column] = (record[name] as Cell | undefined) ?? null;
+    return row;
+  };
+
+  private withChild = (row: Cells, group: GroupPlan, child: Cells | undefined): Cells => {
+    const next = { ...row };
+    for (const [field, column] of Object.entries(group.fields)) next[column] = child?.[field] ?? null;
+    return next;
+  };
+
+  private mapped = (row: T | Cells): row is T =>
+    Object.keys(this.groups).every((name) => Array.isArray((row as Record<string, unknown>)[name]));
+
+  private mark = (seen: Set<string>, parent: string, item: T) => {
+    const record = item as Record<string, Cells[]>;
+    for (const [name, group] of Object.entries(this.groups))
+      for (const child of record[name]) {
+        const key = cellKey(child[group.destKey]);
+        if (key != null) seen.add(`${parent}:${name}:${key}`);
+      }
+  };
+
+  private merge = (into: T, from: T, parent: string, seen: Set<string>) => {
+    const dest = into as Record<string, Cells[]>;
+    const source = from as Record<string, Cells[]>;
+    for (const [name, group] of Object.entries(this.groups)) {
+      const children = dest[name];
+      for (const child of source[name]) {
+        const key = cellKey(child[group.destKey]);
+        if (key == null || seen.has(`${parent}:${name}:${key}`)) continue;
+        seen.add(`${parent}:${name}:${key}`);
+        children.push(child);
+      }
+    }
+  };
+}

package/src/mappers/IFlatToNestedMapper.ts

@@ -0,0 +1,7 @@
+import type { Cells } from "../converters/Cell.ts";
+import type { IMapper } from "./IMapper.ts";
+import type { TypeMap } from "./TypeMap.ts";
+
+export interface IFlatToNestedMapper<T> extends IMapper<Iterable<T | Cells>, T[]> {
+  readonly spec: TypeMap<T>;
+}

package/src/mappers/IMapper.ts

@@ -0,0 +1,4 @@
+export interface IMapper<TFrom, TTo> {
+  map(value: TFrom): TTo;
+  reverseMap(value: TTo): TFrom;
+}

package/src/mappers/IdentityMapper.ts

@@ -0,0 +1,6 @@
+import type { IMapper } from "./IMapper.ts";
+
+export class IdentityMapper<T> implements IMapper<T, T> {
+  map = (value: T): T => value;
+  reverseMap = (value: T): T => value;
+}

package/src/mappers/PluralizerMapper.ts

@@ -0,0 +1,9 @@
+import { PluralizerConverter } from "../converters/PluralizerConverter.ts";
+import type { IMapper } from "./IMapper.ts";
+
+export class PluralizerMapper implements IMapper<string, string> {
+  private readonly pluralizer = new PluralizerConverter();
+
+  map = (value: string): string => this.pluralizer.convert(value);
+  reverseMap = (value: string): string => this.pluralizer.reverseConvert(value);
+}

package/src/mappers/RowTypeMapper.ts

@@ -0,0 +1,13 @@
+import type { Cells } from "../converters/Cell.ts";
+import { MetaDataRowTypeConverter as RowTypeConverter } from "../converters/MetaDataRowTypeConverter.ts";
+import type { TypeConverter } from "../converters/TypeConverter.ts";
+import { TransformMapper } from "./TransformMapper.ts";
+
+export class RowTypeMapper<T> extends TransformMapper<Cells, T> {
+  constructor(converter: TypeConverter<T, Cells> = new RowTypeConverter()) {
+    super(
+      (row) => converter.convert(row),
+      (item) => converter.reverseConvert(item),
+    );
+  }
+}

package/src/mappers/TransformConverterMapper.ts

@@ -0,0 +1,11 @@
+import type { TypeConverter } from "../converters/TypeConverter.ts";
+import { TransformMapper } from "./TransformMapper.ts";
+
+export class TransformConverterMapper<T> extends TransformMapper<T, T> {
+  constructor(converter: TypeConverter<T, T>, filter?: (value: T) => boolean) {
+    super(
+      (value) => (filter?.(value) !== false ? converter.convert(value) : value),
+      (value) => (filter?.(value) !== false ? converter.reverseConvert(value) : value),
+    );
+  }
+}

package/src/mappers/TransformMapper.ts

@@ -0,0 +1,8 @@
+import type { IMapper } from "./IMapper.ts";
+
+export class TransformMapper<TFrom, TTo> implements IMapper<TFrom, TTo> {
+  constructor(
+    readonly map: (value: TFrom) => TTo,
+    readonly reverseMap: (value: TTo) => TFrom,
+  ) {}
+}

package/src/mappers/TypeMap.ts

@@ -0,0 +1,10 @@
+import type { TypeMapGroup } from "./TypeMapGroup.ts";
+
+export type TypeMapFields<T> = {
+  [K in keyof T]?: T[K] extends readonly (infer E)[] ? TypeMapGroup<E> : string;
+};
+
+export type TypeMap<T> = {
+  key: string;
+  fields: TypeMapFields<T>;
+};

package/src/mappers/TypeMapGroup.ts

@@ -0,0 +1,6 @@
+import type { TypeMapFields } from "./TypeMap.ts";
+
+export type TypeMapGroup<E> = {
+  key: string;
+  fields: TypeMapFields<E>;
+};

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);
+  }
+}