@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/DriverLoader.ts

@@ -1,97 +0,0 @@
-import { readFileSync } from "node:fs";
-import { createRequire, registerHooks } from "node:module";
-import { tmpdir } from "node:os";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import type { IDriver } from "./IDriver.ts";
-import type { ProviderCatalog } from "./ProviderCatalog.ts";
-import { ProviderNotInstalledError } from "./ProviderNotInstalledError.ts";
-
-type DriverCtor = new () => IDriver;
-type DriverModule = Record<string, DriverCtor>;
-type TypeScript = {
-  transpileModule: (
-    source: string,
-    options: {
-      compilerOptions: { module: number; target: number };
-      fileName: string;
-    },
-  ) => { outputText: string };
-  ModuleKind: { ESNext: number };
-  ScriptTarget: { ES2022: number };
-};
-
-const require = createRequire(import.meta.url);
-const virtual = new Map<string, string>();
-const virtualBySource = new Map<string, string>();
-let typeScriptHook = false;
-let compiling = false;
-let nextVirtual = 0;
-
-const installTypeScriptHook = (): void => {
-  if (typeScriptHook) return;
-  const typescript = require("typescript") as TypeScript;
-  /* v8 ignore start */
-  registerHooks({
-    resolve: (specifier, context, nextResolve) => {
-      const parentURL = context.parentURL ? virtual.get(context.parentURL) ?? context.parentURL : undefined;
-      const resolved = nextResolve(specifier, parentURL ? { ...context, parentURL } : context);
-      /* v8 ignore next */
-      if (!compiling || !resolved.url.endsWith(".ts")) return resolved;
-      const existing = virtualBySource.get(resolved.url);
-      /* v8 ignore next */
-      if (existing) return { url: existing, shortCircuit: true };
-      const url = pathToFileURL(`${tmpdir()}/datasources-plugin-${nextVirtual++}.mjs`).href;
-      virtual.set(url, resolved.url);
-      virtualBySource.set(resolved.url, url);
-      return { url, shortCircuit: true };
-    },
-    load: (url, context, nextLoad) => {
-      const original = virtual.get(url) ?? (compiling && url.endsWith(".ts") ? url : undefined);
-      /* v8 ignore next */
-      if (!original) return nextLoad(url, context);
-      const filename = fileURLToPath(original);
-      const source = typescript.transpileModule(readFileSync(filename, "utf8"), {
-        compilerOptions: {
-          module: typescript.ModuleKind.ESNext,
-          target: typescript.ScriptTarget.ES2022,
-        },
-        fileName: filename,
-      }).outputText;
-      return { format: "module", source, shortCircuit: true };
-    },
-  });
-  /* v8 ignore stop */
-  typeScriptHook = true;
-};
-
-const instantiate = (catalog: ProviderCatalog): IDriver => {
-  compiling = true;
-  try {
-    return instantiateLoaded(catalog);
-  } finally {
-    compiling = false;
-  }
-};
-
-const instantiateLoaded = (catalog: ProviderCatalog): IDriver => {
-  const loaded = require(catalog.location) as DriverModule;
-  const Type = loaded[catalog.module];
-  if (typeof Type !== "function") throw new ProviderNotInstalledError(catalog.name);
-  return new Type();
-};
-
-export class DriverLoader {
-  static load = (catalog: ProviderCatalog): IDriver => {
-    try {
-      return instantiate(catalog);
-    } catch (error) {
-      if (error instanceof ProviderNotInstalledError) throw error;
-      try {
-        installTypeScriptHook();
-        return instantiate(catalog);
-      } catch {
-        throw new ProviderNotInstalledError(catalog.name);
-      }
-    }
-  };
-}

package/src/Enrichment.ts

@@ -1,15 +0,0 @@
-import type { EnrichmentPropertyType } from "./EnrichmentPropertyType.ts";
-
-export type Association = {
-  parent: string;
-  related: string;
-};
-
-export type Enrichment = {
-  destinationProperty: string;
-  sourceProperty: string;
-  relatedKey: string;
-  relatedProperty?: string;
-  type?: EnrichmentPropertyType;
-  association?: Association;
-};

package/src/EnrichmentPropertyType.ts

