@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/ReadonlyRepository.ts

@@ -0,0 +1,276 @@
+import type { ICommand } from "./ICommand.ts";
+import { executeReader } from "./ICommand.ts";
+import type { ICommandMiddleware } from "./ICommandMiddleware.ts";
+import type { IConnection } from "./IConnection.ts";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
+import type { Parameter } from "./Parameter.ts";
+import type { ISelectStatement } from "./statements/ISelectStatement.ts";
+import type { IStatement } from "./statements/IStatement.ts";
+import type { IReadonlyRepository, ReadQuery } from "./IReadonlyRepository.ts";
+import type { Row } from "./Row.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import { DatasourceError } from "./DatasourceError.ts";
+import type { Cell, Cells } from "./converters/Cell.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+import { SelectStatement } from "./statements/SelectStatement.ts";
+import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.ts";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+import type { BuiltRepository } from "./BuiltRepository.ts";
+import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.ts";
+import type { TypeConverter } from "./converters/TypeConverter.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+import { IdentityMapper } from "./mappers/IdentityMapper.ts";
+import type { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
+import { StatementMappers } from "./StatementMappers.ts";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
+import type { Enrichment } from "./Enrichment.ts";
+import type { IEnriched } from "./IEnriched.ts";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.ts";
+import { StoredEnrichment } from "./StoredEnrichment.ts";
+
+export const untyped = <T>(): Constructable<T> => Object as never as Constructable<T>;
+
+export type Sourced<T> = { item: T; source?: Row };
+
+const storedEnrichments = new WeakMap<object, StoredEnrichment[]>();
+
+export const enrichmentsOf = (host: object): readonly StoredEnrichment[] | undefined =>
+  storedEnrichments.get(host);
+
+export const isBuilt = <T>(
+  value: IConnection | BuiltRepository<T>,
+): value is BuiltRepository<T> =>
+  "statements" in value && "objectConverter" in value && "propertyMappings" in value;
+
+export const builtOf = <T>(
+  typeOrConnectionOrBuilt: Constructable<T> | IConnection | BuiltRepository<T>,
+  connectionOrOptions?: IConnection | ReadonlyRepositoryMappingOptions<T>,
+): BuiltRepository<T> | undefined =>
+  typeof typeOrConnectionOrBuilt === "function"
+    ? connectionOrOptions === undefined
+      ? undefined
+      : new ReadonlyRepositoryBuilder<T>().parts(
+          connectionOrOptions as IConnection,
+          createReadonlyRepositoryMappingOptions(typeOrConnectionOrBuilt),
+        )
+    : isBuilt(typeOrConnectionOrBuilt)
+      ? typeOrConnectionOrBuilt
+      : new ReadonlyRepositoryBuilder<T>().parts(
+          typeOrConnectionOrBuilt,
+          connectionOrOptions as ReadonlyRepositoryMappingOptions<T>,
+        );
+
+export class ReadonlyRepository<T> implements IReadonlyRepository<T>, IEnriched<T> {
+  readonly type: Constructable<T>;
+  private connection?: IConnection;
+  protected rowConverter?: TypeConverter<Cells, Cells>;
+  protected objectConverter?: TypeConverter<T, Cells>;
+  private entityMappers: IMapper<string, string> = new IdentityMapper();
+  private propertyMappers: IMapper<string, string> = new IdentityMapper();
+  private statementMappers = new StatementMappers(new IdentityMapper(), new IdentityMapper());
+  private readonlyStatements?: ReadonlyRepositoryStatements;
+  private readonly middlewares: ICommandMiddleware[] = [];
+
+  constructor(type: Constructable<T>);
+  constructor(type: Constructable<T>, connection: IConnection);
+  constructor(connection: IConnection, options: ReadonlyRepositoryMappingOptions<T>);
+  constructor(built: BuiltRepository<T>);
+  constructor();
+  constructor(
+    typeOrConnectionOrBuilt?: Constructable<T> | IConnection | BuiltRepository<T>,
+    connectionOrOptions?: IConnection | ReadonlyRepositoryMappingOptions<T>,
+  ) {
+    storedEnrichments.set(this, []);
+    if (typeOrConnectionOrBuilt === undefined) {
+      this.type = untyped();
+      return;
+    }
+    const built = builtOf(typeOrConnectionOrBuilt, connectionOrOptions);
+    if (!built) {
+      this.type = typeOrConnectionOrBuilt as Constructable<T>;
+      return;
+    }
+    this.type = built.type;
+    this.connection = built.connection;
+    this.rowConverter = built.rowConverter;
+    this.objectConverter = built.objectConverter;
+    this.entityMappers = built.entityMapper;
+    this.propertyMappers = built.propertyMappings;
+    this.statementMappers = new StatementMappers(built.entityMapper, built.propertyMappings);
+    this.readonlyStatements = built.statements;
+  }
+
+  addMiddleware = (middleware: ICommandMiddleware): this => {
+    this.middlewares.push(middleware);
+    return this;
+  };
+
+  addEnriched<TRelated extends object>(
+    enrichment: Enrichment,
+    via: IReadonlyRepository<TRelated>,
+    strategy?: IReadonlyEnrichmentStrategy<T & object>,
+  ): this {
+    const chosen = strategy ?? new DefaultReadonlyEnrichmentStrategy<T & object>();
+    this.entries().push(
+      new StoredEnrichment<T & object>(
+        enrichment,
+        (parents, sources) => chosen.apply(via, enrichment, parents, sources),
+      ),
+    );
+    return this;
+  }
+
+  async *read(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<T> {
+    for await (const sourced of this.readTracked(query, parameters, options)) yield sourced.item;
+  }
+
+  async readSingle(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): Promise<T | undefined> {
+    for await (const item of this.read(query, parameters, options)) return item;
+    return undefined;
+  }
+
+  protected get enriched(): boolean {
+    return this.entries().length > 0;
+  }
+
+  protected command = (): ICommand =>
+    this.middlewares.reduce(
+      (command, middleware) => command.addMiddleware(middleware),
+      this.connection!.createCommand(),
+    );
+
+  protected column = (property: string): string => this.statementMappers.column(property);
+
+  protected cell = (
+    property: string,
+    value: Cell,
+    fieldsApplied: boolean,
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): Cell => {
+    const objects = options?.objectConverter ?? this.objectConverter;
+    const field =
+      objects instanceof MetaDataRowTypeConverter ? objects.fields[property] : undefined;
+    return field && !fieldsApplied ? field.reverseConvert(value) : value;
+  };
+
+  private entries = (): StoredEnrichment<T & object>[] =>
+    storedEnrichments.get(this) as StoredEnrichment<T & object>[];
+
+  private mappers = (options?: ReadonlyRepositoryMappingOptions<T>): StatementMappers =>
+    options?.entityMapper === undefined && options?.propertyMappings === undefined
+      ? this.statementMappers
+      : new StatementMappers(
+          options?.entityMapper ?? this.entityMappers,
+          options?.propertyMappings ?? this.propertyMappers,
+        );
+
+  private rowConverterOf = (options?: ReadonlyRepositoryMappingOptions<T>): TypeConverter<Cells, Cells> | undefined =>
+    options?.rowConverter ?? this.rowConverter;
+
+  private objects = (options?: ReadonlyRepositoryMappingOptions<T>): TypeConverter<T, Cells> =>
+    options?.objectConverter ??
+    this.objectConverter ??
+    (() => {
+      throw new DatasourceError("Object converter required");
+    })();
+
+  private async *readTracked(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<Sourced<T>> {
+    const mappers = this.mappers(options);
+    const statement = mappers.apply(
+      query instanceof ExecuteStoredProcedureStatement ? query : this.readQuery(query, mappers, options),
+      (name, value) => this.cell(name, value, false, options),
+    );
+    const listed =
+      parameters ??
+      (statement instanceof SelectStatement ? statement.where?.parameters : undefined);
+    yield* this.apply(this.readItems(statement, listed, mappers, this.rowConverterOf(options), this.objects(options)));
+  }
+
+  private async *apply(pairs: AsyncIterable<Sourced<T>>): AsyncIterable<Sourced<T>> {
+    if (!this.enriched) {
+      yield* pairs;
+      return;
+    }
+    yield* this.sourced(pairs);
+  }
+
+  private convertObject = (row: Cells, objects: TypeConverter<T, Cells>): T =>
+    objects instanceof MetaDataRowTypeConverter
+      ? objects.convert(row, this.type)
+      : objects.convert(row);
+
+  private async *readItems(
+    query: IStatement | undefined,
+    parameters: Parameter[] | undefined,
+    mappers: StatementMappers,
+    rows: TypeConverter<Cells, Cells> | undefined,
+    objects: TypeConverter<T, Cells>,
+  ): AsyncIterable<Sourced<T>> {
+    const statement = query ?? this.readonlyStatements!.select();
+    const reader = await executeReader(this.command(), statement, parameters);
+    try {
+      while (await reader.next()) {
+        const renamed = this.columnToPropertyName(
+          reader.current ??
+            (() => {
+              throw new DatasourceError("Reader current must be a row");
+            })(),
+          mappers,
+        );
+        yield {
+          item: this.convertObject(rows ? rows.convert(renamed) : renamed, objects),
+          source: renamed,
+        };
+      }
+    } finally {
+      await reader.dispose();
+    }
+  }
+
+  private async *sourced(pairs: AsyncIterable<Sourced<T>>): AsyncIterable<Sourced<T>> {
+    const items: T[] = [];
+    const sources: (Row | undefined)[] = [];
+    for await (const sourced of pairs) {
+      items.push(sourced.item);
+      sources.push(sourced.source);
+    }
+    await this.fill(items as (T & object)[], sources);
+    for (let index = 0; index < items.length; index++)
+      yield { item: items[index]!, source: sources[index] };
+  }
+
+  private fill = async (parents: (T & object)[], sources?: (Row | undefined)[]): Promise<void> => {
+    for (const entry of this.entries()) await entry.apply(parents, sources);
+  };
+
+  private columnToPropertyName = (row: Cells, mappers: StatementMappers): Cells =>
+    Object.fromEntries(Object.entries(row).map(([key, value]) => [mappers.property(key), value]));
+
+  private readQuery = (
+    query: ISelectStatement | IWhere | undefined,
+    mappers: StatementMappers,
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): ISelectStatement | undefined =>
+    !query
+      ? this.readonlyStatements?.select()
+      : "where" in query
+        ? query
+        : this.readonlyStatements
+          ? this.readonlyStatements.select(
+              mappers.applyWhere(query, (name, cell) => this.cell(name, cell, false, options))!,
+            )
+          : new SelectStatement({ where: query });
+}

package/src/ReadonlyRepositoryBuilder.ts

@@ -0,0 +1,53 @@
+import type { IConnection } from "./IConnection.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+import { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.ts";
+import type { BuiltRepository } from "./BuiltRepository.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
+import { IdentityMapper } from "./mappers/IdentityMapper.ts";
+
+export class ReadonlyRepositoryBuilder<T = object> {
+  protected entityMapper: IMapper<string, string> = new IdentityMapper();
+  protected propertyMapper: IMapper<string, string> = new IdentityMapper();
+
+  parts = (connection: IConnection, options: ReadonlyRepositoryMappingOptions<T>): BuiltRepository<T> => {
+    const rowConverter = options.rowConverter;
+    const objectConverter = options.objectConverter ?? new MetaDataRowTypeConverter<T>();
+    const entityMapper = options.entityMapper ?? new IdentityMapper<string>();
+    const propertyMappings = options.propertyMappings ?? new IdentityMapper<string>();
+    this.entityMapper = entityMapper;
+    this.propertyMapper = propertyMappings;
+    const entity = entityMapper.map(options.entity ?? options.type?.name ?? "");
+    const names = options.readProperties ?? (options.type ? fieldNamesOf(options.type) : []);
+    if (objectConverter instanceof MetaDataRowTypeConverter && options.type) {
+      const instance = new options.type() as Record<string, string | number | boolean | bigint | null | object>;
+      objectConverter.references.clear();
+      objectConverter.referenceColumns = propertyMappings;
+      for (const name of names) {
+        const value = instance[name];
+        if (value !== null && typeof value === "object" && !Array.isArray(value))
+          objectConverter.references.add(name);
+      }
+    }
+    const columns = [...names]
+      .map((name) => propertyMappings.map(name))
+      .sort((left, right) => left.localeCompare(right));
+    return {
+      connection,
+      rowConverter,
+      objectConverter,
+      propertyMappings,
+      entityMapper,
+      statements: this.statements(entity, columns),
+      ids: this.ids(options),
+      type: options.type ?? (Object as never as Constructable<T>),
+    };
+  };
+
+  protected ids = (_options: ReadonlyRepositoryMappingOptions<T>): string[] => [];
+
+  protected statements = (table: string, columns: string[]): ReadonlyRepositoryStatements =>
+    new ReadonlyRepositoryStatements(table, columns);
+}

package/src/ReadonlyRepositoryMappingOptions.ts

@@ -0,0 +1,15 @@
+import type { Cell, Cells } from "./converters/Cell.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import type { TypeConverter } from "./converters/TypeConverter.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+
+export type ReadonlyRepositoryMappingOptions<T = Cells> = {
+  entity?: string;
+  entityMapper?: IMapper<string, string>;
+  propertyMappings?: IMapper<string, string>;
+  rowConverter?: TypeConverter<Cells, Cells>;
+  objectConverter?: TypeConverter<T, Cells>;
+  type?: Constructable<T>;
+  rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>;
+  readProperties?: string[];
+};

package/src/ReadonlyRepositoryStatements.ts

@@ -0,0 +1,13 @@
+import type { ISelectStatement } from "./statements/ISelectStatement.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import { SelectStatement } from "./statements/SelectStatement.ts";
+
+export class ReadonlyRepositoryStatements {
+  constructor(
+    protected readonly table: string,
+    readonly readColumns: readonly string[],
+  ) {}
+
+  select = (where?: IWhere): ISelectStatement =>
+    new SelectStatement({ table: this.table, fields: [...this.readColumns], where });
+}

package/src/RepositoryAccess.ts

@@ -0,0 +1,14 @@
+import type { IConnection } from "./IConnection.ts";
+import type { ICRUDRepository } from "./ICRUDRepository.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+
+export class RepositoryAccess {
+  constructor(
+    private readonly createRepo: (connection: IConnection) => ICRUDRepository,
+    private readonly createReadonlyRepo: (connection: IConnection) => IReadonlyRepository,
+    private readonly connection: IConnection,
+  ) {}
+
+  create = (): ICRUDRepository => this.createRepo(this.connection);
+  createReadonly = (): IReadonlyRepository => this.createReadonlyRepo(this.connection);
+}

package/src/RepositoryFactory.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+import { MockConnection } from "./mocks/mock-connection.ts";
+import { MockRepository } from "./mocks/mock-repository.ts";
+import { RepositoryFactory } from "./RepositoryFactory.ts";
+import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.ts";
+
+class Item {}
+
+const emptyReadonly = (): IReadonlyRepository<Item> => ({
+  type: Item,
+  readSingle: async () => undefined,
+  async *read() {},
+});
+
+describe("RepositoryFactory", () => {
+  it("registers and creates", () => {
+    const factory = new RepositoryFactory();
+    const repo = new MockRepository<Item>(new MockConnection(), Item);
+    factory.register(repo);
+    const created = factory.create(Item);
+
+    expect(created).toBe(repo);
+    expect(factory.asReadonly.create(Item)).toBe(repo);
+  });
+
+  it("readonly registration is not crud", () => {
+    const factory = new RepositoryFactory();
+    const repo = emptyReadonly();
+    factory.asReadonly.register(repo);
+
+    expect(factory.asReadonly.create(Item)).toBe(repo);
+    expect(() => factory.create(Item)).toThrow(RepositoryNotRegisteredError);
+    try {
+      factory.create(Item);
+    } catch (error) {
+      expect(error).toBeInstanceOf(RepositoryNotRegisteredError);
+      expect((error as RepositoryNotRegisteredError).entityTypeName).toBe("Item");
+      expect((error as Error).message).toContain("Item");
+    }
+  });
+
+  it("registers and creates by name", () => {
+    const factory = new RepositoryFactory();
+    const connection = new MockConnection();
+    const crud = new MockRepository<Item>(connection, Item);
+    const read = emptyReadonly();
+    factory.register("Contact", "contacts", () => crud, () => read);
+
+    expect(factory.create("Contact", connection)).toBe(crud);
+    expect(factory.createReadonly("contacts", connection)).toBe(read);
+    expect(factory.access("contacts", connection).create()).toBe(crud);
+    expect(factory.access("Contact", connection).createReadonly()).toBe(read);
+  });
+
+  it("binds register on construct", () => {
+    RepositoryFactory.resetBinders();
+    const connection = new MockConnection();
+    const crud = new MockRepository<Item>(connection, Item);
+    const read = emptyReadonly();
+    RepositoryFactory.bind((factory) =>
+      factory.register("Contact", "contacts", () => crud, () => read),
+    );
+    try {
+      const factory = new RepositoryFactory();
+      expect(factory.create("contacts", connection)).toBe(crud);
+    } finally {
+      RepositoryFactory.resetBinders();
+    }
+  });
+
+  it("binds register on access", () => {
+    RepositoryFactory.resetBinders();
+    const connection = new MockConnection();
+    const crud = new MockRepository<Item>(connection, Item);
+    const read = emptyReadonly();
+    RepositoryFactory.bind((factory) =>
+      factory.register("Contact", "contacts", () => crud, () => read),
+    );
+    try {
+      const factory = new RepositoryFactory();
+      expect(factory.access("contacts", connection).create()).toBe(crud);
+    } finally {
+      RepositoryFactory.resetBinders();
+    }
+  });
+
+  it("throws when missing", () => {
+    const factory = new RepositoryFactory();
+    expect(() => factory.create(Item)).toThrow(RepositoryNotRegisteredError);
+    expect(() => factory.create("Contacts", new MockConnection())).toThrow(RepositoryNotRegisteredError);
+    expect(() => factory.createReadonly("Contacts", new MockConnection())).toThrow(RepositoryNotRegisteredError);
+  });
+});

package/src/RepositoryFactory.ts

@@ -0,0 +1,115 @@
+import type { Constructable } from "./converters/Constructable.ts";
+import type { IConnection } from "./IConnection.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+import type { IRepository } from "./IRepository.ts";
+import type { IRepositoryFactory } from "./IRepositoryFactory.ts";
+import type { ICRUDRepository } from "./ICRUDRepository.ts";
+import type { ICRUDRepositoryFactory } from "./ICRUDRepositoryFactory.ts";
+import { RepositoryAccess } from "./RepositoryAccess.ts";
+import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.ts";
+
+type Named = {
+  create: (connection: IConnection) => ICRUDRepository;
+  createReadonly: (connection: IConnection) => IReadonlyRepository;
+};
+
+const binders: Array<(factory: RepositoryFactory) => void> = [];
+
+export class RepositoryFactory implements ICRUDRepositoryFactory {
+  readonly #readonlyByType = new Map<Constructable<unknown>, IRepository>();
+  readonly #crudByType = new Map<Constructable<unknown>, IRepository>();
+  readonly #byName = new Map<string, Named>();
+
+  constructor() {
+    this.applyBound();
+  }
+
+  static bind = (register: (factory: RepositoryFactory) => void): void => {
+    binders.push(register);
+  };
+
+  static resetBinders = (): void => {
+    binders.length = 0;
+  };
+
+  private applyBound(): void {
+    for (const register of binders) register(this);
+  }
+
+  register(repository: IRepository): void;
+  register(
+    typeName: string,
+    pluralName: string,
+    create: (connection: IConnection) => ICRUDRepository,
+    createReadonly: (connection: IConnection) => IReadonlyRepository,
+  ): void;
+  register(
+    repositoryOrType: IRepository | string,
+    pluralName?: string,
+    create?: (connection: IConnection) => ICRUDRepository,
+    createReadonly?: (connection: IConnection) => IReadonlyRepository,
+  ): void {
+    if (typeof repositoryOrType !== "string") {
+      this.#put(repositoryOrType, true);
+      return;
+    }
+    const named = { create: create as Named["create"], createReadonly: createReadonly as Named["createReadonly"] };
+    this.#byName.set(repositoryOrType, named);
+    this.#byName.set(pluralName as string, named);
+  }
+
+  create<T>(type: Constructable<T>): ICRUDRepository<T>;
+  create(name: string, connection: IConnection): ICRUDRepository;
+  create(
+    typeOrName: Constructable<unknown> | string,
+    connection?: IConnection,
+  ): ICRUDRepository {
+    if (typeof typeOrName !== "string")
+      return this.#get(this.#crudByType, typeOrName) as ICRUDRepository;
+    this.applyBound();
+    return this.#lookup(typeOrName).create(connection as IConnection);
+  }
+
+  createReadonly = (name: string, connection: IConnection): IReadonlyRepository => {
+    this.applyBound();
+    return this.#lookup(name).createReadonly(connection);
+  };
+
+  access = (name: string, connection: IConnection): RepositoryAccess => {
+    this.applyBound();
+    const named = this.#lookup(name);
+    return new RepositoryAccess(named.create, named.createReadonly, connection);
+  };
+
+  has = (name: string): boolean => {
+    this.applyBound();
+    return this.#byName.has(name);
+  };
+
+  readonly asReadonly: IRepositoryFactory = {
+    register: (repository) => this.#put(repository, false),
+    create: <T>(type: Constructable<T>) =>
+      this.#get(this.#readonlyByType, type) as IReadonlyRepository<T>,
+  };
+
+  #put = (repository: IRepository, crud: boolean): void => {
+    this.#readonlyByType.set(repository.type, repository);
+    if (!crud) return;
+    this.#crudByType.set(repository.type, repository);
+  };
+
+  #get = (
+    map: Map<Constructable<unknown>, IRepository>,
+    type: Constructable<unknown>,
+  ): IRepository => {
+    const repository = map.get(type);
+    if (!repository) throw new RepositoryNotRegisteredError(type.name);
+    return repository;
+  };
+
+  #lookup = (name: string): Named => {
+    const named = this.#byName.get(name);
+    if (!named) throw new RepositoryNotRegisteredError(name);
+    return named;
+  };
+}

