@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/statements/ExpressionRenderer.ts

@@ -1,161 +0,0 @@
-import type { Cell } from "../converters/Cell.ts";
-import { ArrayExpression } from "./ArrayExpression.ts";
-import type { IExpression } from "./IExpression.ts";
-import { Identifier } from "./Identifier.ts";
-import { Literal } from "./Literal.ts";
-import { Operator } from "./Operator.ts";
-import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
-import { Subquery } from "./Subquery.ts";
-import { Where } from "./Where.ts";
-
-export class ExpressionRenderer {
-  constructor(private readonly text: StatementTextRenderer) {}
-
-  render = (expression: IExpression): string => {
-    if (expression instanceof Where) return this.render(expression.condition);
-    if (expression instanceof Identifier) return expression.name;
-    if (expression instanceof Literal) return inline(expression.value);
-    if (expression instanceof ArrayExpression) return expression.elements.map((e) => this.render(e)).join(", ");
-    if (expression instanceof Operator.Not) return `NOT (${this.render(expression.argument)})`;
-    if (expression instanceof Operator.IsNull) return `${this.render(expression.argument)} IS NULL`;
-    if (expression instanceof Operator.IsNotNull) return `${this.render(expression.argument)} IS NOT NULL`;
-    if (expression instanceof Operator.Exists) return `EXISTS ${this.render(expression.argument)}`;
-    if (expression instanceof Subquery) return `(${this.text.render(expression.query)})`;
-    if (
-      expression instanceof Operator.In &&
-      expression.left instanceof Identifier &&
-      expression.right instanceof ArrayExpression
-    )
-      return expression.right.elements.length === 0
-        ? "1 = 0"
-        : `${expression.left.name} IN (${slots(expression.left.name, expression.right.elements.length)})`;
-    if (
-      expression instanceof Operator.In &&
-      expression.left instanceof Identifier &&
-      expression.right instanceof Subquery
-    )
-      return `${expression.left.name} IN ${this.render(expression.right)}`;
-    if (
-      expression instanceof Operator.NotIn &&
-      expression.left instanceof Identifier &&
-      expression.right instanceof ArrayExpression
-    )
-      return expression.right.elements.length === 0
-        ? "1 = 1"
-        : `${expression.left.name} NOT IN (${slots(expression.left.name, expression.right.elements.length)})`;
-    if (
-      expression instanceof Operator.NotIn &&
-      expression.left instanceof Identifier &&
-      expression.right instanceof Subquery
-    )
-      return `${expression.left.name} NOT IN ${this.render(expression.right)}`;
-    if (
-      (expression instanceof Operator.Between || expression instanceof Operator.NotBetween) &&
-      expression.value instanceof Identifier &&
-      expression.low instanceof Literal &&
-      expression.high instanceof Literal
-    ) {
-      const word = expression instanceof Operator.NotBetween ? "NOT BETWEEN" : "BETWEEN";
-      return `${expression.value.name} ${word} $${parameterName(expression.value.name)}_0 AND $${parameterName(expression.value.name)}_1`;
-    }
-    if (expression instanceof Operator.Between)
-      return `${this.render(expression.value)} BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
-    if (expression instanceof Operator.NotBetween)
-      return `${this.render(expression.value)} NOT BETWEEN ${this.render(expression.low)} AND ${this.render(expression.high)}`;
-    if (expression instanceof Operator.And)
-      return `${this.wrap(expression.left, true)} AND ${this.wrap(expression.right, true)}`;
-    if (expression instanceof Operator.Or)
-      return `${this.wrap(expression.left, false)} OR ${this.wrap(expression.right, false)}`;
-    const operands = expression instanceof Operator ? pair(expression) : undefined;
-    if (operands && operands.left instanceof Identifier && operands.right instanceof Literal)
-      return `${operands.left.name} ${symbol(expression as Operator)} $${parameterName(operands.left.name)}`;
-    if (operands && operands.left instanceof Literal && operands.right instanceof Literal)
-      return `${inline(operands.left.value)} ${symbol(expression as Operator)} ${inline(operands.right.value)}`;
-    if (operands)
-      return `${this.render(operands.left)} ${symbol(expression as Operator)} ${this.render(operands.right)}`;
-    throw new Error("empty expression");
-  };
-
-  private wrap = (child: IExpression, and: boolean): string =>
-    needsParens(child, and) ? `(${this.render(child)})` : this.render(child);
-}
-
-const symbol = (op: Operator): string =>
-  op instanceof Operator.Equals
-    ? "="
-    : op instanceof Operator.NotEquals
-      ? "<>"
-      : op instanceof Operator.GreaterThan
-        ? ">"
-        : op instanceof Operator.LessThan
-          ? "<"
-          : op instanceof Operator.GreaterThanOrEqual
-            ? ">="
-            : op instanceof Operator.LessThanOrEqual
-              ? "<="
-              : op instanceof Operator.Like
-                ? "LIKE"
-                : op instanceof Operator.NotLike
-                  ? "NOT LIKE"
-                  : "IN";
-
-const inline = (value: Cell): string =>
-  value === null
-    ? "null"
-    : typeof value === "boolean"
-      ? String(value)
-      : typeof value === "string"
-        ? `'${value.replace(/'/g, "''")}'`
-        : String(value);
-
-const needsParens = (child: IExpression, and: boolean): boolean =>
-  child instanceof Where
-    ? needsParens(child.condition, and)
-    : child instanceof Operator.Not ||
-      child instanceof Operator.In ||
-      child instanceof Operator.NotIn ||
-      (child instanceof Operator.And && !and) ||
-      (child instanceof Operator.Or && and);
-
-const pair = (
-  expression: Operator,
-): { left: IExpression; right: IExpression } | undefined =>
-  expression instanceof Operator.Equals ||
-  expression instanceof Operator.NotEquals ||
-  expression instanceof Operator.GreaterThan ||
-  expression instanceof Operator.LessThan ||
-  expression instanceof Operator.GreaterThanOrEqual ||
-  expression instanceof Operator.LessThanOrEqual ||
-  expression instanceof Operator.And ||
-  expression instanceof Operator.Or ||
-  expression instanceof Operator.In ||
-  expression instanceof Operator.Like ||
-  expression instanceof Operator.NotLike
-    ? expression
-    : undefined;
-
-const parameterName = (name: string): string =>
-  parts(name)
-    .map((part) =>
-      part.length >= 2 && part.startsWith('"') && part.endsWith('"')
-        ? part.slice(1, -1).replace(/""/g, '"')
-        : part,
-    )
-    .join(".");
-
-const parts = (name: string): string[] => {
-  const found: string[] = [];
-  let start = 0;
-  let quoted = false;
-  for (let i = 0; i < name.length; i++) {
-    if (name[i] === '"') quoted = !quoted;
-    if (name[i] !== "." || quoted) continue;
-    found.push(name.slice(start, i));
-    start = i + 1;
-  }
-  found.push(name.slice(start));
-  return found;
-};
-
-const slots = (name: string, count: number): string =>
-  Array.from({ length: count }, (_, i) => `$${parameterName(name)}_${i}`).join(", ");