@@ -1,9 +0,0 @@
-export const EnrichmentPropertyType = {
-  Object: "object",
-  List: "list",
-  Dictionary: "dictionary",
-  Custom: "custom",
-} as const;
-
-export type EnrichmentPropertyType =
-  (typeof EnrichmentPropertyType)[keyof typeof EnrichmentPropertyType];

package/src/ExpectConsoleMiddleware.ts

@@ -1,47 +0,0 @@
-import { ConsoleCommandMiddleware } from "./ConsoleCommandMiddleware.ts";
-import type { ICommandMiddleware } from "./ICommandMiddleware.ts";
-import type { Parameter } from "./Parameter.ts";
-import type { Row } from "./Row.ts";
-
-export const consoleSignature = (line: string): string => {
-  const duration = line.lastIndexOf("] ");
-  return duration >= 0 && (line.endsWith("ms") || line.endsWith("μs"))
-    ? line.slice(0, duration + 1)
-    : line;
-};
-
-export class ExpectConsoleMiddleware implements ICommandMiddleware {
-  private readonly inner: ConsoleCommandMiddleware;
-  private index = 0;
-
-  constructor(
-    private readonly expected: readonly string[],
-    now: () => Date,
-    private readonly normalize: (line: string) => string = consoleSignature,
-  ) {
-    this.inner = new ConsoleCommandMiddleware((line) => this.check(line), now, { isVerbose: "true" });
-  }
-
-  beforeCommand = (text: string, params?: ReadonlyArray<Parameter>) =>
-    this.inner.beforeCommand(text, params);
-
-  afterCommand = (
-    text: string,
-    params: ReadonlyArray<Parameter> | undefined,
-    results: ReadonlyArray<Row>,
-    elapsedMs: number,
-    error?: Error,
-  ) => this.inner.afterCommand(text, params, results, elapsedMs, error);
-
-  complete = (): void => {
-    if (this.index !== this.expected.length)
-      throw new Error(`console mismatch at ${this.index}\nexpected: ${this.expected[this.index]}\nactual:   <missing>`);
-  };
-
-  private check = (line: string): void => {
-    const actual = this.normalize(line);
-    if (this.index >= this.expected.length || actual !== this.expected[this.index])
-      throw new Error(`console mismatch at ${this.index}\nexpected: ${this.index < this.expected.length ? this.expected[this.index] : "<missing>"}\nactual:   ${actual}`);
-    this.index++;
-  };
-}

package/src/FirstResultReader.ts

@@ -1,49 +0,0 @@
-import type { Cells } from "./converters/Cell.ts";
-import type { IReader } from "./IReader.ts";
-import { readerToAsyncIterable } from "./readerToAsyncIterable.ts";
-
-export class FirstResultReader implements IReader<Cells> {
-  current: Cells | undefined = undefined;
-  private index = -1;
-  private firstSet = true;
-
-  private constructor(
-    private readonly first: readonly Cells[],
-    private readonly live: IReader<Cells>,
-  ) {}
-
-  static async capture(live: IReader<Cells>): Promise<{ value: IReader<Cells>; rows: Cells[] }> {
-    const rows: Cells[] = [];
-    while (await live.next()) if (live.current != null) rows.push(live.current);
-    return { value: new FirstResultReader(rows, live), rows };
-  }
-
-  async next(): Promise<boolean> {
-    if (!this.firstSet) {
-      const moved = await this.live.next();
-      this.current = this.live.current;
-      return moved;
-    }
-    this.index += 1;
-    if (this.index < this.first.length) {
-      this.current = this.first[this.index];
-      return true;
-    }
-    this.current = undefined;
-    return false;
-  }
-
-  async nextResult(): Promise<boolean> {
-    this.firstSet = false;
-    this.current = undefined;
-    return this.live.nextResult();
-  }
-
-  read(): AsyncIterable<Cells> {
-    return readerToAsyncIterable(this);
-  }
-
-  dispose = (): Promise<void> => this.live.dispose();
-
-  [Symbol.asyncDispose] = (): Promise<void> => this.dispose();
-}

package/src/HashsetOptimizedReadonlyEnrichmentStrategy.ts

