@deterministic-code/datasources 0.0.0-stage → 0.1.0

package/src/mocks/mock-driver.ts

@@ -0,0 +1,27 @@
+import { columnType as identityColumnType } from "../IDriver.ts";
+import type { DatasourceOptions } from "../DatasourceOptions.ts";
+import type { ICommand } from "../ICommand.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { IDriver } from "../IDriver.ts";
+import type { ITransaction } from "../ITransaction.ts";
+import type { IsolationLevel } from "../IsolationLevel.ts";
+import type { Cell } from "../converters/Cell.ts";
+import type { TypeConverter } from "../converters/TypeConverter.ts";
+import { MockCommand } from "./mock-command.ts";
+import { MockConnection } from "./mock-connection.ts";
+import { MockTransaction } from "./mock-transaction.ts";
+
+export class MockDriver implements IDriver {
+  rowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = {};
+  columnType = identityColumnType;
+  connection = (_options?: DatasourceOptions): IConnection => new MockConnection();
+  command = (connection: IConnection): ICommand => new MockCommand(connection);
+  transaction = (
+    connection: IConnection,
+    isolation: IsolationLevel = "readCommitted",
+  ): ITransaction => {
+    const txn = new MockTransaction(connection);
+    txn.isolation = isolation;
+    return txn;
+  };
+}

package/src/mocks/mock-reader.ts

@@ -0,0 +1,38 @@
+import type { IReader } from "../IReader.ts";
+import { readerToAsyncIterable } from "../readerToAsyncIterable.ts";
+
+export class MockReader<T = unknown> implements IReader<T> {
+  current: T | undefined = undefined;
+  nextCalls = 0;
+  nextError?: unknown;
+  private index = -1;
+
+  constructor(public rows: readonly T[] = []) {}
+
+  async next(): Promise<boolean> {
+    this.nextCalls += 1;
+    if (this.nextError) {
+      throw this.nextError;
+    }
+    this.index += 1;
+    if (this.index < this.rows.length) {
+      this.current = this.rows[this.index];
+      return true;
+    }
+    this.current = undefined;
+    return false;
+  }
+
+  read(): AsyncIterable<T> {
+    return readerToAsyncIterable(this);
+  }
+
+  async nextResult(): Promise<boolean> {
+    this.current = undefined;
+    return false;
+  }
+
+  async dispose(): Promise<void> {}
+
+  [Symbol.asyncDispose] = (): Promise<void> => this.dispose();
+}

package/src/mocks/mock-repository.ts

