@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/converters/MetaDataRowTypeConverter.ts

@@ -1,80 +0,0 @@
-import type { Cell, Cells } from "./Cell.ts";
-import { TypeConverter } from "./TypeConverter.ts";
-import type { Constructable } from "./Constructable.ts";
-import type { IMapper } from "../mappers/IMapper.ts";
-import { IdentityMapper } from "../mappers/IdentityMapper.ts";
-
-const scalarId = (value: Cell | object | undefined): Cell | undefined => {
-  if (value === undefined || value === null || typeof value !== "object" || value instanceof Date || value instanceof Uint8Array)
-    return value === undefined ? undefined : (value as Cell);
-  const record = value as Record<string, Cell | undefined>;
-  return record.Id !== undefined ? record.Id : record.id;
-};
-
-export class MetaDataRowTypeConverter<T = Cells> extends TypeConverter<T, Cells> {
-  fields: Record<string, TypeConverter<Cell, Cell>>;
-  references = new Set<string>();
-  referenceColumns: IMapper<string, string> = new IdentityMapper<string>();
-  shouldCoerceId = false;
-
-  constructor(fields: Record<string, TypeConverter<Cell, Cell>> = {}) {
-    super();
-    this.fields = { ...fields };
-  }
-
-  convert = (row: Cells, type?: Constructable<T>): T => {
-    const blank = type ? new type() : {};
-    const cells = Object.fromEntries(
-      Object.entries(row).filter(([key, value]) => {
-        if (this.references.has(key)) return false;
-        const current = (blank as Cells)[key];
-        return !(typeof current === "string" && typeof value !== "string" && value !== null);
-      }),
-    );
-    const dest = Object.assign(blank, cells) as T;
-    const record = dest as Record<string, Cell | object>;
-    for (const [key, value] of Object.entries(row)) {
-      if (this.references.has(key)) {
-        const current = record[key];
-        const target = current !== null && typeof current === "object" && !Array.isArray(current)
-          ? current as Record<string, Cell>
-          : {};
-        const id = "Id" in target ? "Id" : "id";
-        target[id] = value;
-        record[key] = target;
-        continue;
-      }
-      const converter = this.fields[key];
-      if (converter) record[key] = converter.convert(value);
-    }
-    return dest;
-  };
-
-  reverseConvert = (row: T): Cells => {
-    const cells: Cells = {};
-    for (const [key, value] of Object.entries(row as Record<string, Cell | object>)) {
-      if (Array.isArray(value)) continue;
-      if (
-        value !== null &&
-        typeof value === "object" &&
-        !(value instanceof Date) &&
-        !(value instanceof Uint8Array) &&
-        !this.references.has(key)
-      )
-        continue;
-      if (this.references.has(key)) {
-        const id = scalarId(value);
-        if (id !== undefined && id !== null) cells[this.referenceColumns.map(key)] = this.converted(key, id);
-        continue;
-      }
-      const converter = this.fields[key];
-      cells[key] = converter ? converter.reverseConvert(value as Cell) : (value as Cell);
-    }
-    return cells;
-  };
-
-  private converted = (key: string, value: Cell): Cell => {
-    const converter = this.fields[key];
-    return converter ? converter.reverseConvert(value) : value;
-  };
-}

package/src/converters/PluralizerConverter.ts

