@deterministic-code/datasources 0.0.0-stage → 0.1.0

package/src/statements/InsertStatement.ts

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

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

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

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

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

package/src/statements/NotNull.ts

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

package/src/statements/Operator.ts

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

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

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

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

package/src/statements/ReturnStatementTextRenderer.ts

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

package/src/statements/SelectInsertedIdStatement.ts

@@ -0,0 +1,11 @@
+import type { IStatement } from "./IStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+
+export class SelectInsertedIdStatement implements IStatement {
+  constructor(
+    readonly table: string,
+    readonly column: string,
+  ) {}
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}

package/src/statements/SelectInsertedIdStatementTextRenderer.ts

@@ -0,0 +1,7 @@
+import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.ts";
+
+export class SelectInsertedIdStatementTextRenderer {
+  render(_statement: SelectInsertedIdStatement): string {
+    throw new Error("provider must implement SelectInsertIdStatement");
+  }
+}

package/src/statements/SelectStatement.ts

@@ -0,0 +1,34 @@
+import type { ISelectStatement } from "./ISelectStatement.ts";
+import type { IStatementVisitor } from "./IStatementVisitor.ts";
+import type { IWhere } from "./IWhere.ts";
+import type { Join } from "./Join.ts";
+import type { OrderBy } from "./OrderBy.ts";
+import type { SelectStatementOptions } from "./SelectStatementOptions.ts";
+
+export class SelectStatement implements ISelectStatement {
+  readonly where?: IWhere;
+  readonly distinct: boolean;
+  readonly table?: string;
+  readonly fields: string[];
+  readonly joins: Join[];
+  readonly groupBy: string[];
+  readonly having?: IWhere;
+  readonly orderBy: OrderBy[];
+  readonly limit?: number;
+  readonly offset?: number;
+
+  constructor(options: SelectStatementOptions) {
+    this.where = options.where;
+    this.distinct = options.distinct ?? false;
+    this.table = options.table;
+    this.fields = options.fields ?? [];
+    this.joins = options.joins ?? [];
+    this.groupBy = options.groupBy ?? [];
+    this.having = options.having;
+    this.orderBy = options.orderBy ?? [];
+    this.limit = options.limit;
+    this.offset = options.offset;
+  }
+
+  accept = (visitor: IStatementVisitor): string => visitor.visit(this);
+}

package/src/statements/SelectStatementOptions.ts

@@ -0,0 +1,16 @@
+import type { Join } from "./Join.ts";
+import type { IWhere } from "./IWhere.ts";
+import type { OrderBy } from "./OrderBy.ts";
+
+export type SelectStatementOptions = {
+  table?: string;
+  fields?: string[];
+  distinct?: boolean;
+  where?: IWhere;
+  joins?: Join[];
+  groupBy?: string[];
+  having?: IWhere;
+  orderBy?: OrderBy[];
+  limit?: number;
+  offset?: number;
+};

package/src/statements/SelectStatementTextRenderer.ts

@@ -0,0 +1,71 @@
+import type { IWhere } from "./IWhere.ts";
+import type { Join, JoinKind } from "./Join.ts";
+import { orderText, type OrderBy } from "./OrderBy.ts";
+import type { SelectStatement } from "./SelectStatement.ts";
+import type { StatementTextRenderer } from "./StatementTextRenderer.ts";
+import { Where } from "./Where.ts";
+
+export class SelectStatementTextRenderer {
+  constructor(private readonly text: StatementTextRenderer) {}
+
+  render(statement: SelectStatement): string {
+    return `SELECT ${statement.distinct ? "DISTINCT " : ""}${
+      statement.fields.length === 0 ? "*" : statement.fields.join(", ")
+    } FROM ${statement.table}${this.joinSql(statement.joins)}${this.whereSql(statement.where)}${this.groupSql(statement.groupBy)}${this.havingSql(statement.having)}${this.orderSql(statement.orderBy)}${this.limit(statement.limit)}${this.offset(statement.offset)}`;
+  }
+
+  protected whereSql(where?: IWhere): string {
+    return where ? ` WHERE ${this.text.render(where)}` : "";
+  }
+
+  protected havingSql(having?: IWhere): string {
+    return having ? ` HAVING ${this.text.render(having)}` : "";
+  }
+
+  protected groupSql(columns?: string[]): string {
+    return !columns || columns.length === 0 ? "" : ` GROUP BY ${columns.join(", ")}`;
+  }
+
+  protected orderSql(order?: OrderBy[]): string {
+    return !order || order.length === 0 ? "" : ` ORDER BY ${order.map(orderText).join(", ")}`;
+  }
+
+  protected limit(limit?: number): string {
+    return this.bound("LIMIT", limit);
+  }
+
+  protected offset(offset?: number): string {
+    return this.bound("OFFSET", offset);
+  }
+
+  protected bound(keyword: string, value?: number): string {
+    if (value === undefined) return "";
+    if (value < 0) throw new Error(`negative ${keyword.toLowerCase()}`);
+    return ` ${keyword} ${value}`;
+  }
+
+  protected joinSql(joins?: Join[]): string {
+    if (!joins || joins.length === 0) return "";
+    return joins
+      .map((join) =>
+        join.kind === "cross"
+          ? ` CROSS JOIN ${join.table}`
+          : ` ${this.keyword(join.kind)} ${join.table} ON ${this.text.render(
+              new Where(join.on ?? (() => { throw new Error("empty join"); })()),
+            )}`,
+      )
+      .join("");
+  }
+
+  protected keyword(kind: JoinKind): string {
+    return (
+      {
+        inner: "INNER JOIN",
+        left: "LEFT JOIN",
+        right: "RIGHT JOIN",
+        full: "FULL JOIN",
+        cross: "CROSS JOIN",
+      } as Record<JoinKind, string>
+    )[kind];
+  }
+}

package/src/statements/StatementEvaluator.ts

@@ -0,0 +1,5 @@
+import type { IStatement } from "./IStatement.ts";
+
+export class StatementEvaluator {
+  evaluate = (_statement: IStatement): void => {};
+}