@@ -1,80 +0,0 @@
-import type { Scalar } from "./builders/Scalar.ts";
-import { Operator, Where } from "./statements/index.ts";
-import type { Enrichment } from "./Enrichment.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-import type { Row } from "./Row.ts";
-import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
-
-const hasKey = (value: Scalar | object | undefined): value is Scalar =>
-  value !== undefined && value !== null;
-
-export class HashsetOptimizedReadonlyEnrichmentStrategy<T extends object>
-  extends DefaultReadonlyEnrichmentStrategy<T>
-{
-  protected override async applyObject<TRelated extends object>(
-    via: IReadonlyRepository<TRelated>,
-    enrichment: Enrichment,
-    parents: T[],
-    sources?: (Row | undefined)[],
-  ): Promise<void> {
-    const keys = this.keysOf(parents, sources, enrichment.sourceProperty);
-    if (keys.size === 0) return;
-    const index = new Map<string, TRelated>();
-    for await (const item of via.read(
-      new Where(new Operator.In(enrichment.relatedKey, [...keys.values()])),
-    )) {
-      const by = this.props(item)[enrichment.relatedKey];
-      if (hasKey(by)) index.set(this.keyOf(by), item);
-    }
-    for (const [indexOfParent, parent] of parents.entries()) {
-      const key = this.sourceKey(parent, enrichment.sourceProperty, sources, indexOfParent);
-      if (key === undefined || key === null) continue;
-      const related = index.get(this.keyOf(key));
-      if (!related) continue;
-      Object.assign(parent, {
-        [enrichment.destinationProperty]: enrichment.relatedProperty ? this.props(related)[enrichment.relatedProperty] : related,
-      });
-    }
-  }
-
-  protected override async applyList<TRelated extends object>(
-    via: IReadonlyRepository<TRelated>,
-    enrichment: Enrichment,
-    parents: T[],
-    sources?: (Row | undefined)[],
-  ): Promise<void> {
-    const keys = this.keysOf(parents, sources, enrichment.sourceProperty);
-    if (keys.size === 0) return;
-    const index = new Map<string, TRelated[]>();
-    for await (const item of via.read(
-      new Where(new Operator.In(enrichment.relatedKey, [...keys.values()])),
-    )) {
-      const by = this.props(item)[enrichment.relatedKey];
-      if (hasKey(by)) {
-        const cacheKey = this.keyOf(by);
-        const list = index.get(cacheKey) ?? [];
-        list.push(item);
-        index.set(cacheKey, list);
-      }
-    }
-    for (const [indexOfParent, parent] of parents.entries()) {
-      const key = this.sourceKey(parent, enrichment.sourceProperty, sources, indexOfParent);
-      if (key === undefined || key === null) continue;
-      Object.assign(parent, { [enrichment.destinationProperty]: index.get(this.keyOf(key)) ?? [] });
-    }
-  }
-
-  private keysOf(
-    parents: T[],
-    sources: (Row | undefined)[] | undefined,
-    from: string,
-  ): Map<string, Scalar> {
-    const keys = new Map<string, Scalar>();
-    for (const [index, parent] of parents.entries()) {
-      const key = this.sourceKey(parent, from, sources, index);
-      if (key === undefined || key === null) continue;
-      keys.set(this.keyOf(key), this.scalar(key));
-    }
-    return keys;
-  }
-}

package/src/IBulkWriteStrategy.ts

@@ -1,13 +0,0 @@
-import type { CRUDRepository } from "./CRUDRepository.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-import type { ICommand } from "./ICommand.ts";
-import type { Response } from "./Response.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-
-export interface IBulkWriteStrategy<T extends object> {
-  repo: CRUDRepository<T>;
-  attach(command: ICommand, options: CRUDRepositoryOptions<T>): void;
-  create(items: T[]): Promise<Response>;
-  update(items: T[], byWhere: IWhere | undefined): Promise<Response>;
-  delete(items: T[], byWhere: IWhere | undefined): Promise<Response>;
-}

package/src/ICRUDRepository.ts