@@ -1,67 +0,0 @@
-const uncountable = new Set(["sheep", "fish", "series", "species", "deer", "news"]);
-const irregular: Record<string, string> = {
-  person: "people",
-  child: "children",
-  man: "men",
-  woman: "women",
-  mouse: "mice",
-  goose: "geese",
-  tooth: "teeth",
-  foot: "feet",
-  ox: "oxen",
-};
-const irregularSingular = Object.fromEntries(
-  Object.entries(irregular).map(([singular, plural]) => [plural, singular]),
-);
-
-const vowel = (c: string) => "aeiou".includes(c);
-const consonant = (c: string) => /[a-z]/.test(c) && !vowel(c);
-const yies = (word: string) => word.length >= 4 && word.endsWith("ies") && consonant(word[word.length - 4]);
-const consonantY = (word: string) => word.length >= 2 && word.endsWith("y") && consonant(word[word.length - 2]);
-const sibilant = (word: string) =>
-  word.endsWith("ch") ||
-  word.endsWith("sh") ||
-  word.endsWith("x") ||
-  word.endsWith("z") ||
-  word.endsWith("ss") ||
-  (word.length >= 2 && word.endsWith("s") && !word.endsWith("es") && vowel(word[word.length - 2]));
-const sibilantEs = (word: string) => word.length > 2 && word.endsWith("es") && sibilant(word.slice(0, -2));
-
-const restore = (original: string, result: string) =>
-  original[0] === original[0].toUpperCase()
-    ? result[0].toUpperCase() + result.slice(1)
-    : result;
-
-const plural = (word: string) =>
-  uncountable.has(word) || word in irregularSingular
-    ? word
-    : irregular[word] ??
-      (yies(word) || sibilantEs(word)
-        ? word
-        : sibilant(word)
-          ? word + "es"
-          : consonantY(word)
-            ? word.slice(0, -1) + "ies"
-            : word.endsWith("s")
-              ? word
-              : word + "s");
-
-const singular = (word: string) =>
-  uncountable.has(word) || word in irregular
-    ? word
-    : (irregularSingular[word] ??
-      (yies(word)
-        ? word.slice(0, -3) + "y"
-        : sibilantEs(word)
-          ? word.slice(0, -2)
-          : word.endsWith("s") && !sibilant(word)
-            ? word.slice(0, -1)
-            : word));
-
-const apply = (word: string, transform: (word: string) => string) =>
-  word.length === 0 ? word : restore(word, transform(word.toLowerCase()));
-
-export class PluralizerConverter {
-  convert = (from: string) => apply(from, plural);
-  reverseConvert = (to: string) => apply(to, singular);
-}

package/src/converters/RegexConverter.ts

@@ -1,14 +0,0 @@
-export class RegexConverter {
-  readonly regex: RegExp;
-  readonly replacement: string;
-
-  constructor(pattern: string | RegExp, replacement: string) {
-    this.regex = typeof pattern === "string"
-      ? new RegExp(pattern, "g")
-      : new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
-    this.replacement = replacement;
-  }
-
-  convert = (from: string) => from.replace(this.regex, this.replacement);
-  reverseConvert = (to: string) => to;
-}

package/src/converters/ReplaceConverter.ts

@@ -1,6 +0,0 @@
-export class ReplaceConverter {
-  constructor(readonly search: string, readonly replacement: string) {}
-
-  convert = (from: string) => from.replaceAll(this.search, this.replacement);
-  reverseConvert = (to: string) => to.replaceAll(this.replacement, this.search);
-}

package/src/converters/RowTypeConverter.ts

@@ -1,33 +0,0 @@
-import type { Cell, Cells } from "./Cell.ts";
-import { TypeConverter } from "./TypeConverter.ts";
-
-export class RowTypeConverter extends TypeConverter<Cells, Cells> {
-  constructor(readonly fields: Record<string, TypeConverter<Cell, Cell>>) {
-    super();
-  }
-
-  static from(
-    converters: Record<string, TypeConverter<Cell, Cell>>,
-    columns: Record<string, string>,
-  ): RowTypeConverter {
-    const fields: Record<string, TypeConverter<Cell, Cell>> = {};
-    for (const [name, type] of Object.entries(columns)) {
-      const converter = converters[type];
-      if (converter) fields[name] = converter;
-    }
-    return new RowTypeConverter(fields);
-  }
-
-  convert = (from: Cells): Cells => this.apply(from, false);
-
-  reverseConvert = (to: Cells): Cells => this.apply(to, true);
-
-  private apply(row: Cells, reverse: boolean): Cells {
-    return Object.fromEntries(
-      Object.entries(row).map(([name, value]) => {
-        const converter = this.fields[name];
-        return [name, converter ? (reverse ? converter.reverseConvert(value) : converter.convert(value)) : value];
-      }),
-    );
-  }
-}