package/src/statements/ForeignKey.ts

@@ -1,23 +0,0 @@
-import type { ITableConstraint } from "./ITableConstraint.ts";
-
-export const ReferentialAction = {
-  Cascade: "cascade",
-  SetNull: "setNull",
-  SetDefault: "setDefault",
-  Restrict: "restrict",
-  NoAction: "noAction",
-} as const;
-
-export type ReferentialAction = (typeof ReferentialAction)[keyof typeof ReferentialAction];
-
-export class ForeignKey implements ITableConstraint {
-  readonly kind = "foreignKey" as const;
-  constructor(
-    readonly name: string,
-    readonly columns: string[],
-    readonly referencesTable: string,
-    readonly referencesColumns: string[],
-    readonly onDelete?: ReferentialAction,
-    readonly onUpdate?: ReferentialAction,
-  ) {}
-}

package/src/statements/IBulkDeleteStatement.ts

@@ -1,3 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-
-export interface IBulkDeleteStatement extends IStatement {}

package/src/statements/IBulkInsertStatement.ts

@@ -1,3 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-
-export interface IBulkInsertStatement extends IStatement {}

package/src/statements/IBulkUpdateStatement.ts

@@ -1,3 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-
-export interface IBulkUpdateStatement extends IStatement {}

package/src/statements/ICondition.ts

