@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/Parameter.ts

@@ -1,8 +0,0 @@
-import type { Scalar } from "./builders/Scalar.ts";
-import type { ParameterDirection } from "./ParameterDirection.ts";
-
-export interface Parameter<T = Scalar> {
-  name: string;
-  value?: T;
-  direction?: ParameterDirection;
-}

package/src/ParameterDirection.ts

@@ -1,9 +0,0 @@
-export const ParameterDirection = {
-  Input: "input",
-  Output: "output",
-  InputOutput: "inputOutput",
-  ReturnValue: "returnValue",
-} as const;
-
-export type ParameterDirection =
-  (typeof ParameterDirection)[keyof typeof ParameterDirection];

package/src/ProviderCatalog.ts

@@ -1,21 +0,0 @@
-export class ProviderCatalog {
-  constructor(
-    readonly name: string,
-    readonly location: string,
-    readonly module: string,
-  ) {}
-
-  static readonly default: Readonly<Record<string, ProviderCatalog>> = {
-    json: new ProviderCatalog("json", "@datasources/json", "JsonDriver"),
-    memory: new ProviderCatalog("memory", "@datasources/memory", "MemoryDriver"),
-    sqlite: new ProviderCatalog("sqlite", "@datasources/sqlite", "SqliteDriver"),
-    xml: new ProviderCatalog("xml", "@datasources/xml", "XmlDriver"),
-    yaml: new ProviderCatalog("yaml", "@datasources/yaml", "YamlDriver"),
-    mysql: new ProviderCatalog("mysql", "@datasources/mysql", "MysqlDriver"),
-    sqlserver: new ProviderCatalog("sqlserver", "@datasources/sqlserver", "SqlServerDriver"),
-    postgres: new ProviderCatalog("postgres", "@datasources/postgres", "PostgresDriver"),
-    oracle: new ProviderCatalog("oracle", "@datasources/oracle", "OracleDriver"),
-    mongodb: new ProviderCatalog("mongodb", "@datasources/mongodb", "MongoDbDriver"),
-    dynamodb: new ProviderCatalog("dynamodb", "@datasources/dynamodb", "DynamoDbDriver"),
-  };
-}

package/src/ProviderNotImplementedError.ts

@@ -1,9 +0,0 @@
-export class ProviderNotImplementedError extends Error {
-  readonly provider: string;
-
-  constructor(provider: string) {
-    super(`Provider "${provider}" is not implemented`);
-    this.name = "ProviderNotImplementedError";
-    this.provider = provider;
-  }
-}

package/src/ProviderNotInstalledError.ts

@@ -1,9 +0,0 @@
-export class ProviderNotInstalledError extends Error {
-  readonly provider: string;
-
-  constructor(provider: string) {
-    super(`Provider "${provider}" is not installed`);
-    this.name = "ProviderNotInstalledError";
-    this.provider = provider;
-  }
-}

package/src/ReadonlyRepository.ts

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

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

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

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

@@ -1,14 +0,0 @@
-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.ts

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

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

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

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

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

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

package/src/SingleCommandIBulkWriteStrategy.ts

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