@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/StatementMappers.ts

@@ -1,110 +0,0 @@
-import type { Cell } from "./converters/Cell.ts";
-import type { IMapper } from "./mappers/IMapper.ts";
-import { DeleteStatement } from "./statements/DeleteStatement.ts";
-import type { IStatement } from "./statements/IStatement.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import { InsertStatement } from "./statements/InsertStatement.ts";
-import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.ts";
-import { SelectStatement } from "./statements/SelectStatement.ts";
-import { UpdateStatement } from "./statements/UpdateStatement.ts";
-import { Where } from "./statements/Where.ts";
-
-export class StatementMappers implements IMapper<string, string> {
-  constructor(
-    private readonly entityMappers: IMapper<string, string>,
-    private readonly propertyMappers: IMapper<string, string>,
-  ) {}
-
-  map = (property: string): string => {
-    const dot = lastDot(property);
-    if (dot < 0) return this.propertyMappers.map(property);
-    const qualifier = property.slice(0, dot);
-    const name = property.slice(dot + 1);
-    const mapped = this.propertyMappers.map(name);
-    if (mapped !== name && mapped.includes(".")) return mapped;
-    const table = this.entityMappers.map(qualifier);
-    return table === qualifier && mapped === name ? property : `${table}.${mapped}`;
-  };
-
-  reverseMap = (key: string): string => {
-    const reversed = this.propertyMappers.reverseMap(key);
-    if (reversed !== key && this.propertyMappers.map(reversed) === key) return reversed;
-    const dot = lastDot(key);
-    if (dot < 0) return reversed;
-    const column = key.slice(dot + 1);
-    const name = this.propertyMappers.reverseMap(column);
-    return name !== column && this.propertyMappers.map(name) === column ? name : reversed;
-  };
-
-  column = (property: string): string => this.map(property);
-
-  property = (key: string): string => this.reverseMap(key);
-
-  apply = (
-    query: IStatement | undefined,
-    cell: (property: string, value: Cell) => Cell,
-  ): IStatement | undefined => {
-    if (query instanceof SelectStatement && query.table)
-      return new SelectStatement({
-        distinct: query.distinct,
-        table: this.entityMappers.map(query.table),
-        fields: query.fields.map(this.mapSelectField),
-        where: query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
-        joins: query.joins.map((join) => ({
-          kind: join.kind,
-          table: this.entityMappers.map(join.table),
-          on: join.on ? new Where(join.on).map(this.column, cell).condition : undefined,
-        })),
-        groupBy: query.groupBy.map(this.column),
-        having: query.having instanceof Where ? this.applyWhere(query.having, cell) : query.having,
-        orderBy: query.orderBy.map((order) => ({ column: this.column(order.column), direction: order.direction })),
-        limit: query.limit,
-        offset: query.offset,
-      });
-    if (query instanceof InsertStatement && query.table !== undefined)
-      return new InsertStatement(
-        this.entityMappers.map(query.table),
-        query.fields.map((field) => ({ name: this.column(field.name), value: field.value })),
-      );
-    if (query instanceof UpdateStatement && query.table !== undefined)
-      return new UpdateStatement(
-        this.entityMappers.map(query.table),
-        query.fields.map((field) => ({ name: this.column(field.name), value: field.value })),
-        query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
-      );
-    if (query instanceof DeleteStatement && query.table !== undefined)
-      return new DeleteStatement(
-        this.entityMappers.map(query.table),
-        query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
-      );
-    if (query instanceof SelectInsertedIdStatement)
-      return new SelectInsertedIdStatement(this.entityMappers.map(query.table), this.column(query.column));
-    return query;
-  };
-
-  applyWhere = (
-    where: IWhere | undefined,
-    cell: (property: string, value: Cell) => Cell,
-  ): IWhere | undefined =>
-    where instanceof Where ? where.map(this.column, cell) : where;
-
-  private mapSelectField = (field: string): string => {
-    const asIndex = field.toUpperCase().indexOf(" AS ");
-    if (asIndex >= 0) {
-      const expression = field.slice(0, asIndex).trim();
-      const alias = field.slice(asIndex + 4).trim();
-      return `${this.map(expression)} AS ${alias}`;
-    }
-    return this.map(field);
-  };
-}
-
-const lastDot = (name: string): number => {
-  let quoted = false;
-  let dot = -1;
-  for (let i = 0; i < name.length; i++) {
-    if (name[i] === '"') quoted = !quoted;
-    if (name[i] === "." && !quoted) dot = i;
-  }
-  return dot;
-};

package/src/StoredEnrichment.ts

