@deterministic-code/datasources 0.0.0-stage → 0.1.1

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);
+}

package/src/statements/CreateTableStatementTextRenderer.ts

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

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

package/src/statements/DeleteStatement.ts

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

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

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

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