package/src/converters/ToLowerCaseConverter.ts

@@ -1,4 +0,0 @@
-export class ToLowerCaseConverter {
-  convert = (from: string) => from.toLowerCase();
-  reverseConvert = (to: string) => to;
-}

package/src/converters/ToUpperCaseConverter.ts

@@ -1,4 +0,0 @@
-export class ToUpperCaseConverter {
-  convert = (from: string) => from.toUpperCase();
-  reverseConvert = (to: string) => to;
-}

package/src/converters/TypeConverter.ts

@@ -1,6 +0,0 @@
-import type { Cells } from "./Cell.ts";
-
-export abstract class TypeConverter<To = Cells, From = Cells> {
-  abstract convert(from: From): To;
-  abstract reverseConvert(to: To): From;
-}

package/src/createCRUDRepositoryOptions.ts

@@ -1,21 +0,0 @@
-import type { Cell } from "./converters/Cell.ts";
-import type { Constructable } from "./converters/Constructable.ts";
-import type { TypeConverter } from "./converters/TypeConverter.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-import {
-  createReadonlyRepositoryMappingOptions,
-  fieldNamesOf,
-} from "./createReadonlyRepositoryMappingOptions.ts";
-
-export { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.ts";
-
-export const defaultId = (fields: string[]): string[] =>
-  fields.includes("id") ? ["id"] : fields.includes("Id") ? ["Id"] : [];
-
-export const createCRUDRepositoryOptions = <T>(
-  type: Constructable<T>,
-  rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>,
-): CRUDRepositoryOptions<T> => ({
-  ...createReadonlyRepositoryMappingOptions(type, rowTypeConverters),
-  ids: defaultId(fieldNamesOf(type)),
-});

package/src/createReadonlyRepositoryMappingOptions.ts

@@ -1,26 +0,0 @@
-import type { Cell } from "./converters/Cell.ts";
-import type { Constructable } from "./converters/Constructable.ts";
-import type { TypeConverter } from "./converters/TypeConverter.ts";
-import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
-
-type FieldSource = Record<string, string | number | boolean | bigint | null | object>;
-
-export const fieldNamesOf = <T>(type: Constructable<T>): string[] => {
-  const instance = new type() as FieldSource;
-  return Object.keys(instance).filter((key) => {
-    const value = instance[key];
-    if (Array.isArray(value)) return false;
-    if (value !== null && typeof value === "object" && !(value instanceof Date) && !(value instanceof Uint8Array))
-      return "id" in value || "Id" in value;
-    return true;
-  });
-};
-
-export const createReadonlyRepositoryMappingOptions = <T>(
-  type: Constructable<T>,
-  rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>,
-): ReadonlyRepositoryMappingOptions<T> => ({
-  type,
-  entity: type.name,
-  rowTypeConverters,
-});

package/src/dotEnv.ts

@@ -1,16 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import type { DatasourceOptions } from "./DatasourceOptions.ts";
-
-export const DotEnv = {
-  parse: (text: string): DatasourceOptions =>
-    Object.fromEntries(
-      text
-        .split(/\r?\n/)
-        .map((raw) => raw.trimStart().split("=", 2))
-        .filter((parts): parts is [string, string] =>
-          parts.length === 2 && !parts[0].startsWith("#") && parts[0].trim() !== "")
-        .map(([key, value]) => [key.trim(), value]),
-    ),
-  load: (path = ".env"): DatasourceOptions =>
-    existsSync(path) ? DotEnv.parse(readFileSync(path, "utf8")) : {},
-};

package/src/index.ts

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

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

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

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