@@ -1,25 +0,0 @@
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { Row } from "./Row.ts";
-
-export type ApplyEnrichment<T extends object = object> = (
-  parents: T[],
-  sources?: (Row | undefined)[],
-) => Promise<void>;
-
-export class StoredEnrichment<T extends object = object> {
-  apply: ApplyEnrichment<T>;
-  persist?: ICRUDRepository<object>;
-  link?: ICRUDRepository<object>;
-
-  constructor(
-    readonly enrichment: Enrichment,
-    apply: ApplyEnrichment<T>,
-    persist?: ICRUDRepository<object>,
-    link?: ICRUDRepository<object>,
-  ) {
-    this.apply = apply;
-    this.persist = persist;
-    this.link = link;
-  }
-}

package/src/StoredProcedureBulkWriteStrategy.ts

@@ -1,164 +0,0 @@
-import type { Cell, Cells } from "./converters/Cell.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-import type { Response } from "./Response.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
-import type { CRUDRepository } from "./CRUDRepository.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-import type { ICommand } from "./ICommand.ts";
-import { execute } from "./ICommand.ts";
-import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
-import { repositoryParts } from "./CRUDRepositoryBuilder.ts";
-import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
-import { afterBulkWrite } from "./BulkWriteEnrichment.ts";
-import { ParameterDirection } from "./ParameterDirection.ts";
-import type { Parameter } from "./Parameter.ts";
-
-const empty = (): Response => ({ result: null, rowsAffected: 0 });
-
-const json = (rows: Cells[]): string => `[${rows.map(object).join(",")}]`;
-
-const object = (row: Cells): string =>
-  `{${Object.entries(row)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, value]) => `${quote(key)}:${scalar(value)}`)
-    .join(",")}}`;
-
-const scalar = (value: Cell): string => {
-  if (value === null || value === undefined) return "null";
-  if (typeof value === "boolean") return value ? "true" : "false";
-  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : fail();
-  if (typeof value === "bigint") return value.toString();
-  if (typeof value === "string") return quote(value);
-  if (value instanceof Date) return quote(roundTrip(value));
-  if (value instanceof Uint8Array) return quote(base64(value));
-  return fail();
-};
-
-const fail = (): string => {
-  throw new DatasourceError("Unsupported bulk payload value");
-};
-
-const roundTrip = (date: Date): string =>
-  date.toISOString().replace(/\.(\d{3})Z$/, (_, fraction: string) => `.${fraction}0000Z`);
-
-const base64 = (bytes: Uint8Array): string =>
-  btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""));
-
-const quote = (text: string): string => {
-  let result = "\"";
-  for (const ch of text) {
-    result += ({
-      "\\": "\\\\",
-      "\"": "\\\"",
-      "\b": "\\b",
-      "\f": "\\f",
-      "\n": "\\n",
-      "\r": "\\r",
-      "\t": "\\t",
-    }[ch] ?? (ch < " " ? `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}` : ch));
-  }
-  return `${result}"`;
-};
-
-export class StoredProcedureBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
-  repo!: CRUDRepository<T>;
-  command!: ICommand;
-  options!: CRUDRepositoryOptions<T>;
-
-  attach = (command: ICommand, options: CRUDRepositoryOptions<T>): void => {
-    this.command = command;
-    this.options = options;
-  };
-
-  constructor(
-    private readonly createName: string,
-    private readonly updateName: string,
-    private readonly deleteName: string,
-  ) {}
-
-  create = (items: T[]): Promise<Response> => this.then(this.call(this.createName, items, true), items, "create");
-
-  update = (items: T[], _byWhere: IWhere | undefined): Promise<Response> =>
-    this.then(this.call(this.updateName, items), items, "update");
-
-  delete = (items: T[], _byWhere: IWhere | undefined): Promise<Response> =>
-    this.then(this.call(this.deleteName, items), items, "delete");
-
-  private then = async (write: Promise<Response>, items: T[], mode: "create" | "update" | "delete"): Promise<Response> => {
-    const response = await write;
-    await afterBulkWrite(this.repo, this.options, items, mode);
-    return response;
-  };
-
-  private call = async (name: string, items: T[], generated = false): Promise<Response> => {
-    if (items.length === 0) return empty();
-    const payload = { name: "payload", value: json(items.map((item) => this.rowOf(item, generated))) };
-      const parameters: Parameter[] = generated && this.ids().length === 1
-      ? [payload, { name: "ids", value: null, direction: ParameterDirection.InputOutput }]
-      : [payload];
-    const response = await execute(this.command, new ExecuteStoredProcedureStatement(name, parameters), parameters);
-    if (generated) this.applyIds(items, response.parameters);
-    return response;
-  };
-
-  private ids = (): readonly string[] => this.options.ids ?? this.repo.ids ?? ["id"];
-
-  private rowOf = (item: T, create = false): Cells => {
-    const stored = this.reverse(item);
-    const statements = repositoryParts(this.command.connection, this.options).statements;
-    const row: Cells = {};
-    for (const name of statements.readColumns) {
-      if (create && this.identity(name) && !assigned(stored[name] ?? stored[this.ids()[0]!])) continue;
-      const match = Object.entries(stored).find(([key]) => this.column(key) === name);
-      row[name] = match?.[1] ?? null;
-    }
-    return row;
-  };
-
-  private identity = (column: string): boolean => this.ids().length === 1 && this.ids()[0] === column;
-
-  private applyIds = (items: T[], parameters?: Parameter[]): void => {
-    if (this.ids().length !== 1) return;
-    const found = parameters?.find((parameter) => parameter.name === "ids");
-    const list = parseIds(found?.value);
-    const column = this.ids()[0]!;
-    for (let index = 0; index < items.length && index < list.length; index++)
-      stamp(items[index], column, list[index]!);
-  };
-
-  private column = (property: string): string => this.options.propertyMappings?.map(property) ?? property;
-
-  private reverse = (item: T): Cells => {
-    const objects = this.options.objectConverter ?? new MetaDataRowTypeConverter<T>();
-    const row = objects.reverseConvert(item);
-    return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
-  };
-}
-
-const assigned = (value: Cell | undefined): boolean => {
-  if (value === null || value === undefined) return false;
-  if (value === 0 || value === 0n) return false;
-  if (typeof value === "string") return value.length > 0;
-  return true;
-};
-
-const parseIds = (value: Cell | undefined): number[] => {
-  const text =
-    typeof value === "string" ? value.trim()
-    : typeof value === "number" || typeof value === "bigint" ? String(value)
-    : "";
-  if (text === "" || text === "[]" || text === "null") return [];
-  return text
-    .replace(/^\[/, "")
-    .replace(/\]$/, "")
-    .split(",")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => Number(part));
-};
-
-const stamp = <T extends object>(item: T, column: string, id: number): void => {
-  const key = column in item ? column : "id" in item ? "id" : "Id" in item ? "Id" : column;
-  (item as Record<string, Cell>)[key] = id;
-};