@@ -0,0 +1,91 @@
+import type { Scalar } from "../builders/Scalar.ts";
+import type { Cells } from "../converters/Cell.ts";
+import type { Constructable } from "../converters/Constructable.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { Parameter } from "../Parameter.ts";
+import type { IExecuteStoredProcedureStatement } from "../statements/IExecuteStoredProcedureStatement.ts";
+import type { ISelectStatement } from "../statements/ISelectStatement.ts";
+import type { ICRUDRepository } from "../ICRUDRepository.ts";
+import { ReadonlyRepository, untyped } from "../ReadonlyRepository.ts";
+import type { ReadonlyRepositoryMappingOptions } from "../ReadonlyRepositoryMappingOptions.ts";
+import type { Response } from "../Response.ts";
+import type { IWhere } from "../statements/IWhere.ts";
+
+export class MockRepository<T = unknown> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+  readonly ids: readonly string[] = [];
+  items: T[] = [];
+  readSingleCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined> = [];
+  readCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined> = [];
+  addCalls: T[] = [];
+  updateCalls: Array<{ item: T; byWhere?: IWhere }> = [];
+  deleteCalls: Array<{ item: T; byWhere?: IWhere }> = [];
+  readSingleError?: unknown;
+  readError?: unknown;
+  addError?: unknown;
+  updateError?: unknown;
+  deleteError?: unknown;
+  addResponse: Response = { result: undefined, rowsAffected: 1 };
+  updateResponse: Response = { result: undefined, rowsAffected: 1 };
+  deleteResponse: Response = { result: undefined, rowsAffected: 1 };
+
+  constructor(
+    _connection: IConnection,
+    type: Constructable<T> = untyped<T>(),
+  ) {
+    super(type);
+  }
+
+  async readSingle(
+    query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement,
+    _parameters?: Parameter[],
+    _options?: ReadonlyRepositoryMappingOptions<T>,
+  ): Promise<T | undefined> {
+    this.readSingleCalls.push(query);
+    if (this.readSingleError) {
+      throw this.readSingleError;
+    }
+    return this.items[0];
+  }
+
+  async *read(
+    query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement,
+    _parameters?: Parameter[],
+    _options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<T> {
+    this.readCalls.push(query);
+    if (this.readError) {
+      throw this.readError;
+    }
+    for (const item of this.items) {
+      yield item;
+    }
+  }
+
+  async create(item: T): Promise<T> {
+    this.addCalls.push(item);
+    if (this.addError) {
+      throw this.addError;
+    }
+    this.items.push(item);
+    this.addResponse = { result: item, rowsAffected: 1 };
+    return item;
+  }
+
+  async update(item: T, byWhere?: IWhere): Promise<Response> {
+    this.updateCalls.push({ item, byWhere });
+    if (this.updateError) {
+      throw this.updateError;
+    }
+    return this.updateResponse;
+  }
+
+  async delete(item: T, byWhere?: IWhere): Promise<Response> {
+    this.deleteCalls.push({ item, byWhere });
+    if (this.deleteError) {
+      throw this.deleteError;
+    }
+    return this.deleteResponse;
+  }
+
+  readSingleById = (_id: Scalar | Cells): Promise<T | undefined> => this.readSingle();
+}

package/src/mocks/mock-select-statement.ts

@@ -0,0 +1,17 @@
+import type { ISelectStatement } from "../statements/ISelectStatement.ts";
+import type { IStatementVisitor } from "../statements/IStatementVisitor.ts";
+import type { IWhere } from "../statements/IWhere.ts";
+
+export class MockSelectStatement implements ISelectStatement {
+  acceptCalls = 0;
+
+  constructor(
+    public text: string,
+    public where?: IWhere,
+  ) {}
+
+  accept(_visitor: IStatementVisitor): string {
+    this.acceptCalls += 1;
+    return this.text;
+  }
+}

package/src/mocks/mock-transaction.ts

@@ -0,0 +1,31 @@
+import type { IConnection } from "../IConnection.ts";
+import type { ITransaction } from "../ITransaction.ts";
+import { IsolationLevel } from "../IsolationLevel.ts";
+
+export class MockTransaction implements ITransaction {
+  commitCalls = 0;
+  abortCalls = 0;
+  commitError?: unknown;
+  abortError?: unknown;
+  committed = false;
+  aborted = false;
+  isolation: IsolationLevel = IsolationLevel.ReadCommitted;
+
+  constructor(readonly connection: IConnection) {}
+
+  async commit(): Promise<void> {
+    this.commitCalls += 1;
+    if (this.commitError) {
+      throw this.commitError;
+    }
+    this.committed = true;
+  }
+
+  async abort(): Promise<void> {
+    this.abortCalls += 1;
+    if (this.abortError) {
+      throw this.abortError;
+    }
+    this.aborted = true;
+  }
+}

package/src/mocks/mock-where.ts

@@ -0,0 +1,13 @@
+import type { IConditionVisitor } from "../statements/IConditionVisitor.ts";
+import type { IWhere } from "../statements/IWhere.ts";
+
+export class MockWhere implements IWhere {
+  acceptCalls = 0;
+
+  constructor(public text: string) {}
+
+  accept(_visitor: IConditionVisitor): string {
+    this.acceptCalls += 1;
+    return this.text;
+  }
+}

package/src/parametersToRecord.ts

