@deterministic-code/datasources 0.1.1 → 0.1.3

package/dist/statements/Operator.js

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

package/dist/statements/OrderBy.js

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

package/dist/statements/PrimaryKey.js

@@ -0,0 +1,9 @@
+export class PrimaryKey {
+    name;
+    columns;
+    kind = "primaryKey";
+    constructor(name, columns) {
+        this.name = name;
+        this.columns = columns;
+    }
+}

package/dist/statements/ReturnStatement.js

@@ -0,0 +1,9 @@
+export class ReturnStatement {
+    name;
+    parameters;
+    constructor(name, parameters) {
+        this.name = name;
+        this.parameters = parameters;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/ReturnStatementTextRenderer.js

@@ -0,0 +1,10 @@
+import { ParameterDirection } from "../ParameterDirection.js";
+const args = (parameters) => parameters
+    .filter((parameter) => parameter.direction !== ParameterDirection.ReturnValue)
+    .map((parameter) => `$${parameter.name}`)
+    .join(", ");
+export class ReturnStatementTextRenderer {
+    render(statement) {
+        return `SELECT ${statement.name}(${args(statement.parameters)})`;
+    }
+}

package/dist/statements/RoutineParameter.d.ts

@@ -0,0 +1,4 @@
+export type RoutineParameter = {
+    name: string;
+    type: string;
+};

package/dist/statements/RoutineParameter.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/SelectInsertedIdStatement.js

@@ -0,0 +1,9 @@
+export class SelectInsertedIdStatement {
+    table;
+    column;
+    constructor(table, column) {
+        this.table = table;
+        this.column = column;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/SelectInsertedIdStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class SelectInsertedIdStatementTextRenderer {
+    render(_statement) {
+        throw new Error("provider must implement SelectInsertIdStatement");
+    }
+}

package/dist/statements/SelectStatement.js

@@ -0,0 +1,25 @@
+export class SelectStatement {
+    where;
+    distinct;
+    table;
+    fields;
+    joins;
+    groupBy;
+    having;
+    orderBy;
+    limit;
+    offset;
+    constructor(options) {
+        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) => visitor.visit(this);
+}

package/dist/statements/SelectStatementOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/statements/SelectStatementTextRenderer.js

@@ -0,0 +1,54 @@
+import { orderText } from "./OrderBy.js";
+import { Where } from "./Where.js";
+export class SelectStatementTextRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    render(statement) {
+        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)}`;
+    }
+    whereSql(where) {
+        return where ? ` WHERE ${this.text.render(where)}` : "";
+    }
+    havingSql(having) {
+        return having ? ` HAVING ${this.text.render(having)}` : "";
+    }
+    groupSql(columns) {
+        return !columns || columns.length === 0 ? "" : ` GROUP BY ${columns.join(", ")}`;
+    }
+    orderSql(order) {
+        return !order || order.length === 0 ? "" : ` ORDER BY ${order.map(orderText).join(", ")}`;
+    }
+    limit(limit) {
+        return this.bound("LIMIT", limit);
+    }
+    offset(offset) {
+        return this.bound("OFFSET", offset);
+    }
+    bound(keyword, value) {
+        if (value === undefined)
+            return "";
+        if (value < 0)
+            throw new Error(`negative ${keyword.toLowerCase()}`);
+        return ` ${keyword} ${value}`;
+    }
+    joinSql(joins) {
+        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("");
+    }
+    keyword(kind) {
+        return {
+            inner: "INNER JOIN",
+            left: "LEFT JOIN",
+            right: "RIGHT JOIN",
+            full: "FULL JOIN",
+            cross: "CROSS JOIN",
+        }[kind];
+    }
+}

package/dist/statements/StatementEvaluator.js

@@ -0,0 +1,3 @@
+export class StatementEvaluator {
+    evaluate = (_statement) => { };
+}