@@ -1,13 +0,0 @@
-import type { Scalar } from "./builders/Scalar.ts";
-import type { Cells } from "./converters/Cell.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import type { Response } from "./Response.ts";
-
-export interface ICRUDRepository<T = unknown> extends IReadonlyRepository<T> {
-  readonly ids: readonly string[];
-  create(item: T): Promise<T>;
-  update(item: T, byWhere?: IWhere): Promise<Response>;
-  delete(item: T, byWhere?: IWhere): Promise<Response>;
-  readSingleById(id: Scalar | Cells): Promise<T | undefined>;
-}

package/src/ICRUDRepositoryFactory.ts

@@ -1,8 +0,0 @@
-import type { Constructable } from "./converters/Constructable.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { IRepository } from "./IRepository.ts";
-
-export interface ICRUDRepositoryFactory {
-  register(repository: IRepository): void;
-  create<T>(type: Constructable<T>): ICRUDRepository<T>;
-}

package/src/ICommand.ts

@@ -1,45 +0,0 @@
-import type { IStatement } from "./statements/IStatement.ts";
-import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.ts";
-import { Native } from "./statements/Native.ts";
-import type { ICommandMiddleware } from "./ICommandMiddleware.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";
-
-export interface ICommand {
-  readonly connection: IConnection;
-  addMiddleware(middleware: ICommandMiddleware): this;
-  executeReader(text: string, parameters?: Parameter[]): Promise<IReader<Cells>>;
-  execute(text: string, parameters?: Parameter[]): Promise<Response>;
-  executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
-  executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
-  executeStatement?(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
-  executeReaderStatement?(
-    statement: IStatement,
-    parameters?: Parameter[],
-  ): Promise<IReader<Cells>>;
-}
-
-export const execute = (
-  command: ICommand,
-  statement: IStatement,
-  parameters?: Parameter[],
-): Promise<Response> =>
-  command.executeStatement?.(statement, parameters) ??
-  command.executeNative(
-    new Native(DefaultStatementTextRenderer.instance.render(statement)),
-    parameters,
-  );
-
-export const executeReader = (
-  command: ICommand,
-  statement: IStatement,
-  parameters?: Parameter[],
-): Promise<IReader<Cells>> =>
-  command.executeReaderStatement?.(statement, parameters) ??
-  command.executeReaderNative(
-    new Native(DefaultStatementTextRenderer.instance.render(statement)),
-    parameters,
-  );

package/src/ICommandMiddleware.ts

@@ -1,20 +0,0 @@
-import type { Parameter } from "./Parameter.ts";
-import type { Row } from "./Row.ts";
-
-export interface ICommandMiddleware {
-  beforeCommand(
-    text: string,
-    params?: ReadonlyArray<Parameter>,
-  ):
-    | void
-    | { text: string; params?: ReadonlyArray<Parameter> }
-    | Promise<void | { text: string; params?: ReadonlyArray<Parameter> }>;
-
-  afterCommand(
-    text: string,
-    params: ReadonlyArray<Parameter> | undefined,
-    results: ReadonlyArray<Row>,
-    elapsedMs: number,
-    error?: Error,
-  ): void | Promise<void>;
-}

package/src/IConnection.ts

@@ -1,13 +0,0 @@
-import type { ICommand } from "./ICommand.ts";
-import type { ITransaction } from "./ITransaction.ts";
-import type { IsolationLevel } from "./IsolationLevel.ts";
-
-export interface IConnection {
-  readonly provider: string;
-  readonly isOpen: boolean;
-  createCommand(): ICommand;
-  open(): Promise<void>;
-  close(): Promise<void>;
-  startTransaction(isolation?: IsolationLevel): Promise<ITransaction>;
-  [Symbol.asyncDispose](): Promise<void>;
-}

package/src/IDatasource.ts

@@ -1,27 +0,0 @@
-import type { Constructable } from "./converters/Constructable.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-import type { ICommand } from "./ICommand.ts";
-import type { IConnection } from "./IConnection.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
-import type { RepositoryFactory } from "./RepositoryFactory.ts";
-
-export interface IDatasource {
-  readonly provider: string;
-  readonly repositories: RepositoryFactory;
-  createConnection(): Promise<IConnection>;
-  createCommand(connection?: IConnection): Promise<ICommand>;
-  createRepository<T>(
-    type: Constructable<T>,
-    connection?: IConnection,
-    options?: CRUDRepositoryOptions<T>,
-  ): ICRUDRepository<T>;
-  createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
-  createReadonlyRepository<T>(
-    type: Constructable<T>,
-    connection?: IConnection,
-    options?: ReadonlyRepositoryMappingOptions<T>,
-  ): IReadonlyRepository<T>;
-  createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
-}

package/src/IDatasourceFactory.ts

@@ -1,6 +0,0 @@
-import type { DatasourceOptions } from "./DatasourceOptions.ts";
-import type { IDatasource } from "./IDatasource.ts";
-
-export interface IDatasourceFactory {
-  create(options?: DatasourceOptions): IDatasource;
-}

package/src/IDriver.ts

@@ -1,24 +0,0 @@
-import type { ICommand } from "./ICommand.ts";
-import type { IConnection } from "./IConnection.ts";
-import type { ITransaction } from "./ITransaction.ts";
-import type { IsolationLevel } from "./IsolationLevel.ts";
-import type { DatasourceOptions } from "./DatasourceOptions.ts";
-import type { Cell } from "./converters/Cell.ts";
-import type { TypeConverter } from "./converters/TypeConverter.ts";
-import type { Information } from "./Information.ts";
-import type { StatementTextRenderer } from "./statements/StatementTextRenderer.ts";
-
-export const columnType = (name: string): string => name;
-
-export interface IDriver {
-  connection(options?: DatasourceOptions): IConnection;
-  command(connection: IConnection): ICommand;
-  transaction(
-    connection: IConnection,
-    isolation?: IsolationLevel,
-  ): ITransaction;
-  rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
-  columnType(name: string): string;
-  statementRenderer?: StatementTextRenderer | null;
-  information?: Information | null;
-}

package/src/IEnriched.ts

@@ -1,11 +0,0 @@
-import type { Enrichment } from "./Enrichment.ts";
-import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-
-export interface IEnriched<T> {
-  addEnriched<TRelated extends object>(
-    enrichment: Enrichment,
-    via: IReadonlyRepository<TRelated>,
-    strategy?: IReadonlyEnrichmentStrategy<T & object>,
-  ): this;
-}

package/src/IReader.ts

@@ -1,8 +0,0 @@
-export interface IReader<T = unknown> {
-  readonly current: T | undefined;
-  next(): Promise<boolean>;
-  nextResult(): Promise<boolean>;
-  read(): AsyncIterable<T>;
-  dispose(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
-}

package/src/IReadonlyEnrichmentStrategy.ts

@@ -1,19 +0,0 @@
-import type { Enrichment } from "./Enrichment.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-import type { Row } from "./Row.ts";
-
-export interface IReadonlyEnrichmentStrategy<T extends object> {
-  apply<TRelated extends object>(
-    via: IReadonlyRepository<TRelated>,
-    enrichment: Enrichment,
-    parents: T[],
-    sources?: (Row | undefined)[],
-  ): Promise<void>;
-  applyLinked<TRelated extends object, TLink extends object>(
-    via: IReadonlyRepository<TRelated>,
-    link: IReadonlyRepository<TLink>,
-    enrichment: Enrichment,
-    parents: T[],
-    sources?: (Row | undefined)[],
-  ): Promise<void>;
-}

package/src/IReadonlyRepository.ts

@@ -1,21 +0,0 @@
-import type { Parameter } from "./Parameter.ts";
-import type { IExecuteStoredProcedureStatement } from "./statements/IExecuteStoredProcedureStatement.ts";
-import type { ISelectStatement } from "./statements/ISelectStatement.ts";
-import type { IRepository } from "./IRepository.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
-
-export type ReadQuery = ISelectStatement | IWhere | IExecuteStoredProcedureStatement;
-
-export interface IReadonlyRepository<T = unknown> extends IRepository<T> {
-  readSingle(
-    query?: ReadQuery,
-    parameters?: Parameter[],
-    options?: ReadonlyRepositoryMappingOptions<T>,
-  ): Promise<T | undefined>;
-  read(
-    query?: ReadQuery,
-    parameters?: Parameter[],
-    options?: ReadonlyRepositoryMappingOptions<T>,
-  ): AsyncIterable<T>;
-}

package/src/IRepository.ts

@@ -1,5 +0,0 @@
-import type { Constructable } from "./converters/Constructable.ts";
-
-export interface IRepository<T = unknown> {
-  readonly type: Constructable<T>;
-}

package/src/IRepositoryFactory.ts

@@ -1,8 +0,0 @@
-import type { Constructable } from "./converters/Constructable.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-import type { IRepository } from "./IRepository.ts";
-
-export interface IRepositoryFactory {
-  register(repository: IRepository): void;
-  create<T>(type: Constructable<T>): IReadonlyRepository<T>;
-}

package/src/IRepositoryTreeNode.ts

@@ -1,8 +0,0 @@
-import type { Enrichment } from "./Enrichment.ts";
-
-export interface IRepositoryTreeNode {
-  readonly value: object;
-  readonly propertyName: string;
-  readonly parent?: IRepositoryTreeNode;
-  readonly enrichment?: Enrichment;
-}

package/src/ITransaction.ts

@@ -1,9 +0,0 @@
-import type { IConnection } from "./IConnection.ts";
-import type { IsolationLevel } from "./IsolationLevel.ts";
-
-export interface ITransaction {
-  readonly connection: IConnection;
-  readonly isolation: IsolationLevel;
-  commit(): Promise<void>;
-  abort(): Promise<void>;
-}

package/src/IUnitOfWork.ts

@@ -1,5 +0,0 @@
-export interface IUnitOfWork {
-  begin(): Promise<void>;
-  commit(): Promise<void>;
-  abort(): Promise<void>;
-}

package/src/IWriteEnrichmentStrategy.ts

@@ -1,8 +0,0 @@
-import type { IRepositoryTree } from "./IRepositoryTree.ts";
-import type { WriteMode } from "./WriteMode.ts";
-
-export interface IWriteEnrichmentStrategy<T> {
-  readonly useTransaction: boolean;
-  persist(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
-  persistBulk?(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
-}

package/src/Information.ts

@@ -1,5 +0,0 @@
-export type Information = {
-  descriptions: readonly string[];
-  overrides: readonly string[];
-  changeLogs: readonly string[];
-};

package/src/IsolationLevel.ts

@@ -1,8 +0,0 @@
-export const IsolationLevel = {
-  ReadUncommitted: "readUncommitted",
-  ReadCommitted: "readCommitted",
-  RepeatableRead: "repeatableRead",
-  Serializable: "serializable",
-} as const;
-
-export type IsolationLevel = (typeof IsolationLevel)[keyof typeof IsolationLevel];

package/src/LazyWriteEnrichmentStrategy.ts

@@ -1,5 +0,0 @@
-import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
-
-export class LazyWriteEnrichmentStrategy<T> extends DefaultWriteEnrichmentStrategy<T> {
-  protected override skipUnloaded = true;
-}

package/src/NestedToObjectEnrichmentStrategy.ts

@@ -1,33 +0,0 @@
-import type { Cells } from "./converters/Cell.ts";
-import type { Enrichment } from "./Enrichment.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-import { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.ts";
-import type { TypeMap } from "./mappers/TypeMap.ts";
-import type { Row } from "./Row.ts";
-import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
-
-export class NestedToObjectEnrichmentStrategy<T extends object>
-  extends DefaultReadonlyEnrichmentStrategy<T>
-{
-  private readonly nested: FlatToNestedMapper<T>;
-
-  constructor(typeMap: TypeMap<T>) {
-    super();
-    this.nested = new FlatToNestedMapper(typeMap);
-  }
-
-  override apply<TRelated extends object>(
-    _via: IReadonlyRepository<TRelated>,
-    _enrichment: Enrichment,
-    parents: T[],
-    sources?: (Row | undefined)[],
-  ): Promise<void> {
-    parents.length = 0;
-    for (const item of this.nested.map(rows(sources))) parents.push(item);
-    return Promise.resolve();
-  }
-}
-
-function* rows(sources?: (Row | undefined)[]): Iterable<Cells> {
-  for (const source of sources ?? []) if (source) yield source;
-}