@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/statements/CreateReadStoredProcedureStatement.d.ts

@@ -0,0 +1,17 @@
+import type { ICreateReadStoredProcedureStatement } from "./ICreateReadStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateReadStoredProcedureStatement implements ICreateReadStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly parameters: readonly RoutineParameter[];
+    readonly key: string;
+    readonly keyType: string;
+    readonly writable: readonly string[];
+    readonly byProperties: readonly string[];
+    readonly generatedKey: boolean;
+    readonly auditUpdated?: string | undefined;
+    constructor(name: string, table: string, columns: readonly string[], parameters: readonly RoutineParameter[], key: string, keyType: string, writable: readonly string[], byProperties?: readonly string[], generatedKey?: boolean, auditUpdated?: string | undefined);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateReadStoredProcedureStatement.js

@@ -0,0 +1,25 @@
+export class CreateReadStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    parameters;
+    key;
+    keyType;
+    writable;
+    byProperties;
+    generatedKey;
+    auditUpdated;
+    constructor(name, table, columns, parameters, key, keyType, writable, byProperties = [], generatedKey = false, auditUpdated) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.parameters = parameters;
+        this.key = key;
+        this.keyType = keyType;
+        this.writable = writable;
+        this.byProperties = byProperties;
+        this.generatedKey = generatedKey;
+        this.auditUpdated = auditUpdated;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateReadStoredProcedureStatementTextRenderer.d.ts

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

package/dist/statements/CreateReadStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateReadStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/CreateRoutineStatement.d.ts

