@deterministic-code/datasources 0.1.1 → 0.1.3

package/dist/mocks/mock-repository.js

@@ -0,0 +1,61 @@
+import { ReadonlyRepository, untyped } from "../ReadonlyRepository.js";
+export class MockRepository extends ReadonlyRepository {
+    ids = [];
+    items = [];
+    readSingleCalls = [];
+    readCalls = [];
+    addCalls = [];
+    updateCalls = [];
+    deleteCalls = [];
+    readSingleError;
+    readError;
+    addError;
+    updateError;
+    deleteError;
+    addResponse = { result: undefined, rowsAffected: 1 };
+    updateResponse = { result: undefined, rowsAffected: 1 };
+    deleteResponse = { result: undefined, rowsAffected: 1 };
+    constructor(_connection, type = untyped()) {
+        super(type);
+    }
+    async readSingle(query, _parameters, _options) {
+        this.readSingleCalls.push(query);
+        if (this.readSingleError) {
+            throw this.readSingleError;
+        }
+        return this.items[0];
+    }
+    async *read(query, _parameters, _options) {
+        this.readCalls.push(query);
+        if (this.readError) {
+            throw this.readError;
+        }
+        for (const item of this.items) {
+            yield item;
+        }
+    }
+    async create(item) {
+        this.addCalls.push(item);
+        if (this.addError) {
+            throw this.addError;
+        }
+        this.items.push(item);
+        this.addResponse = { result: item, rowsAffected: 1 };
+        return item;
+    }
+    async update(item, byWhere) {
+        this.updateCalls.push({ item, byWhere });
+        if (this.updateError) {
+            throw this.updateError;
+        }
+        return this.updateResponse;
+    }
+    async delete(item, byWhere) {
+        this.deleteCalls.push({ item, byWhere });
+        if (this.deleteError) {
+            throw this.deleteError;
+        }
+        return this.deleteResponse;
+    }
+    readSingleById = (_id) => this.readSingle();
+}

package/dist/mocks/mock-select-statement.js

@@ -0,0 +1,13 @@
+export class MockSelectStatement {
+    text;
+    where;
+    acceptCalls = 0;
+    constructor(text, where) {
+        this.text = text;
+        this.where = where;
+    }
+    accept(_visitor) {
+        this.acceptCalls += 1;
+        return this.text;
+    }
+}

package/dist/mocks/mock-transaction.js

@@ -0,0 +1,28 @@
+import { IsolationLevel } from "../IsolationLevel.js";
+export class MockTransaction {
+    connection;
+    commitCalls = 0;
+    abortCalls = 0;
+    commitError;
+    abortError;
+    committed = false;
+    aborted = false;
+    isolation = IsolationLevel.ReadCommitted;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    async commit() {
+        this.commitCalls += 1;
+        if (this.commitError) {
+            throw this.commitError;
+        }
+        this.committed = true;
+    }
+    async abort() {
+        this.abortCalls += 1;
+        if (this.abortError) {
+            throw this.abortError;
+        }
+        this.aborted = true;
+    }
+}

package/dist/mocks/mock-where.js

@@ -0,0 +1,11 @@
+export class MockWhere {
+    text;
+    acceptCalls = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    accept(_visitor) {
+        this.acceptCalls += 1;
+        return this.text;
+    }
+}

package/dist/parametersToRecord.js

@@ -0,0 +1,9 @@
+export function parametersToRecord(parameters) {
+    if (!parameters)
+        return {};
+    const record = {};
+    for (const parameter of parameters)
+        if (parameter.value !== undefined)
+            record[parameter.name] = parameter.value;
+    return record;
+}

package/dist/readerToAsyncIterable.js

@@ -0,0 +1,7 @@
+export async function* readerToAsyncIterable(reader) {
+    while (await reader.next()) {
+        if (reader.current !== undefined) {
+            yield reader.current;
+        }
+    }
+}

package/dist/splitStatements.js