package/src/StreamingReader.ts

@@ -1,64 +0,0 @@
-import type { Cells } from "./converters/Cell.ts";
-import type { IReader } from "./IReader.ts";
-import { readerToAsyncIterable } from "./readerToAsyncIterable.ts";
-
-export class StreamingReader implements IReader<Cells> {
-  current: Cells | undefined = undefined;
-  private closed = false;
-
-  constructor(
-    private readonly pull: () => Promise<Cells | undefined>,
-    private readonly advance: () => Promise<boolean>,
-    private readonly close: () => Promise<void> = async () => {},
-  ) {}
-
-  async next(): Promise<boolean> {
-    this.current = await this.pull();
-    return this.current !== undefined;
-  }
-
-  read(): AsyncIterable<Cells> {
-    return readerToAsyncIterable(this);
-  }
-
-  async nextResult(): Promise<boolean> {
-    this.current = undefined;
-    return this.advance();
-  }
-
-  async dispose(): Promise<void> {
-    if (this.closed) return;
-    this.closed = true;
-    await this.close();
-  }
-
-  [Symbol.asyncDispose] = (): Promise<void> => this.dispose();
-}
-
-export const statementReader = (
-  statements: readonly string[],
-  load: (sql: string) => AsyncIterable<Cells>,
-): StreamingReader => {
-  let index = 0;
-  let rows: AsyncIterator<Cells> | undefined;
-  const closeRows = async () => {
-    await rows?.return?.();
-    rows = undefined;
-  };
-  return new StreamingReader(
-    async () => {
-      if (index >= statements.length) return undefined;
-      const sql = statements[index];
-      if (!sql) return undefined;
-      rows ??= load(sql)[Symbol.asyncIterator]();
-      const step = await rows.next();
-      return step.done ? undefined : step.value;
-    },
-    async () => {
-      await closeRows();
-      index += 1;
-      return index < statements.length;
-    },
-    closeRows,
-  );
-};

package/src/UnitOfWorkTransaction.ts

