@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/splitStatements.ts

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

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

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

package/src/statements/Aggregate.ts

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

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

package/src/statements/BulkDeleteStatement.ts

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

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

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

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

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

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

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

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

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

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

package/src/statements/Condition.ts

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

package/src/statements/ConditionRenderer.ts

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

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

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

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

package/src/statements/CreateTableStatementTextRenderer.ts

@@ -1,92 +0,0 @@
-import type { CheckConstraint } from "./CheckConstraint.ts";
-import type { Column } from "./Column.ts";
-import type { CreateTableStatement } from "./CreateTableStatement.ts";
-import type { ForeignKey, ReferentialAction } from "./ForeignKey.ts";
-import type { ITableConstraint } from "./ITableConstraint.ts";
-import type { NotNull } from "./NotNull.ts";
-import type { PrimaryKey } from "./PrimaryKey.ts";
-import type { UniqueConstraint } from "./UniqueConstraint.ts";
-
-const actionKeyword: Record<ReferentialAction, string> = {
-  cascade: "CASCADE",
-  setNull: "SET NULL",
-  setDefault: "SET DEFAULT",
-  restrict: "RESTRICT",
-  noAction: "NO ACTION",
-};
-
-export class CreateTableStatementTextRenderer {
-  render(statement: CreateTableStatement): string {
-    return `CREATE TABLE ${this.quote(statement.table!)} (${this.parts(statement).join(", ")})${this.suffix()}`;
-  }
-
-  protected quote(name: string): string {
-    return name;
-  }
-
-  protected suffix(): string {
-    return "";
-  }
-
-  protected typeName(column: Column): string {
-    return column.type;
-  }
-
-  protected columnDefault(column: Column): string {
-    return column.default == null
-      ? ""
-      : column.default.name == null
-        ? ` DEFAULT ${column.default.value}`
-        : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${column.default.value}`;
-  }
-
-  protected identity(_column: Column): string {
-    return "";
-  }
-
-  protected column(column: Column): string {
-    return `${this.quote(column.name)} ${this.typeName(column)}${this.identity(column)}${this.columnDefault(column)}${this.notNullSql(column.notNull)}`;
-  }
-
-  protected constraint(constraint: ITableConstraint): string {
-    return (
-      {
-        primaryKey: (item: PrimaryKey) =>
-          `CONSTRAINT ${this.quote(item.name)} PRIMARY KEY (${this.quoted(item.columns)})`,
-        foreignKey: (item: ForeignKey) => this.foreignKey(item),
-        unique: (item: UniqueConstraint) =>
-          `CONSTRAINT ${this.quote(item.name)} UNIQUE (${this.quoted(item.columns)})`,
-        check: (item: CheckConstraint) =>
-          `CONSTRAINT ${this.quote(item.name)} CHECK (${item.expression})`,
-      } as Record<ITableConstraint["kind"], (item: ITableConstraint) => string>
-    )[constraint.kind]?.(constraint) ??
-      (() => {
-        throw new Error("empty constraint");
-      })();
-  }
-
-  private parts(statement: CreateTableStatement): string[] {
-    return statement.constraints.length === 0
-      ? statement.columns.map((column) => this.column(column))
-      : [
-          ...statement.columns.map((column) => this.column(column)),
-          ...statement.constraints.map((constraint) => this.constraint(constraint)),
-        ];
-  }
-
-  private notNullSql(value?: NotNull): string {
-    return value == null ? "" : value.name == null ? " NOT NULL" : ` CONSTRAINT ${this.quote(value.name)} NOT NULL`;
-  }
-
-  private foreignKey(fk: ForeignKey): string {
-    return `CONSTRAINT ${this.quote(fk.name)} FOREIGN KEY (${this.quoted(fk.columns)}) REFERENCES ${this.quote(fk.referencesTable)} (${this.quoted(fk.referencesColumns)})${this.actionSql("DELETE", fk.onDelete)}${this.actionSql("UPDATE", fk.onUpdate)}`;
-  }
-
-  private quoted(names: string[]): string {
-    return names.map((name) => this.quote(name)).join(", ");
-  }
-
-  private actionSql(kind: string, action?: ReferentialAction): string {
-    return action == null ? "" : ` ON ${kind} ${actionKeyword[action]}`;
-  }
-}

package/src/statements/DefaultStatementTextRenderer.ts

@@ -1,9 +0,0 @@
-import { StatementTextRenderer } from "./StatementTextRenderer.ts";
-
-export class DefaultStatementTextRenderer extends StatementTextRenderer {
-  static readonly instance = new DefaultStatementTextRenderer();
-
-  constructor() {
-    super();
-  }
-}

package/src/statements/DeleteStatement.ts

@@ -1,15 +0,0 @@
-import type { IDeleteStatement } from "./IDeleteStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-import type { IWhere } from "./IWhere.ts";
-
-export class DeleteStatement implements IDeleteStatement {
-  readonly table: string;
-  readonly where?: IWhere;
-
-  constructor(table: string, where?: IWhere) {
-    this.table = table;
-    this.where = where;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-}

package/src/statements/DeleteStatementTextRenderer.ts

@@ -1,12 +0,0 @@
-import type { DeleteStatement } from "./DeleteStatement.ts";
-import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
-
-export class DeleteStatementTextRenderer {
-  constructor(private readonly text: StatementTextRenderer) {}
-
-  render(statement: DeleteStatement): string {
-    return statement.where
-      ? `DELETE FROM ${statement.table} WHERE ${this.text.render(statement.where)}`
-      : `DELETE FROM ${statement.table}`;
-  }
-}

package/src/statements/ExecuteStoredProcedureStatement.ts

@@ -1,15 +0,0 @@
-import type { Parameter } from "../Parameter.ts";
-import type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-
-export class ExecuteStoredProcedureStatement implements IExecuteStoredProcedureStatement {
-  readonly name: string;
-  readonly parameters: Parameter[];
-
-  constructor(name: string, parameters: Parameter[]) {
-    this.name = name;
-    this.parameters = parameters;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-}

package/src/statements/ExecuteStoredProcedureStatementTextRenderer.ts

@@ -1,15 +0,0 @@
-import { ParameterDirection } from "../ParameterDirection.ts";
-import type { Parameter } from "../Parameter.ts";
-import type { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
-
-const args = (parameters: Parameter[]): string =>
-  parameters
-    .filter((parameter) => parameter.direction !== ParameterDirection.ReturnValue)
-    .map((parameter) => `$${parameter.name}`)
-    .join(", ");
-
-export class ExecuteStoredProcedureStatementTextRenderer {
-  render(statement: ExecuteStoredProcedureStatement): string {
-    return `CALL ${statement.name}(${args(statement.parameters)})`;
-  }
-}