@@ -0,0 +1,22 @@
+import type { ICreateRoutineStatement } from "./ICreateRoutineStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export type RoutineKind = "create" | "findOne" | "findAll" | "findBy" | "update" | "delete";
+export type RoutineParameter = {
+    name: string;
+    type: string;
+};
+export declare class CreateRoutineStatement implements ICreateRoutineStatement {
+    readonly name: string;
+    readonly kind: RoutineKind;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly parameters: readonly RoutineParameter[];
+    readonly key: string;
+    readonly keyType: string;
+    readonly writable: readonly string[];
+    readonly byField?: string | undefined;
+    readonly generatedKey: boolean;
+    readonly auditUpdated?: string | undefined;
+    constructor(name: string, kind: RoutineKind, table: string, columns: readonly string[], parameters: readonly RoutineParameter[], key: string, keyType: string, writable: readonly string[], byField?: string | undefined, generatedKey?: boolean, auditUpdated?: string | undefined);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateRoutineStatementTextRenderer.d.ts

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

package/dist/statements/CreateTableStatement.d.ts

@@ -0,0 +1,11 @@
+import type { Column } from "./Column.js";
+import type { ICreateTableStatement } from "./ICreateTableStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class CreateTableStatement implements ICreateTableStatement {
+    readonly table: string;
+    readonly columns: Column[];
+    readonly constraints: ITableConstraint[];
+    constructor(table: string, columns: Column[], constraints?: ITableConstraint[]);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateTableStatement.js

@@ -0,0 +1,11 @@
+export class CreateTableStatement {
+    table;
+    columns;
+    constraints;
+    constructor(table, columns, constraints = []) {
+        this.table = table;
+        this.columns = columns;
+        this.constraints = constraints;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateTableStatementTextRenderer.d.ts

@@ -0,0 +1,18 @@
+import type { Column } from "./Column.js";
+import type { CreateTableStatement } from "./CreateTableStatement.js";
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class CreateTableStatementTextRenderer {
+    render(statement: CreateTableStatement): string;
+    protected quote(name: string): string;
+    protected suffix(): string;
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
+    protected identity(_column: Column): string;
+    protected column(column: Column): string;
+    protected constraint(constraint: ITableConstraint): string;
+    private parts;
+    private notNullSql;
+    private foreignKey;
+    private quoted;
+    private actionSql;
+}

package/dist/statements/CreateTableStatementTextRenderer.js

@@ -0,0 +1,65 @@
+const actionKeyword = {
+    cascade: "CASCADE",
+    setNull: "SET NULL",
+    setDefault: "SET DEFAULT",
+    restrict: "RESTRICT",
+    noAction: "NO ACTION",
+};
+export class CreateTableStatementTextRenderer {
+    render(statement) {
+        return `CREATE TABLE ${this.quote(statement.table)} (${this.parts(statement).join(", ")})${this.suffix()}`;
+    }
+    quote(name) {
+        return name;
+    }
+    suffix() {
+        return "";
+    }
+    typeName(column) {
+        return column.type;
+    }
+    columnDefault(column) {
+        return column.default == null
+            ? ""
+            : column.default.name == null
+                ? ` DEFAULT ${column.default.value}`
+                : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${column.default.value}`;
+    }
+    identity(_column) {
+        return "";
+    }
+    column(column) {
+        return `${this.quote(column.name)} ${this.typeName(column)}${this.identity(column)}${this.columnDefault(column)}${this.notNullSql(column.notNull)}`;
+    }
+    constraint(constraint) {
+        return {
+            primaryKey: (item) => `CONSTRAINT ${this.quote(item.name)} PRIMARY KEY (${this.quoted(item.columns)})`,
+            foreignKey: (item) => this.foreignKey(item),
+            unique: (item) => `CONSTRAINT ${this.quote(item.name)} UNIQUE (${this.quoted(item.columns)})`,
+            check: (item) => `CONSTRAINT ${this.quote(item.name)} CHECK (${item.expression})`,
+        }[constraint.kind]?.(constraint) ??
+            (() => {
+                throw new Error("empty constraint");
+            })();
+    }
+    parts(statement) {
+        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)),
+            ];
+    }
+    notNullSql(value) {
+        return value == null ? "" : value.name == null ? " NOT NULL" : ` CONSTRAINT ${this.quote(value.name)} NOT NULL`;
+    }
+    foreignKey(fk) {
+        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)}`;
+    }
+    quoted(names) {
+        return names.map((name) => this.quote(name)).join(", ");
+    }
+    actionSql(kind, action) {
+        return action == null ? "" : ` ON ${kind} ${actionKeyword[action]}`;
+    }
+}

package/dist/statements/CreateTriggerStatement.d.ts

@@ -0,0 +1,11 @@
+import type { ICreateTriggerStatement } from "./ICreateTriggerStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class CreateTriggerStatement implements ICreateTriggerStatement {
+    readonly table: string;
+    readonly name: string;
+    readonly updatedColumn: string;
+    readonly keyColumn: string;
+    readonly utcNow: string;
+    constructor(table: string, name: string, updatedColumn: string, keyColumn: string, utcNow: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateTriggerStatement.js

@@ -0,0 +1,15 @@
+export class CreateTriggerStatement {
+    table;
+    name;
+    updatedColumn;
+    keyColumn;
+    utcNow;
+    constructor(table, name, updatedColumn, keyColumn, utcNow) {
+        this.table = table;
+        this.name = name;
+        this.updatedColumn = updatedColumn;
+        this.keyColumn = keyColumn;
+        this.utcNow = utcNow;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateTriggerStatementTextRenderer.d.ts

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

package/dist/statements/CreateTriggerStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateTriggerStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/CreateUpdateStoredProcedureStatement.d.ts

@@ -0,0 +1,17 @@
+import type { ICreateUpdateStoredProcedureStatement } from "./ICreateUpdateStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateUpdateStoredProcedureStatement implements ICreateUpdateStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly parameters: readonly RoutineParameter[];
+    readonly key: string;
+    readonly keyType: string;
+    readonly writable: readonly string[];
+    readonly byProperties: readonly string[];
+    readonly generatedKey: boolean;
+    readonly auditUpdated?: string | undefined;
+    constructor(name: string, table: string, columns: readonly string[], parameters: readonly RoutineParameter[], key: string, keyType: string, writable: readonly string[], byProperties?: readonly string[], generatedKey?: boolean, auditUpdated?: string | undefined);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateUpdateStoredProcedureStatement.js

@@ -0,0 +1,25 @@
+export class CreateUpdateStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    parameters;
+    key;
+    keyType;
+    writable;
+    byProperties;
+    generatedKey;
+    auditUpdated;
+    constructor(name, table, columns, parameters, key, keyType, writable, byProperties = [], generatedKey = false, auditUpdated) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.parameters = parameters;
+        this.key = key;
+        this.keyType = keyType;
+        this.writable = writable;
+        this.byProperties = byProperties;
+        this.generatedKey = generatedKey;
+        this.auditUpdated = auditUpdated;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateUpdateStoredProcedureStatementTextRenderer.d.ts

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

package/dist/statements/CreateUpdateStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateUpdateStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/DefaultStatementTextRenderer.d.ts

@@ -0,0 +1,5 @@
+import { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class DefaultStatementTextRenderer extends StatementTextRenderer {
+    static readonly instance: DefaultStatementTextRenderer;
+    constructor();
+}

package/dist/statements/DefaultStatementTextRenderer.js

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

package/dist/statements/DeleteStatement.d.ts

@@ -0,0 +1,9 @@
+import type { IDeleteStatement } from "./IDeleteStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { IWhere } from "./IWhere.js";
+export declare class DeleteStatement implements IDeleteStatement {
+    readonly table: string;
+    readonly where?: IWhere;
+    constructor(table: string, where?: IWhere);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/DeleteStatement.js

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

package/dist/statements/DeleteStatementTextRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { DeleteStatement } from "./DeleteStatement.js";
+import type { StatementTextRenderer } from "./StatementTextRenderer.js";
+export declare class DeleteStatementTextRenderer {
+    private readonly text;
+    constructor(text: StatementTextRenderer);
+    render(statement: DeleteStatement): string;
+}

package/dist/statements/DeleteStatementTextRenderer.js

@@ -0,0 +1,11 @@
+export class DeleteStatementTextRenderer {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    render(statement) {
+        return statement.where
+            ? `DELETE FROM ${statement.table} WHERE ${this.text.render(statement.where)}`
+            : `DELETE FROM ${statement.table}`;
+    }
+}

package/dist/statements/DropIndexStatement.d.ts

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

package/dist/statements/DropIndexStatement.js

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

package/dist/statements/DropIndexStatementTextRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { DropIndexStatement } from "./DropIndexStatement.js";
+export declare class DropIndexStatementTextRenderer {
+    render(statement: DropIndexStatement): string;
+    protected quote(name: string): string;
+}

package/dist/statements/DropIndexStatementTextRenderer.js

@@ -0,0 +1,8 @@
+export class DropIndexStatementTextRenderer {
+    render(statement) {
+        return `DROP INDEX IF EXISTS ${this.quote(statement.name)}`;
+    }
+    quote(name) {
+        return name;
+    }
+}

package/dist/statements/DropRoutineStatement.d.ts

@@ -0,0 +1,7 @@
+import type { IDropRoutineStatement } from "./IDropRoutineStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class DropRoutineStatement implements IDropRoutineStatement {
+    readonly name: string;
+    constructor(name: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/DropRoutineStatement.js

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

package/dist/statements/DropRoutineStatementTextRenderer.d.ts

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

package/dist/statements/DropRoutineStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class DropRoutineStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/DropTableStatement.d.ts

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

package/dist/statements/DropTableStatement.js

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

package/dist/statements/DropTableStatementTextRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { DropTableStatement } from "./DropTableStatement.js";
+export declare class DropTableStatementTextRenderer {
+    render(statement: DropTableStatement): string;
+    protected quote(name: string): string;
+}

package/dist/statements/DropTableStatementTextRenderer.js

@@ -0,0 +1,8 @@
+export class DropTableStatementTextRenderer {
+    render(statement) {
+        return `DROP TABLE IF EXISTS ${this.quote(statement.table)}`;
+    }
+    quote(name) {
+        return name;
+    }
+}

package/dist/statements/DropTriggerStatement.d.ts

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

package/dist/statements/DropTriggerStatement.js

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

package/dist/statements/DropTriggerStatementTextRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { DropTriggerStatement } from "./DropTriggerStatement.js";
+export declare class DropTriggerStatementTextRenderer {
+    render(statement: DropTriggerStatement): string;
+    protected quote(name: string): string;
+}

package/dist/statements/DropTriggerStatementTextRenderer.js

@@ -0,0 +1,8 @@
+export class DropTriggerStatementTextRenderer {
+    render(statement) {
+        return `DROP TRIGGER IF EXISTS ${this.quote(statement.name)}`;
+    }
+    quote(name) {
+        return name;
+    }
+}

package/dist/statements/ExecuteStoredProcedureStatement.d.ts

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

package/dist/statements/ExecuteStoredProcedureStatement.js

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

package/dist/statements/ExecuteStoredProcedureStatementTextRenderer.d.ts

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

package/dist/statements/ExecuteStoredProcedureStatementTextRenderer.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 ExecuteStoredProcedureStatementTextRenderer {
+    render(statement) {
+        return `CALL ${statement.name}(${args(statement.parameters)})`;
+    }
+}

package/dist/statements/ExpressionEvaluator.d.ts

@@ -0,0 +1,5 @@
+import type { Scalar } from "../builders/Scalar.js";
+import type { IExpression } from "./IExpression.js";
+export declare class ExpressionEvaluator {
+    evaluate: (expression: IExpression, parameters?: Record<string, Scalar>) => Scalar;
+}