@@ -1,50 +0,0 @@
-import { DatasourceError } from "./DatasourceError.ts";
-import type { IConnection } from "./IConnection.ts";
-import type { ITransaction } from "./ITransaction.ts";
-import type { IUnitOfWork } from "./IUnitOfWork.ts";
-
-const open = new WeakSet<IConnection>();
-
-export class UnitOfWorkTransaction implements IUnitOfWork {
-  private begun = false;
-  private transaction: ITransaction | undefined;
-
-  constructor(private readonly connection: IConnection) {}
-
-  begin = async (): Promise<void> => {
-    if (this.begun) throw new DatasourceError("Unit of work already begun");
-    this.begun = true;
-    if (open.has(this.connection)) return;
-    open.add(this.connection);
-    try {
-      this.transaction = await this.connection.startTransaction();
-    } catch (error) {
-      open.delete(this.connection);
-      throw error;
-    }
-  };
-
-  commit = async (): Promise<void> => {
-    if (!this.begun) throw new DatasourceError("Unit of work has not begun");
-    const txn = this.transaction;
-    if (!txn) return;
-    await txn.commit();
-    this.release();
-  };
-
-  abort = async (): Promise<void> => {
-    if (!this.begun) throw new DatasourceError("Unit of work has not begun");
-    const txn = this.transaction;
-    if (!txn) return;
-    try {
-      await txn.abort();
-    } finally {
-      this.release();
-    }
-  };
-
-  private release(): void {
-    open.delete(this.connection);
-    this.transaction = undefined;
-  }
-}

package/src/UpdateEnrichmentStrategy.ts

@@ -1,97 +0,0 @@
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { Scalar } from "./builders/Scalar.ts";
-import { defaultId } from "./createCRUDRepositoryOptions.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-import { Operator, Where } from "./statements/index.ts";
-
-type Props = Record<string, Scalar | object>;
-
-export abstract class UpdateEnrichmentStrategy<T> {
-  abstract updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
-
-  abstract updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
-
-  protected getCell = <TItem>(item: TItem, name: string): Scalar | object | undefined =>
-    (item as never as Props)[name];
-
-  protected presentCell = (value: Scalar | object | undefined): value is Scalar =>
-    value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
-
-  protected payloadOf = <TChild extends object, TParent>(
-    parent: TParent,
-    into: string,
-    enrichment?: Enrichment,
-  ): TChild[] => mapPayload(this.getCell(parent, into), enrichment) as TChild[];
-
-  protected stampCell = <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined): void => {
-    if (key === undefined || key === null || typeof key === "object") return;
-    const current = this.getCell(related, by);
-    if (current !== null && typeof current === "object" && !Array.isArray(current)) {
-      const target = current as Props;
-      const id = "Id" in target ? "Id" : "id";
-      target[id] = key;
-      return;
-    }
-    Object.assign(related, { [by]: key });
-  };
-
-  protected hasKey = <TItem extends object>(item: TItem, keys: readonly string[]): boolean =>
-    keys.length > 0 && keys.every((name) => this.presentCell(this.getCell(item, name)));
-
-  protected keyOf = <TItem extends object>(item: TItem, keys: readonly string[]): string =>
-    keys.map((name) => String(this.getCell(item, name) ?? "")).join("\u001f");
-
-  protected namesOf = <TChild extends object>(writer: ICRUDRepository<TChild>, item: TChild): readonly string[] =>
-    writer.ids.length > 0 ? writer.ids : defaultId(Object.keys(item));
-
-  protected linkWhere = (
-    association: NonNullable<Enrichment["association"]>,
-    parentKey: Scalar,
-    relatedKey: Scalar,
-  ): Where =>
-    new Where(
-      new Operator.And(
-        new Operator.Equals(association.parent, parentKey),
-        new Operator.Equals(association.related, relatedKey),
-      ),
-    );
-
-  protected relatedIds = <TParent>(parent: TParent, enrichment: Enrichment): Scalar[] => {
-    const ids: Scalar[] = [];
-    const seen = new Set<string>();
-    for (const related of this.payloadOf<object, TParent>(parent, enrichment.destinationProperty)) {
-      const id = this.getCell(related, enrichment.relatedKey);
-      if (!this.presentCell(id)) throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.relatedKey}"`);
-      const key = String(id);
-      if (seen.has(key)) continue;
-      seen.add(key);
-      ids.push(id);
-    }
-    return ids;
-  };
-
-  protected requiredKey = <TParent>(parent: TParent, enrichment: Enrichment): Scalar => {
-    const key = this.getCell(parent, enrichment.sourceProperty);
-    if (!this.presentCell(key)) throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.sourceProperty}"`);
-    return key;
-  };
-}
-
-const mapPayload = (value: Scalar | object | undefined, enrichment?: Enrichment): object[] => {
-  if (value === undefined || value === null || typeof value === "string") return [];
-  if (Array.isArray(value)) return value.filter((item) => item !== null && typeof item === "object");
-  if (enrichment?.type !== "dictionary" || typeof value !== "object") return [];
-  const keyName = mapKeyName(enrichment.relatedKey);
-  const valueName = enrichment.relatedProperty ?? (keyName === "Key" ? "Value" : "value");
-  return Object.entries(value as Record<string, Scalar | object>)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, cell]) =>
-      cell !== null && typeof cell === "object" && !Array.isArray(cell)
-        ? { [keyName]: key, ...(cell as object) }
-        : { [keyName]: key, [valueName]: cell },
-    );
-};
-
-const mapKeyName = (relatedKey: string): string =>
-  relatedKey.includes("_") || relatedKey[0] !== relatedKey[0]?.toUpperCase() ? "key" : "Key";