package/src/RepositoryNotRegisteredError.ts

@@ -0,0 +1,9 @@
+export class RepositoryNotRegisteredError extends Error {
+  readonly entityTypeName: string;
+
+  constructor(entityTypeName: string) {
+    super(`Repository "${entityTypeName}" is not registered`);
+    this.name = "RepositoryNotRegisteredError";
+    this.entityTypeName = entityTypeName;
+  }
+}

package/src/RepositoryTree.ts

@@ -0,0 +1,6 @@
+import type { IRepositoryTree } from "./IRepositoryTree.ts";
+import type { IRepositoryTreeNode } from "./IRepositoryTreeNode.ts";
+
+export class RepositoryTree implements IRepositoryTree {
+  constructor(readonly parent: IRepositoryTreeNode) {}
+}

package/src/RepositoryTreeNode.ts

@@ -0,0 +1,11 @@
+import type { Enrichment } from "./Enrichment.ts";
+import type { IRepositoryTreeNode } from "./IRepositoryTreeNode.ts";
+
+export class RepositoryTreeNode implements IRepositoryTreeNode {
+  constructor(
+    readonly value: object,
+    readonly propertyName: string,
+    readonly parent?: IRepositoryTreeNode,
+    readonly enrichment?: Enrichment,
+  ) {}
+}

