@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/statements/IStatementVisitor.js

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

package/{src/statements/ITableConstraint.ts → dist/statements/ITableConstraint.d.ts}

@@ -1,6 +1,5 @@
 export type TableConstraintKind = "primaryKey" | "foreignKey" | "unique" | "check";
-
 export interface ITableConstraint {
-  readonly kind: TableConstraintKind;
-  readonly name: string;
+    readonly kind: TableConstraintKind;
+    readonly name: string;
 }

package/dist/statements/ITableConstraint.js

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

package/dist/statements/IUpdateStatement.d.ts

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

package/dist/statements/IUpdateStatement.js

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

package/dist/statements/IWhere.d.ts

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

package/dist/statements/IWhere.js

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

package/dist/statements/Identifier.d.ts

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

package/dist/statements/Identifier.js

@@ -0,0 +1,6 @@
+export class Identifier {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}

package/dist/statements/IdentityInsertStatement.d.ts

@@ -0,0 +1,11 @@
+import type { IIdentityInsertStatement } from "./IIdentityInsertStatement.js";
+import type { InsertStatement } from "./InsertStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class IdentityInsertStatement implements IIdentityInsertStatement {
+    readonly table: string;
+    readonly idColumn: string;
+    readonly inserts: readonly InsertStatement[];
+    readonly identity: boolean;
+    constructor(table: string, idColumn: string, inserts: readonly InsertStatement[], identity?: boolean);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/IdentityInsertStatement.js

@@ -0,0 +1,13 @@
+export class IdentityInsertStatement {
+    table;
+    idColumn;
+    inserts;
+    identity;
+    constructor(table, idColumn, inserts, identity = false) {
+        this.table = table;
+        this.idColumn = idColumn;
+        this.inserts = inserts;
+        this.identity = identity;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/IdentityInsertStatementTextRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { IdentityInsertStatement } from "./IdentityInsertStatement.js";
+import type { InsertStatement } from "./InsertStatement.js";
+export declare class IdentityInsertStatementTextRenderer {
+    render(statement: IdentityInsertStatement): string;
+    protected insert(statement: InsertStatement): string;
+}

package/dist/statements/IdentityInsertStatementTextRenderer.js

@@ -0,0 +1,8 @@
+export class IdentityInsertStatementTextRenderer {
+    render(statement) {
+        return statement.inserts.map((insert) => this.insert(insert)).join("\n");
+    }
+    insert(statement) {
+        return `INSERT INTO ${statement.table} (${statement.fields.map((field) => field.name).join(", ")}) VALUES (${statement.fields.map((field) => String(field.value)).join(", ")});`;
+    }
+}

package/dist/statements/InsertStatement.d.ts

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

package/dist/statements/InsertStatement.js

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

package/dist/statements/InsertStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { InsertStatement } from "./InsertStatement.js";
+export declare class InsertStatementTextRenderer {
+    render(statement: InsertStatement): string;
+}

package/dist/statements/InsertStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class InsertStatementTextRenderer {
+    render(statement) {
+        return `INSERT INTO ${statement.table} (${statement.fields.map((field) => field.name).join(", ")}) VALUES (${statement.fields.map((field) => `$${field.name}`).join(", ")})`;
+    }
+}

package/dist/statements/Join.d.ts

@@ -0,0 +1,14 @@
+import type { IExpression } from "./IExpression.js";
+export type JoinKind = "inner" | "left" | "right" | "full" | "cross";
+export type Join = {
+    kind: JoinKind;
+    table: string;
+    on?: IExpression;
+};
+export declare const Join: {
+    inner: (table: string, left: string, right: string) => Join;
+    left: (table: string, left: string, right: string) => Join;
+    right: (table: string, left: string, right: string) => Join;
+    full: (table: string, left: string, right: string) => Join;
+    cross: (table: string) => Join;
+};

package/dist/statements/Join.js

@@ -0,0 +1,10 @@
+import { Identifier } from "./Identifier.js";
+import { Operator } from "./Operator.js";
+const equality = (left, right) => new Operator.Equals(new Identifier(left), new Identifier(right));
+export const Join = {
+    inner: (table, left, right) => ({ kind: "inner", table, on: equality(left, right) }),
+    left: (table, left, right) => ({ kind: "left", table, on: equality(left, right) }),
+    right: (table, left, right) => ({ kind: "right", table, on: equality(left, right) }),
+    full: (table, left, right) => ({ kind: "full", table, on: equality(left, right) }),
+    cross: (table) => ({ kind: "cross", table }),
+};

package/dist/statements/Literal.d.ts

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

package/dist/statements/Literal.js

@@ -0,0 +1,6 @@
+export class Literal {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}

package/dist/statements/Native.d.ts

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

package/dist/statements/Native.js

@@ -0,0 +1,7 @@
+export class Native {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+}
+export const n = (text) => new Native(text);

package/dist/statements/NotNull.d.ts

@@ -0,0 +1,4 @@
+export declare class NotNull {
+    readonly name?: string | undefined;
+    constructor(name?: string | undefined);
+}

package/dist/statements/NotNull.js

@@ -0,0 +1,6 @@
+export class NotNull {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}

package/dist/statements/Operator.d.ts

@@ -0,0 +1,107 @@
+import type { Cell } from "../converters/Cell.js";
+import { Condition } from "./Condition.js";
+import type { IExpression } from "./IExpression.js";
+export declare abstract class Operator extends Condition {
+}
+export declare namespace Operator {
+    class Equals extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class NotEquals extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class GreaterThan extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class LessThan extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class GreaterThanOrEqual extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class LessThanOrEqual extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class And extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(left: IExpression, right: IExpression);
+    }
+    class Or extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(left: IExpression, right: IExpression);
+    }
+    class In extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, values: Cell[]);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class Not extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+    class IsNull extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+    class IsNotNull extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+    class Like extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class NotLike extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, value: Cell);
+        constructor(left: IExpression, right: IExpression);
+    }
+    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);
+    }
+    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);
+    }
+    class NotIn extends Operator {
+        readonly left: IExpression;
+        readonly right: IExpression;
+        constructor(field: string, values: Cell[]);
+        constructor(left: IExpression, right: IExpression);
+    }
+    class Exists extends Operator {
+        readonly argument: IExpression;
+        constructor(argument: IExpression);
+    }
+}

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.d.ts

@@ -0,0 +1,10 @@
+export type SortDirection = "asc" | "desc";
+export type OrderBy = {
+    column: string;
+    direction: SortDirection;
+};
+export declare const OrderBy: {
+    asc: (column: string) => OrderBy;
+    desc: (column: string) => OrderBy;
+};
+export declare const orderText: (order: OrderBy) => string;

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.d.ts

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

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.d.ts

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

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.d.ts

@@ -0,0 +1,4 @@
+import type { ReturnStatement } from "./ReturnStatement.js";
+export declare class ReturnStatementTextRenderer {
+    render(statement: ReturnStatement): string;
+}

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.d.ts

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

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.d.ts

@@ -0,0 +1,4 @@
+import type { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+export declare class SelectInsertedIdStatementTextRenderer {
+    render(_statement: SelectInsertedIdStatement): string;
+}

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.d.ts

@@ -0,0 +1,20 @@
+import type { ISelectStatement } from "./ISelectStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { IWhere } from "./IWhere.js";
+import type { Join } from "./Join.js";
+import type { OrderBy } from "./OrderBy.js";
+import type { SelectStatementOptions } from "./SelectStatementOptions.js";
+export declare 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);
+    accept: (visitor: IStatementVisitor) => string;
+}