package/src/builders/Field.ts

@@ -1,6 +0,0 @@
-import type { Scalar } from "./Scalar.ts";
-
-export interface Field {
-  name: string;
-  value: Scalar;
-}

package/src/builders/index.ts

@@ -1,2 +0,0 @@
-export type { Field } from "./Field.ts";
-export type { Scalar } from "./Scalar.ts";

package/src/collectAsync.ts

@@ -1,7 +0,0 @@
-export async function collectAsync<T>(items: AsyncIterable<T>): Promise<T[]> {
-  const collected: T[] = [];
-  for await (const item of items) {
-    collected.push(item);
-  }
-  return collected;
-}

package/src/converters/Cell.ts

@@ -1,10 +0,0 @@
-export type Cell =
-  | string
-  | number
-  | boolean
-  | bigint
-  | Date
-  | Uint8Array
-  | null;
-
-export type Cells = Record<string, Cell>;

package/src/converters/ChangeCasingConverter.ts

@@ -1,59 +0,0 @@
-export type Casing =
-  | "camelCase"
-  | "capitalCase"
-  | "constantCase"
-  | "dotCase"
-  | "kebabCase"
-  | "noCase"
-  | "pascalCase"
-  | "pascalSnakeCase"
-  | "pathCase"
-  | "sentenceCase"
-  | "snakeCase"
-  | "trainCase";
-
-const cap = (word: string) => word[0].toUpperCase() + word.slice(1);
-const sep = (c: string) => c === "_" || c === "." || c === "-" || c === "/" || /\s/.test(c);
-const upper = (c: string) => c !== c.toLowerCase();
-const lower = (c: string) => c !== c.toUpperCase();
-const letter = (c: string) => upper(c) || lower(c);
-const digit = (c: string) => c >= "0" && c <= "9";
-
-const words = (text: string): string[] => {
-  const parts: string[] = [];
-  let start = 0;
-  for (let i = 0; i < text.length; i++) {
-    const split =
-      sep(text[i]) ||
-      (i > 0 && lower(text[i - 1]) && upper(text[i])) ||
-      (i > 0 && i + 1 < text.length && upper(text[i - 1]) && upper(text[i]) && lower(text[i + 1])) ||
-      (i > 0 && letter(text[i - 1]) !== letter(text[i]) && (letter(text[i - 1]) || digit(text[i - 1])) && (letter(text[i]) || digit(text[i])));
-    if (!split) continue;
-    if (i > start) parts.push(text.slice(start, i));
-    start = sep(text[i]) ? i + 1 : i;
-  }
-  if (start < text.length) parts.push(text.slice(start));
-  return parts.map((word) => word.toLowerCase()).filter((word) => word.length > 0);
-};
-
-const join = (parts: string[], casing: Casing): string =>
-  ({
-    camelCase: () => parts.map((word, i) => (i === 0 ? word : cap(word))).join(""),
-    capitalCase: () => parts.map(cap).join(" "),
-    constantCase: () => parts.map((word) => word.toUpperCase()).join("_"),
-    dotCase: () => parts.join("."),
-    kebabCase: () => parts.join("-"),
-    noCase: () => parts.join(" "),
-    pascalCase: () => parts.map(cap).join(""),
-    pascalSnakeCase: () => parts.map(cap).join("_"),
-    pathCase: () => parts.join("/"),
-    sentenceCase: () => parts.map((word, i) => (i === 0 ? cap(word) : word)).join(" "),
-    snakeCase: () => parts.join("_"),
-    trainCase: () => parts.map(cap).join("-"),
-  }[casing]());
-
-export class ChangeCasingConverter {
-  constructor(private readonly casing: Casing) {}
-  convert = (from: string) => join(words(from), this.casing);
-  reverseConvert = (to: string) => to;
-}