@@ -0,0 +1,106 @@
+const quoteOf = (char) => char === "'" || char === "\"" || char === "`" ? char : undefined;
+const word = (sql, i, token) => {
+    if (!sql.startsWith(token, i))
+        return false;
+    const before = i === 0 || !/[0-9A-Za-z_]/.test(sql[i - 1]);
+    const after = i + token.length === sql.length || !/[0-9A-Za-z_]/.test(sql[i + token.length]);
+    return before && after;
+};
+const dollarTag = (sql, i) => {
+    if (sql[i] !== "$")
+        return undefined;
+    let end = i + 1;
+    while (end < sql.length && /[0-9A-Za-z_]/.test(sql[end]))
+        end += 1;
+    return sql[end] === "$" ? sql.slice(i, end + 1) : undefined;
+};
+const routine = (sql, start, i) => {
+    const head = sql.slice(start, i).toUpperCase();
+    return (head.includes("CREATE PROCEDURE") ||
+        head.includes("CREATE FUNCTION") ||
+        head.includes("CREATE TRIGGER"));
+};
+export const splitStatements = (sql) => {
+    const parts = [];
+    let start = 0;
+    let quote;
+    let dollar;
+    let line = false;
+    let block = false;
+    let depth = 0;
+    for (let i = 0; i < sql.length; i++) {
+        const char = sql.charAt(i);
+        const next = sql.charAt(i + 1);
+        if (line) {
+            if (char === "\n")
+                line = false;
+            continue;
+        }
+        if (block) {
+            if (char === "*" && next === "/") {
+                block = false;
+                i += 1;
+            }
+            continue;
+        }
+        if (dollar) {
+            if (sql.startsWith(dollar, i)) {
+                i += dollar.length - 1;
+                dollar = undefined;
+            }
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                if (next === quote)
+                    i += 1;
+                else
+                    quote = undefined;
+            }
+            continue;
+        }
+        if (char === "-" && next === "-") {
+            line = true;
+            i += 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            block = true;
+            i += 1;
+            continue;
+        }
+        const tag = dollarTag(sql, i);
+        if (tag) {
+            dollar = tag;
+            i += tag.length - 1;
+            continue;
+        }
+        const opened = quoteOf(char);
+        if (opened) {
+            quote = opened;
+            continue;
+        }
+        if (word(sql, i, "BEGIN") && routine(sql, start, i)) {
+            depth += 1;
+            i += 4;
+            continue;
+        }
+        if (char === ";") {
+            if (depth > 0 && routine(sql, start, i)) {
+                if (/\bEND$/i.test(sql.slice(start, i).trimEnd()))
+                    depth -= 1;
+                if (depth > 0)
+                    continue;
+            }
+            const part = sql.slice(start, i).trim();
+            if (part)
+                parts.push(part);
+            start = i + 1;
+            depth = 0;
+        }
+    }
+    const tail = sql.slice(start).trim();
+    if (tail)
+        parts.push(tail);
+    return parts;
+};

package/dist/statementParameters.js

@@ -0,0 +1,25 @@
+export const statementParameters = (sql) => {
+    const names = [];
+    const seen = new Set();
+    for (let i = 0; i < sql.length; i++) {
+        const char = sql[i];
+        if (char !== "$" && char !== ":" && char !== "@")
+            continue;
+        let end = i + 1;
+        while (end < sql.length && /[0-9A-Za-z_]/.test(sql[end]))
+            end += 1;
+        if (end === i + 1)
+            continue;
+        if (char === "$" && sql[end] === "$") {
+            i = end;
+            continue;
+        }
+        const name = sql.slice(i + 1, end);
+        if (!seen.has(name)) {
+            seen.add(name);
+            names.push(name);
+        }
+        i = end - 1;
+    }
+    return names;
+};

package/dist/statementUsesParameter.js

@@ -0,0 +1,2 @@
+import { statementParameters } from "./statementParameters.js";
+export const statementUsesParameter = (sql, name) => statementParameters(sql).includes(name.replace(/^[$:@]/, ""));

package/dist/statements/Aggregate.js

@@ -0,0 +1,7 @@
+const fragment = (op, column, alias) => alias === undefined ? `${op}(${column})` : `${op}(${column}) AS ${alias}`;
+export const Aggregate = {
+    count: (column, alias) => fragment("COUNT", column, alias),
+    sum: (column, alias) => fragment("SUM", column, alias),
+    min: (column, alias) => fragment("MIN", column, alias),
+    max: (column, alias) => fragment("MAX", column, alias),
+};