package/src/Response.ts

@@ -0,0 +1,15 @@
+import { ParameterDirection } from "./ParameterDirection.ts";
+import type { Parameter } from "./Parameter.ts";
+
+export class Response {
+  readonly result: unknown;
+  readonly rowsAffected: number;
+  readonly parameters?: Parameter[];
+
+  constructor(result: unknown, rowsAffected: number, parameters?: Parameter[]) {
+    const returned = parameters?.find((parameter) => parameter.direction === ParameterDirection.ReturnValue)?.value;
+    this.result = result == null && returned != null ? returned : result;
+    this.rowsAffected = rowsAffected;
+    if (parameters !== undefined) this.parameters = parameters;
+  }
+}

package/src/Row.ts

@@ -0,0 +1,3 @@
+import type { Cell } from "./converters/Cell.ts";
+
+export type Row = Record<string, Cell>;

package/src/SingleCommandIBulkWriteStrategy.ts

@@ -0,0 +1,35 @@
+import type { CRUDRepository } from "./CRUDRepository.ts";
+import type { Response } from "./Response.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
+
+const fold = async <T>(
+  items: T[],
+  write: (item: T) => Promise<Response>,
+): Promise<Response> => {
+  let result: Response["result"] = null;
+  let rowsAffected = 0;
+  for (const item of items) {
+    const response = await write(item);
+    result = response.result;
+    rowsAffected += response.rowsAffected;
+  }
+  return { result, rowsAffected };
+};
+
+export class SingleCommandIBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
+  repo!: CRUDRepository<T>;
+
+  attach = (): void => {};
+
+  create = async (items: T[]): Promise<Response> => {
+    for (const item of items) await this.repo.create(item);
+    return { result: null, rowsAffected: items.length };
+  };
+
+  update = (items: T[], byWhere: IWhere | undefined): Promise<Response> =>
+    fold(items, (item) => this.repo.update(item, byWhere));
+
+  delete = (items: T[], byWhere: IWhere | undefined): Promise<Response> =>
+    fold(items, (item) => this.repo.delete(item, byWhere));
+}