@@ -1,5 +0,0 @@
-import type { IConditionVisitor } from "./IConditionVisitor.ts";
-
-export interface ICondition {
-  accept(visitor: IConditionVisitor): string;
-}

package/src/statements/IConditionVisitor.ts

@@ -1,7 +0,0 @@
-import type { Where } from "./Where.ts";
-import type { WhereText } from "./WhereText.ts";
-
-export interface IConditionVisitor {
-  visit(where: Where): string;
-  visit(where: WhereText): string;
-}

package/src/statements/ICreateIndexStatement.ts

@@ -1,3 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-
-export interface ICreateIndexStatement extends IStatement {}

package/src/statements/ICreateTableStatement.ts

@@ -1,3 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-
-export interface ICreateTableStatement extends IStatement {}

package/src/statements/IDeleteStatement.ts

@@ -1,6 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-import type { IWhere } from "./IWhere.ts";
-
-export interface IDeleteStatement extends IStatement {
-  readonly where?: IWhere;
-}

package/src/statements/IExpression.ts

@@ -1 +0,0 @@
-export interface IExpression {}

package/src/statements/IInsertStatement.ts

@@ -1,3 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-
-export interface IInsertStatement extends IStatement {}

package/src/statements/IReturnStatement.ts

@@ -1,3 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-
-export interface IReturnStatement extends IStatement {}

package/src/statements/ISelectStatement.ts

@@ -1,6 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-import type { IWhere } from "./IWhere.ts";
-
-export interface ISelectStatement extends IStatement {
-  readonly where?: IWhere;
-}

package/src/statements/IStatement.ts

@@ -1,5 +0,0 @@
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-
-export interface IStatement {
-  accept(visitor: IStatementVisitor): string;
-}

package/src/statements/IStatementVisitor.ts