package/dist/statements/AlterTableStatement.d.ts

@@ -0,0 +1,33 @@
+import type { Column } from "./Column.js";
+import type { IAlterTableStatement } from "./IAlterTableStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { ITableConstraint } from "./ITableConstraint.js";
+export type AlterAction = {
+    kind: "addColumn";
+    column: Column;
+} | {
+    kind: "dropColumn";
+    name: string;
+} | {
+    kind: "alterColumn";
+    column: Column;
+} | {
+    kind: "renameColumn";
+    from: string;
+    to: string;
+} | {
+    kind: "renameTable";
+    to: string;
+} | {
+    kind: "addConstraint";
+    constraint: ITableConstraint;
+} | {
+    kind: "dropConstraint";
+    name: string;
+};
+export declare class AlterTableStatement implements IAlterTableStatement {
+    readonly table: string;
+    readonly action: AlterAction;
+    constructor(table: string, action: AlterAction);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/AlterTableStatement.js

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

package/dist/statements/AlterTableStatementTextRenderer.d.ts

@@ -0,0 +1,9 @@
+import type { AlterAction, AlterTableStatement } from "./AlterTableStatement.js";
+import type { Column } from "./Column.js";
+import { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+export declare class AlterTableStatementTextRenderer extends CreateTableStatementTextRenderer {
+    renderAlter(statement: AlterTableStatement): string;
+    protected actionSql(action: AlterAction): string;
+    protected alterColumn(column: Column): string;
+    protected notNullClause(column: Column): string;
+}

package/dist/statements/AlterTableStatementTextRenderer.js

@@ -0,0 +1,33 @@
+import { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+export class AlterTableStatementTextRenderer extends CreateTableStatementTextRenderer {
+    renderAlter(statement) {
+        return `ALTER TABLE ${this.quote(statement.table)} ${this.actionSql(statement.action)}`;
+    }
+    actionSql(action) {
+        return ({
+            addColumn: (item) => `ADD COLUMN ${this.column(item.column)}`,
+            dropColumn: (item) => `DROP COLUMN ${this.quote(item.name)}`,
+            alterColumn: (item) => this.alterColumn(item.column),
+            renameColumn: (item) => {
+                const rename = item;
+                return `RENAME COLUMN ${this.quote(rename.from)} TO ${this.quote(rename.to)}`;
+            },
+            renameTable: (item) => `RENAME TO ${this.quote(item.to)}`,
+            addConstraint: (item) => `ADD ${this.constraint(item.constraint)}`,
+            dropConstraint: (item) => `DROP CONSTRAINT ${this.quote(item.name)}`,
+        }[action.kind] ??
+            (() => {
+                throw new Error("empty alter");
+            }))(action);
+    }
+    alterColumn(column) {
+        return `ALTER COLUMN ${this.quote(column.name)} TYPE ${this.typeName(column)}${this.columnDefault(column)}${this.notNullClause(column)}`;
+    }
+    notNullClause(column) {
+        return column.notNull == null
+            ? ""
+            : column.notNull.name == null
+                ? " NOT NULL"
+                : ` CONSTRAINT ${this.quote(column.notNull.name)} NOT NULL`;
+    }
+}

package/dist/statements/ArrayExpression.js

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

package/dist/statements/BulkDeleteStatement.js

@@ -0,0 +1,15 @@
+import { flattenBulkParameters } from "./BulkInsertStatement.js";
+export class BulkDeleteStatement {
+    table;
+    ids;
+    rows;
+    constructor(table, ids, rows) {
+        this.table = table;
+        this.ids = ids;
+        this.rows = rows;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return flattenBulkParameters(this.ids, this.rows);
+    }
+}

package/dist/statements/BulkDeleteStatementTextRenderer.js

@@ -0,0 +1,15 @@
+export class BulkDeleteStatementTextRenderer {
+    render = (statement) => {
+        if (statement.ids.length === 0)
+            return `DELETE FROM ${statement.table} WHERE 1 = 1`;
+        if (statement.ids.length === 1) {
+            const column = statement.ids[0];
+            const names = statement.rows.map((_, index) => `$${column}__${index}`).join(", ");
+            return `DELETE FROM ${statement.table} WHERE ${column} IN (${names})`;
+        }
+        const tuples = statement.rows
+            .map((_, index) => `(${statement.ids.map((column) => `$${column}__${index}`).join(", ")})`)
+            .join(", ");
+        return `DELETE FROM ${statement.table} WHERE (${statement.ids.join(", ")}) IN (${tuples})`;
+    };
+}

package/dist/statements/BulkInsertStatement.js

@@ -0,0 +1,29 @@
+const lookup = (fields) => {
+    const map = new Map();
+    for (const field of fields)
+        map.set(field.name, (field.value ?? null));
+    return map;
+};
+export const flattenBulkParameters = (columns, rows) => {
+    const parameters = [];
+    rows.forEach((row, index) => {
+        const byName = lookup(row);
+        for (const column of columns)
+            parameters.push({ name: `${column}__${index}`, value: (byName.get(column) ?? null) });
+    });
+    return parameters;
+};
+export class BulkInsertStatement {
+    table;
+    columns;
+    rows;
+    constructor(table, columns, rows) {
+        this.table = table;
+        this.columns = columns;
+        this.rows = rows;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return flattenBulkParameters(this.columns, this.rows);
+    }
+}

package/dist/statements/BulkInsertStatementTextRenderer.js

@@ -0,0 +1,6 @@
+export class BulkInsertStatementTextRenderer {
+    render = (statement) => {
+        const values = statement.rows.map((_, index) => `(${statement.columns.map((column) => `$${column}__${index}`).join(", ")})`);
+        return `INSERT INTO ${statement.table} (${statement.columns.join(", ")}) VALUES ${values.join(", ")}`;
+    };
+}

package/dist/statements/BulkUpdateStatement.js

@@ -0,0 +1,17 @@
+import { flattenBulkParameters } from "./BulkInsertStatement.js";
+export class BulkUpdateStatement {
+    table;
+    set;
+    ids;
+    rows;
+    constructor(table, set, ids, rows) {
+        this.table = table;
+        this.set = set;
+        this.ids = ids;
+        this.rows = rows;
+    }
+    accept = (visitor) => visitor.visit(this);
+    get parameters() {
+        return flattenBulkParameters([...this.set, ...this.ids], this.rows.map((row) => [...row.fields, ...row.ids]));
+    }
+}

package/dist/statements/BulkUpdateStatementTextRenderer.js

@@ -0,0 +1,20 @@
+export class BulkUpdateStatementTextRenderer {
+    render = (statement) => {
+        const assigns = statement.set.map((column) => `${column} = data.${column}`).join(", ");
+        return `UPDATE ${statement.table} SET ${assigns} FROM ${this.source(statement)} WHERE ${this.on(statement)}`;
+    };
+    on = (statement) => statement.ids.map((column) => `${statement.table}.${column} = data.${column}`).join(" AND ");
+    source = (statement) => {
+        const columns = [...statement.set, ...statement.ids];
+        const selects = statement.rows.map((row, index) => {
+            const byName = new Map();
+            for (const field of [...row.fields, ...row.ids])
+                byName.set(field.name, (field.value ?? null));
+            return `SELECT ${columns
+                .map((column) => this.cell(column, index, byName.get(column) ?? null))
+                .join(", ")}`;
+        });
+        return `(${selects.join(" UNION ALL ")}) AS data`;
+    };
+    cell = (column, index, _value) => `$${column}__${index} AS ${column}`;
+}

package/dist/statements/CheckConstraint.js

@@ -0,0 +1,9 @@
+export class CheckConstraint {
+    name;
+    expression;
+    kind = "check";
+    constructor(name, expression) {
+        this.name = name;
+        this.expression = expression;
+    }
+}

package/dist/statements/Cmp.js

@@ -0,0 +1,7 @@
+import { Operator } from "./Operator.js";
+export const eq = (column, value) => new Operator.Equals(column, value);
+export const ne = (column, value) => new Operator.NotEquals(column, value);
+export const gt = (column, value) => new Operator.GreaterThan(column, value);
+export const lt = (column, value) => new Operator.LessThan(column, value);
+export const ge = (column, value) => new Operator.GreaterThanOrEqual(column, value);
+export const le = (column, value) => new Operator.LessThanOrEqual(column, value);

package/dist/statements/Column.js

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

package/dist/statements/ColumnDefault.js

@@ -0,0 +1,8 @@
+export class ColumnDefault {
+    value;
+    name;
+    constructor(value, name) {
+        this.value = value;
+        this.name = name;
+    }
+}

package/dist/statements/Condition.js

@@ -0,0 +1,2 @@
+export class Condition {
+}

package/dist/statements/ConditionRenderer.js

@@ -0,0 +1,11 @@
+import { Where } from "./Where.js";
+export class ConditionRenderer {
+    expressions;
+    constructor(expressions) {
+        this.expressions = expressions;
+    }
+    render = (condition) => condition.accept(this);
+    visit(where) {
+        return where instanceof Where ? this.expressions.render(where.condition) : where.rawText;
+    }
+}

package/dist/statements/CreateBulkCreateStoredProcedureStatement.d.ts

@@ -0,0 +1,13 @@
+import type { ICreateBulkCreateStoredProcedureStatement } from "./ICreateBulkCreateStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateBulkCreateStoredProcedureStatement implements ICreateBulkCreateStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly RoutineParameter[];
+    readonly payload: RoutineParameter;
+    readonly key: string;
+    readonly keyType: string;
+    constructor(name: string, table: string, columns: readonly RoutineParameter[], payload: RoutineParameter, key: string, keyType: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateBulkCreateStoredProcedureStatement.js

@@ -0,0 +1,17 @@
+export class CreateBulkCreateStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    payload;
+    key;
+    keyType;
+    constructor(name, table, columns, payload, key, keyType) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.payload = payload;
+        this.key = key;
+        this.keyType = keyType;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateBulkCreateStoredProcedureStatementTextRenderer.d.ts

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

package/dist/statements/CreateBulkCreateStoredProcedureStatementTextRenderer.js

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

package/dist/statements/CreateBulkDeleteStoredProcedureStatement.d.ts

@@ -0,0 +1,13 @@
+import type { ICreateBulkDeleteStoredProcedureStatement } from "./ICreateBulkDeleteStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateBulkDeleteStoredProcedureStatement implements ICreateBulkDeleteStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly RoutineParameter[];
+    readonly payload: RoutineParameter;
+    readonly key: string;
+    readonly keyType: string;
+    constructor(name: string, table: string, columns: readonly RoutineParameter[], payload: RoutineParameter, key: string, keyType: string);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateBulkDeleteStoredProcedureStatement.js

@@ -0,0 +1,17 @@
+export class CreateBulkDeleteStoredProcedureStatement {
+    name;
+    table;
+    columns;
+    payload;
+    key;
+    keyType;
+    constructor(name, table, columns, payload, key, keyType) {
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+        this.payload = payload;
+        this.key = key;
+        this.keyType = keyType;
+    }
+    accept = (visitor) => visitor.visit(this);
+}

package/dist/statements/CreateBulkDeleteStoredProcedureStatementTextRenderer.d.ts

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

package/dist/statements/CreateBulkDeleteStoredProcedureStatementTextRenderer.js

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

package/dist/statements/CreateBulkUpdateStoredProcedureStatement.d.ts

@@ -0,0 +1,13 @@
+import type { ICreateBulkUpdateStoredProcedureStatement } from "./ICreateBulkUpdateStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { RoutineParameter } from "./RoutineParameter.js";
+export declare class CreateBulkUpdateStoredProcedureStatement implements ICreateBulkUpdateStoredProcedureStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly RoutineParameter[];
+    readonly payload: RoutineParameter;
+    readonly key: string;
+    readonly keyType: string;
+    constructor(name: string, table: string, columns: readonly RoutineParameter[], payload: RoutineParameter, key: string, keyType: string);
+    accept: (visitor: IStatementVisitor) => string;
+}