@@ -0,0 +1,11 @@
+import type { Parameter } from "./Parameter.ts";
+
+export function parametersToRecord<T>(
+  parameters?: Parameter<T>[] | null,
+): Record<string, T> {
+  if (!parameters) return {};
+  const record: Record<string, T> = {};
+  for (const parameter of parameters)
+    if (parameter.value !== undefined) record[parameter.name] = parameter.value;
+  return record;
+}

package/src/readerToAsyncIterable.ts

@@ -0,0 +1,11 @@
+import type { IReader } from "./IReader.ts";
+
+export async function* readerToAsyncIterable<T>(
+  reader: IReader<T>,
+): AsyncIterable<T> {
+  while (await reader.next()) {
+    if (reader.current !== undefined) {
+      yield reader.current;
+    }
+  }
+}

package/src/splitStatements.ts

@@ -0,0 +1,99 @@
+const quoteOf = (char: string): "'" | "\"" | "`" | undefined =>
+  char === "'" || char === "\"" || char === "`" ? char : undefined;
+
+const word = (sql: string, i: number, token: string): boolean => {
+  if (!sql.startsWith(token, i)) return false;
+  const before = i === 0 || !/[0-9A-Za-z_]/.test(sql[i - 1]!);
+  const after = i + token.length === sql.length || !/[0-9A-Za-z_]/.test(sql[i + token.length]!);
+  return before && after;
+};
+
+const dollarTag = (sql: string, i: number): string | undefined => {
+  if (sql[i] !== "$") return undefined;
+  let end = i + 1;
+  while (end < sql.length && /[0-9A-Za-z_]/.test(sql[end]!)) end += 1;
+  return sql[end] === "$" ? sql.slice(i, end + 1) : undefined;
+};
+
+const routine = (sql: string, start: number, i: number): boolean => {
+  const head = sql.slice(start, i).toUpperCase();
+  return head.includes("CREATE PROCEDURE") || head.includes("CREATE FUNCTION");
+};
+
+export const splitStatements = (sql: string): string[] => {
+  const parts: string[] = [];
+  let start = 0;
+  let quote: "'" | "\"" | "`" | undefined;
+  let dollar: string | undefined;
+  let line = false;
+  let block = false;
+  let depth = 0;
+  for (let i = 0; i < sql.length; i++) {
+    const char = sql.charAt(i);
+    const next = sql.charAt(i + 1);
+    if (line) {
+      if (char === "\n") line = false;
+      continue;
+    }
+    if (block) {
+      if (char === "*" && next === "/") {
+        block = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (dollar) {
+      if (sql.startsWith(dollar, i)) {
+        i += dollar.length - 1;
+        dollar = undefined;
+      }
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        if (next === quote) i += 1;
+        else quote = undefined;
+      }
+      continue;
+    }
+    if (char === "-" && next === "-") {
+      line = true;
+      i += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      block = true;
+      i += 1;
+      continue;
+    }
+    const tag = dollarTag(sql, i);
+    if (tag) {
+      dollar = tag;
+      i += tag.length - 1;
+      continue;
+    }
+    const opened = quoteOf(char);
+    if (opened) {
+      quote = opened;
+      continue;
+    }
+    if (word(sql, i, "BEGIN") && routine(sql, start, i)) {
+      depth += 1;
+      i += 4;
+      continue;
+    }
+    if (char === ";") {
+      if (depth > 0 && routine(sql, start, i)) {
+        if (/\bEND$/i.test(sql.slice(start, i).trimEnd())) depth -= 1;
+        if (depth > 0) continue;
+      }
+      const part = sql.slice(start, i).trim();
+      if (part) parts.push(part);
+      start = i + 1;
+      depth = 0;
+    }
+  }
+  const tail = sql.slice(start).trim();
+  if (tail) parts.push(tail);
+  return parts;
+};

package/src/statementParameters.ts

@@ -0,0 +1,22 @@
+export const statementParameters = (sql: string): string[] => {
+  const names: string[] = [];
+  const seen = new Set<string>();
+  for (let i = 0; i < sql.length; i++) {
+    const char = sql[i];
+    if (char !== "$" && char !== ":" && char !== "@") continue;
+    let end = i + 1;
+    while (end < sql.length && /[0-9A-Za-z_]/.test(sql[end]!)) end += 1;
+    if (end === i + 1) continue;
+    if (char === "$" && sql[end] === "$") {
+      i = end;
+      continue;
+    }
+    const name = sql.slice(i + 1, end);
+    if (!seen.has(name)) {
+      seen.add(name);
+      names.push(name);
+    }
+    i = end - 1;
+  }
+  return names;
+};

package/src/statementUsesParameter.ts

@@ -0,0 +1,4 @@
+import { statementParameters } from "./statementParameters.ts";
+
+export const statementUsesParameter = (sql: string, name: string): boolean =>
+  statementParameters(sql).includes(name.replace(/^[$:@]/, ""));

package/src/statements/Aggregate.ts

@@ -0,0 +1,9 @@
+const fragment = (op: string, column: string, alias?: string): string =>
+  alias === undefined ? `${op}(${column})` : `${op}(${column}) AS ${alias}`;
+
+export const Aggregate = {
+  count: (column: string, alias?: string): string => fragment("COUNT", column, alias),
+  sum: (column: string, alias?: string): string => fragment("SUM", column, alias),
+  min: (column: string, alias?: string): string => fragment("MIN", column, alias),
+  max: (column: string, alias?: string): string => fragment("MAX", column, alias),
+};

package/src/statements/ArrayExpression.ts

@@ -0,0 +1,5 @@
+import type { IExpression } from "./IExpression.ts";
+
+export class ArrayExpression implements IExpression {
+  constructor(readonly elements: IExpression[]) {}
+}

package/src/statements/BulkDeleteStatement.ts

@@ -0,0 +1,18 @@
+import type { Parameter } from "../Parameter.ts";
+import type { IBulkDeleteStatement } from "./IBulkDeleteStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+import { flattenBulkParameters } from "./BulkInsertStatement.ts";
+
+export class BulkDeleteStatement implements IBulkDeleteStatement {
+  constructor(
+    readonly table: string,
+    readonly ids: readonly string[],
+    readonly rows: readonly Parameter[][],
+  ) {}
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+
+  get parameters(): Parameter[] {
+    return flattenBulkParameters(this.ids, this.rows);
+  }
+}

package/src/statements/BulkDeleteStatementTextRenderer.ts

@@ -0,0 +1,16 @@
+import type { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
+
+export class BulkDeleteStatementTextRenderer {
+  render = (statement: BulkDeleteStatement): string => {
+    if (statement.ids.length === 0) return `DELETE FROM ${statement.table} WHERE 1 = 1`;
+    if (statement.ids.length === 1) {
+      const column = statement.ids[0]!;
+      const names = statement.rows.map((_, index) => `$${column}__${index}`).join(", ");
+      return `DELETE FROM ${statement.table} WHERE ${column} IN (${names})`;
+    }
+    const tuples = statement.rows
+      .map((_, index) => `(${statement.ids.map((column) => `$${column}__${index}`).join(", ")})`)
+      .join(", ");
+    return `DELETE FROM ${statement.table} WHERE (${statement.ids.join(", ")}) IN (${tuples})`;
+  };
+}

package/src/statements/BulkInsertStatement.ts

@@ -0,0 +1,37 @@
+import type { Cell } from "../converters/Cell.ts";
+import type { Parameter } from "../Parameter.ts";
+import type { IBulkInsertStatement } from "./IBulkInsertStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+
+const lookup = (fields: readonly Parameter[]): Map<string, Cell> => {
+  const map = new Map<string, Cell>();
+  for (const field of fields) map.set(field.name, (field.value ?? null) as Cell);
+  return map;
+};
+
+export const flattenBulkParameters = (
+  columns: readonly string[],
+  rows: readonly Parameter[][],
+): Parameter[] => {
+  const parameters: Parameter[] = [];
+  rows.forEach((row, index) => {
+    const byName = lookup(row);
+    for (const column of columns)
+      parameters.push({ name: `${column}__${index}`, value: (byName.get(column) ?? null) as Parameter["value"] });
+  });
+  return parameters;
+};
+
+export class BulkInsertStatement implements IBulkInsertStatement {
+  constructor(
+    readonly table: string,
+    readonly columns: readonly string[],
+    readonly rows: readonly Parameter[][],
+  ) {}
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+
+  get parameters(): Parameter[] {
+    return flattenBulkParameters(this.columns, this.rows);
+  }
+}

package/src/statements/BulkInsertStatementTextRenderer.ts

@@ -0,0 +1,10 @@
+import type { BulkInsertStatement } from "./BulkInsertStatement.ts";
+
+export class BulkInsertStatementTextRenderer {
+  render = (statement: BulkInsertStatement): string => {
+    const values = statement.rows.map(
+      (_, index) => `(${statement.columns.map((column) => `$${column}__${index}`).join(", ")})`,
+    );
+    return `INSERT INTO ${statement.table} (${statement.columns.join(", ")}) VALUES ${values.join(", ")}`;
+  };
+}

package/src/statements/BulkUpdateStatement.ts

@@ -0,0 +1,24 @@
+import type { Parameter } from "../Parameter.ts";
+import type { IBulkUpdateStatement } from "./IBulkUpdateStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+import { flattenBulkParameters } from "./BulkInsertStatement.ts";
+
+export type BulkUpdatedRow = { fields: Parameter[]; ids: Parameter[] };
+
+export class BulkUpdateStatement implements IBulkUpdateStatement {
+  constructor(
+    readonly table: string,
+    readonly set: readonly string[],
+    readonly ids: readonly string[],
+    readonly rows: readonly BulkUpdatedRow[],
+  ) {}
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+
+  get parameters(): Parameter[] {
+    return flattenBulkParameters(
+      [...this.set, ...this.ids],
+      this.rows.map((row) => [...row.fields, ...row.ids]),
+    );
+  }
+}

package/src/statements/BulkUpdateStatementTextRenderer.ts

@@ -0,0 +1,29 @@
+import type { Cell } from "../converters/Cell.ts";
+import type { Parameter } from "../Parameter.ts";
+import type { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
+
+export class BulkUpdateStatementTextRenderer {
+  render = (statement: BulkUpdateStatement): string => {
+    const assigns = statement.set.map((column) => `${column} = data.${column}`).join(", ");
+    return `UPDATE ${statement.table} SET ${assigns} FROM ${this.source(statement)} WHERE ${this.on(statement)}`;
+  };
+
+  protected on = (statement: BulkUpdateStatement): string =>
+    statement.ids.map((column) => `${statement.table}.${column} = data.${column}`).join(" AND ");
+
+  protected source = (statement: BulkUpdateStatement): string => {
+    const columns = [...statement.set, ...statement.ids];
+    const selects = statement.rows.map((row, index) => {
+      const byName = new Map<string, Cell>();
+      for (const field of [...row.fields, ...row.ids] as Parameter[])
+        byName.set(field.name, (field.value ?? null) as Cell);
+      return `SELECT ${columns
+        .map((column) => this.cell(column, index, byName.get(column) ?? null))
+        .join(", ")}`;
+    });
+    return `(${selects.join(" UNION ALL ")}) AS data`;
+  };
+
+  protected cell = (column: string, index: number, _value: Cell): string =>
+    `$${column}__${index} AS ${column}`;
+}

package/src/statements/CheckConstraint.ts

@@ -0,0 +1,9 @@
+import type { ITableConstraint } from "./ITableConstraint.ts";
+
+export class CheckConstraint implements ITableConstraint {
+  readonly kind = "check" as const;
+  constructor(
+    readonly name: string,
+    readonly expression: string,
+  ) {}
+}

package/src/statements/Cmp.ts

@@ -0,0 +1,12 @@
+import type { Cell } from "../converters/Cell.ts";
+import type { Condition } from "./Condition.ts";
+import { Operator } from "./Operator.ts";
+
+export type Comparison = (column: string, value: Cell) => Condition;
+
+export const eq: Comparison = (column, value) => new Operator.Equals(column, value);
+export const ne: Comparison = (column, value) => new Operator.NotEquals(column, value);
+export const gt: Comparison = (column, value) => new Operator.GreaterThan(column, value);
+export const lt: Comparison = (column, value) => new Operator.LessThan(column, value);
+export const ge: Comparison = (column, value) => new Operator.GreaterThanOrEqual(column, value);
+export const le: Comparison = (column, value) => new Operator.LessThanOrEqual(column, value);

package/src/statements/Column.ts

@@ -0,0 +1,10 @@
+import type { ColumnDefault } from "./ColumnDefault.ts";
+import type { NotNull } from "./NotNull.ts";
+
+export interface Column {
+  name: string;
+  type: string;
+  default?: ColumnDefault;
+  notNull?: NotNull;
+  identity?: boolean;
+}

package/src/statements/ColumnDefault.ts

@@ -0,0 +1,6 @@
+export class ColumnDefault {
+  constructor(
+    readonly value: string,
+    readonly name?: string,
+  ) {}
+}

package/src/statements/Condition.ts

@@ -0,0 +1,3 @@
+import type { IExpression } from "./IExpression.ts";
+
+export abstract class Condition implements IExpression {}

package/src/statements/ConditionRenderer.ts

@@ -0,0 +1,17 @@
+import type { ICondition } from "./ICondition.ts";
+import type { IConditionVisitor } from "./IConditionVisitor.ts";
+import type { ExpressionRenderer } from "./ExpressionRenderer.ts";
+import { Where } from "./Where.ts";
+import { WhereText } from "./WhereText.ts";
+
+export class ConditionRenderer implements IConditionVisitor {
+  constructor(private readonly expressions: ExpressionRenderer) {}
+
+  render = (condition: ICondition): string => condition.accept(this);
+
+  visit(where: Where): string;
+  visit(where: WhereText): string;
+  visit(where: Where | WhereText): string {
+    return where instanceof Where ? this.expressions.render(where.condition) : where.rawText;
+  }
+}

package/src/statements/CreateIndexStatement.ts

@@ -0,0 +1,18 @@
+import type { ICreateIndexStatement } from "./ICreateIndexStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+
+export class CreateIndexStatement implements ICreateIndexStatement {
+  readonly name: string;
+  readonly table: string;
+  readonly columns: string[];
+  readonly unique: boolean;
+
+  constructor(name: string, table: string, columns: string[], unique = false) {
+    this.name = name;
+    this.table = table;
+    this.columns = columns;
+    this.unique = unique;
+  }
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}

package/src/statements/CreateIndexStatementTextRenderer.ts

@@ -0,0 +1,11 @@
+import type { CreateIndexStatement } from "./CreateIndexStatement.ts";
+
+export class CreateIndexStatementTextRenderer {
+  render(statement: CreateIndexStatement): string {
+    return `CREATE ${statement.unique ? "UNIQUE " : ""}INDEX ${this.quote(statement.name)} ON ${this.quote(statement.table)} (${statement.columns.map((column) => this.quote(column)).join(", ")})`;
+  }
+
+  protected quote(name: string): string {
+    return name;
+  }
+}

package/src/statements/CreateTableStatement.ts

@@ -0,0 +1,18 @@
+import type { Column } from "./Column.ts";
+import type { ICreateTableStatement } from "./ICreateTableStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+import type { ITableConstraint } from "./ITableConstraint.ts";
+
+export class CreateTableStatement implements ICreateTableStatement {
+  readonly table: string;
+  readonly columns: Column[];
+  readonly constraints: ITableConstraint[];
+
+  constructor(table: string, columns: Column[], constraints: ITableConstraint[] = []) {
+    this.table = table;
+    this.columns = columns;
+    this.constraints = constraints;
+  }
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}