@deterministic-code/datasources 0.0.0-stage → 0.1.0

package/src/RepositoryFactory.ts

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

package/src/RepositoryNotRegisteredError.ts

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

package/src/RepositoryTree.ts

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

package/src/RepositoryTreeNode.ts

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

package/src/Response.ts

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

package/src/Row.ts

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

package/src/SingleCommandIBulkWriteStrategy.ts

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

package/src/StatementMappers.ts

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

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

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

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

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