@@ -1,27 +0,0 @@
-import type { BulkDeleteStatement } from "./BulkDeleteStatement.ts";
-import type { BulkInsertStatement } from "./BulkInsertStatement.ts";
-import type { BulkUpdateStatement } from "./BulkUpdateStatement.ts";
-import type { CreateIndexStatement } from "./CreateIndexStatement.ts";
-import type { CreateTableStatement } from "./CreateTableStatement.ts";
-import type { DeleteStatement } from "./DeleteStatement.ts";
-import type { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.ts";
-import type { InsertStatement } from "./InsertStatement.ts";
-import type { ReturnStatement } from "./ReturnStatement.ts";
-import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
-import type { SelectStatement } from "./SelectStatement.ts";
-import type { UpdateStatement } from "./UpdateStatement.ts";
-
-export interface IStatementVisitor {
-  visit(statement: SelectStatement): string;
-  visit(statement: InsertStatement): string;
-  visit(statement: UpdateStatement): string;
-  visit(statement: DeleteStatement): string;
-  visit(statement: CreateTableStatement): string;
-  visit(statement: CreateIndexStatement): string;
-  visit(statement: ExecuteStoredProcedureStatement): string;
-  visit(statement: ReturnStatement): string;
-  visit(statement: SelectInsertedIdStatement): string;
-  visit(statement: BulkInsertStatement): string;
-  visit(statement: BulkUpdateStatement): string;
-  visit(statement: BulkDeleteStatement): string;
-}

package/src/statements/IUpdateStatement.ts

@@ -1,6 +0,0 @@
-import type { IStatement } from "./IStatement.ts";
-import type { IWhere } from "./IWhere.ts";
-
-export interface IUpdateStatement extends IStatement {
-  readonly where?: IWhere;
-}

package/src/statements/IWhere.ts

@@ -1,7 +0,0 @@
-import type { Parameter } from "../Parameter.ts";
-import type { ICondition } from "./ICondition.ts";
-import type { IExpression } from "./IExpression.ts";
-
-export interface IWhere extends IExpression, ICondition {
-  readonly parameters?: Parameter[];
-}

package/src/statements/Identifier.ts

@@ -1,5 +0,0 @@
-import type { IExpression } from "./IExpression.ts";
-
-export class Identifier implements IExpression {
-  constructor(readonly name: string) {}
-}

package/src/statements/InsertStatement.ts

@@ -1,15 +0,0 @@
-import type { Field } from "../builders/Field.ts";
-import type { IInsertStatement } from "./IInsertStatement.ts";
-import type { IStatementVisitor } from "./IStatementVisitor.ts";
-
-export class InsertStatement implements IInsertStatement {
-  readonly table: string;
-  readonly fields: Field[];
-
-  constructor(table: string, fields: Field[]) {
-    this.table = table;
-    this.fields = fields;
-  }
-
-  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
-}

package/src/statements/InsertStatementTextRenderer.ts

@@ -1,7 +0,0 @@
-import type { InsertStatement } from "./InsertStatement.ts";
-
-export class InsertStatementTextRenderer {
-  render(statement: InsertStatement): string {
-    return `INSERT INTO ${statement.table} (${statement.fields.map((field) => field.name).join(", ")}) VALUES (${statement.fields.map((field) => `$${field.name}`).join(", ")})`;
-  }
-}

package/src/statements/Join.ts

@@ -1,26 +0,0 @@
-import { Identifier } from "./Identifier.ts";
-import type { IExpression } from "./IExpression.ts";
-import { Operator } from "./Operator.ts";
-
-export type JoinKind = "inner" | "left" | "right" | "full" | "cross";
-
-export type Join = {
-  kind: JoinKind;
-  table: string;
-  on?: IExpression;
-};
-
-const equality = (left: string, right: string): IExpression =>
-  new Operator.Equals(new Identifier(left), new Identifier(right));
-
-export const Join = {
-  inner: (table: string, left: string, right: string): Join =>
-    ({ kind: "inner", table, on: equality(left, right) }),
-  left: (table: string, left: string, right: string): Join =>
-    ({ kind: "left", table, on: equality(left, right) }),
-  right: (table: string, left: string, right: string): Join =>
-    ({ kind: "right", table, on: equality(left, right) }),
-  full: (table: string, left: string, right: string): Join =>
-    ({ kind: "full", table, on: equality(left, right) }),
-  cross: (table: string): Join => ({ kind: "cross", table }),
-};

package/src/statements/Literal.ts

@@ -1,6 +0,0 @@
-import type { Cell } from "../converters/Cell.ts";
-import type { IExpression } from "./IExpression.ts";
-
-export class Literal implements IExpression {
-  constructor(readonly value: Cell) {}
-}

package/src/statements/Native.ts

@@ -1,5 +0,0 @@
-export class Native {
-  constructor(readonly text: string) {}
-}
-
-export const n = (text: string): Native => new Native(text);

package/src/statements/NotNull.ts

@@ -1,3 +0,0 @@
-export class NotNull {
-  constructor(readonly name?: string) {}
-}

package/src/statements/Operator.ts

@@ -1,234 +0,0 @@
-import type { Cell } from "../converters/Cell.ts";
-import { ArrayExpression } from "./ArrayExpression.ts";
-import { Condition } from "./Condition.ts";
-import { Identifier } from "./Identifier.ts";
-import type { IExpression } from "./IExpression.ts";
-import { Literal } from "./Literal.ts";
-
-const pair = (
-  left: string | IExpression,
-  right: IExpression | Cell,
-): [IExpression, IExpression] =>
-  typeof left === "string"
-    ? [new Identifier(left), new Literal(right as Cell)]
-    : [left, right as IExpression];
-
-export abstract class Operator extends Condition {}
-
-export namespace Operator {
-  export class Equals extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class NotEquals extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class GreaterThan extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class LessThan extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class GreaterThanOrEqual extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class LessThanOrEqual extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class And extends Operator {
-    constructor(
-      readonly left: IExpression,
-      readonly right: IExpression,
-    ) {
-      super();
-    }
-  }
-
-  export class Or extends Operator {
-    constructor(
-      readonly left: IExpression,
-      readonly right: IExpression,
-    ) {
-      super();
-    }
-  }
-
-  export class In extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, values: Cell[]);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: Cell[] | IExpression) {
-      super();
-      if (typeof left === "string") {
-        this.left = new Identifier(left);
-        this.right = new ArrayExpression(
-          (right as Cell[]).map((value) => new Literal(value)),
-        );
-      } else {
-        this.left = left;
-        this.right = right as IExpression;
-      }
-    }
-  }
-
-  /* v8 ignore next 6 */
-  export class Not extends Operator {
-    readonly argument: IExpression;
-    constructor(argument: IExpression) {
-      super();
-      this.argument = argument;
-    }
-  }
-
-  export class IsNull extends Operator {
-    readonly argument: IExpression;
-    constructor(argument: IExpression) {
-      super();
-      this.argument = argument;
-    }
-  }
-
-  export class IsNotNull extends Operator {
-    readonly argument: IExpression;
-    constructor(argument: IExpression) {
-      super();
-      this.argument = argument;
-    }
-  }
-
-  export class Like extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class NotLike extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, value: Cell);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: IExpression | Cell) {
-      super();
-      [this.left, this.right] = pair(left, right);
-    }
-  }
-
-  export class Between extends Operator {
-    readonly value: IExpression;
-    readonly low: IExpression;
-    readonly high: IExpression;
-    constructor(field: string, low: Cell, high: Cell);
-    constructor(value: IExpression, low: IExpression, high: IExpression);
-    constructor(value: string | IExpression, low: IExpression | Cell, high: IExpression | Cell) {
-      super();
-      if (typeof value === "string") {
-        this.value = new Identifier(value);
-        this.low = new Literal(low as Cell);
-        this.high = new Literal(high as Cell);
-      } else {
-        this.value = value;
-        this.low = low as IExpression;
-        this.high = high as IExpression;
-      }
-    }
-  }
-
-  export class NotBetween extends Operator {
-    readonly value: IExpression;
-    readonly low: IExpression;
-    readonly high: IExpression;
-    constructor(field: string, low: Cell, high: Cell);
-    constructor(value: IExpression, low: IExpression, high: IExpression);
-    constructor(value: string | IExpression, low: IExpression | Cell, high: IExpression | Cell) {
-      super();
-      if (typeof value === "string") {
-        this.value = new Identifier(value);
-        this.low = new Literal(low as Cell);
-        this.high = new Literal(high as Cell);
-      } else {
-        this.value = value;
-        this.low = low as IExpression;
-        this.high = high as IExpression;
-      }
-    }
-  }
-
-  export class NotIn extends Operator {
-    readonly left: IExpression;
-    readonly right: IExpression;
-    constructor(field: string, values: Cell[]);
-    constructor(left: IExpression, right: IExpression);
-    constructor(left: string | IExpression, right: Cell[] | IExpression) {
-      super();
-      if (typeof left === "string") {
-        this.left = new Identifier(left);
-        this.right = new ArrayExpression((right as Cell[]).map((value) => new Literal(value)));
-      } else {
-        this.left = left;
-        this.right = right as IExpression;
-      }
-    }
-  }
-
-  /* v8 ignore next */
-  export class Exists extends Operator {
-    readonly argument: IExpression;
-    constructor(argument: IExpression) {
-      super();
-      this.argument = argument;
-    }
-  }
-}

package/src/statements/OrderBy.ts

@@ -1,19 +0,0 @@
-export type SortDirection = "asc" | "desc";
-
-export type OrderBy = {
-  column: string;
-  direction: SortDirection;
-};
-
-const directionSql: Record<SortDirection, string> = {
-  asc: "ASC",
-  desc: "DESC",
-};
-
-export const OrderBy = {
-  asc: (column: string): OrderBy => ({ column, direction: "asc" }),
-  desc: (column: string): OrderBy => ({ column, direction: "desc" }),
-};
-
-export const orderText = (order: OrderBy): string =>
-  `${order.column} ${directionSql[order.direction]}`;

package/src/statements/PrimaryKey.ts

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

package/src/statements/ReturnStatement.ts

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