@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/mocks/mock-connection.js

@@ -0,0 +1,48 @@
+import { DatasourceError } from "../DatasourceError.js";
+import { IsolationLevel } from "../IsolationLevel.js";
+import { MockCommand } from "./mock-command.js";
+import { MockTransaction } from "./mock-transaction.js";
+export class MockConnection {
+    provider;
+    openCalls = 0;
+    closeCalls = 0;
+    startTransactionCalls = 0;
+    openError;
+    closeError;
+    startTransactionError;
+    transaction;
+    command;
+    isOpen = false;
+    constructor(transaction, provider = "mock") {
+        this.provider = provider;
+        this.transaction = transaction ?? new MockTransaction(this);
+    }
+    createCommand = () => this.command ?? new MockCommand(this);
+    async open() {
+        if (this.isOpen)
+            throw new DatasourceError("Connection is already open");
+        this.openCalls += 1;
+        if (this.openError) {
+            throw this.openError;
+        }
+        this.isOpen = true;
+    }
+    async close() {
+        this.closeCalls += 1;
+        if (this.closeError) {
+            throw this.closeError;
+        }
+        this.isOpen = false;
+    }
+    [Symbol.asyncDispose] = () => this.close();
+    async startTransaction(isolation = IsolationLevel.Serializable) {
+        this.startTransactionCalls += 1;
+        if (this.startTransactionError) {
+            throw this.startTransactionError;
+        }
+        if (this.transaction instanceof MockTransaction) {
+            this.transaction.isolation = isolation;
+        }
+        return this.transaction;
+    }
+}

package/dist/mocks/mock-datasource.d.ts

@@ -0,0 +1,24 @@
+import type { Constructable } from "../converters/Constructable.js";
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { IDatasource } from "../IDatasource.js";
+import type { IReadonlyRepository } from "../IReadonlyRepository.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { RepositoryFactory } from "../RepositoryFactory.js";
+export declare class MockDatasource implements IDatasource {
+    readonly provider: string;
+    createConnectionCalls: number;
+    createCommandCalls: Array<IConnection | undefined>;
+    createRepositoryCalls: Array<IConnection | undefined>;
+    connection: IConnection;
+    command?: ICommand;
+    repository?: ICRUDRepository;
+    readonly repositories: RepositoryFactory;
+    constructor(provider?: string);
+    createConnection(): Promise<IConnection>;
+    createCommand(connection?: IConnection): Promise<ICommand>;
+    createRepository<T>(type: Constructable<T>, connection?: IConnection): ICRUDRepository<T>;
+    createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+    createReadonlyRepository<T>(type: Constructable<T>, connection?: IConnection): IReadonlyRepository<T>;
+    createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+}

package/dist/mocks/mock-datasource.js

@@ -0,0 +1,44 @@
+import { DatasourceError } from "../DatasourceError.js";
+import { RepositoryFactory } from "../RepositoryFactory.js";
+import { MockCommand } from "./mock-command.js";
+import { MockConnection } from "./mock-connection.js";
+import { MockRepository } from "./mock-repository.js";
+export class MockDatasource {
+    provider;
+    createConnectionCalls = 0;
+    createCommandCalls = [];
+    createRepositoryCalls = [];
+    connection;
+    command;
+    repository;
+    repositories = new RepositoryFactory();
+    constructor(provider = "mock") {
+        this.provider = provider;
+        this.connection = new MockConnection();
+    }
+    createConnection() {
+        this.createConnectionCalls += 1;
+        return Promise.resolve(this.connection);
+    }
+    async createCommand(connection) {
+        this.createCommandCalls.push(connection);
+        if (connection === undefined) {
+            if (this.connection.isOpen)
+                throw new DatasourceError("Connection is already open");
+            await this.connection.open();
+        }
+        return this.command ?? new MockCommand(connection ?? this.connection);
+    }
+    createRepository(typeOrName, connection) {
+        this.createRepositoryCalls.push(connection);
+        if (typeof typeOrName === "string")
+            return this.repositories.create(typeOrName, connection ?? this.connection);
+        return this.repository ??
+            new MockRepository(connection ?? this.connection, typeOrName);
+    }
+    createReadonlyRepository(typeOrName, connection) {
+        if (typeof typeOrName === "string")
+            return this.repositories.createReadonly(typeOrName, connection ?? this.connection);
+        return this.createRepository(typeOrName, connection);
+    }
+}

package/dist/mocks/mock-driver.d.ts

@@ -0,0 +1,15 @@
+import type { DatasourceOptions } from "../DatasourceOptions.js";
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { IDriver } from "../IDriver.js";
+import type { ITransaction } from "../ITransaction.js";
+import type { IsolationLevel } from "../IsolationLevel.js";
+import type { Cell } from "../converters/Cell.js";
+import type { TypeConverter } from "../converters/TypeConverter.js";
+export declare class MockDriver implements IDriver {
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    columnType: (name: string) => string;
+    connection: (_options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/mocks/mock-driver.js

@@ -0,0 +1,15 @@
+import { columnType as identityColumnType } from "../IDriver.js";
+import { MockCommand } from "./mock-command.js";
+import { MockConnection } from "./mock-connection.js";
+import { MockTransaction } from "./mock-transaction.js";
+export class MockDriver {
+    rowTypeConverters = {};
+    columnType = identityColumnType;
+    connection = (_options) => new MockConnection();
+    command = (connection) => new MockCommand(connection);
+    transaction = (connection, isolation = "readCommitted") => {
+        const txn = new MockTransaction(connection);
+        txn.isolation = isolation;
+        return txn;
+    };
+}

package/dist/mocks/mock-reader.d.ts

@@ -0,0 +1,14 @@
+import type { IReader } from "../IReader.js";
+export declare class MockReader<T = unknown> implements IReader<T> {
+    rows: readonly T[];
+    current: T | undefined;
+    nextCalls: number;
+    nextError?: unknown;
+    private index;
+    constructor(rows?: readonly T[]);
+    next(): Promise<boolean>;
+    read(): AsyncIterable<T>;
+    nextResult(): Promise<boolean>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}

package/dist/mocks/mock-reader.js

@@ -0,0 +1,33 @@
+import { readerToAsyncIterable } from "../readerToAsyncIterable.js";
+export class MockReader {
+    rows;
+    current = undefined;
+    nextCalls = 0;
+    nextError;
+    index = -1;
+    constructor(rows = []) {
+        this.rows = rows;
+    }
+    async next() {
+        this.nextCalls += 1;
+        if (this.nextError) {
+            throw this.nextError;
+        }
+        this.index += 1;
+        if (this.index < this.rows.length) {
+            this.current = this.rows[this.index];
+            return true;
+        }
+        this.current = undefined;
+        return false;
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    async nextResult() {
+        this.current = undefined;
+        return false;
+    }
+    async dispose() { }
+    [Symbol.asyncDispose] = () => this.dispose();
+}

package/dist/mocks/mock-repository.d.ts

@@ -0,0 +1,42 @@
+import type { Scalar } from "../builders/Scalar.js";
+import type { Cells } from "../converters/Cell.js";
+import type { Constructable } from "../converters/Constructable.js";
+import type { IConnection } from "../IConnection.js";
+import type { Parameter } from "../Parameter.js";
+import type { IExecuteStoredProcedureStatement } from "../statements/IExecuteStoredProcedureStatement.js";
+import type { ISelectStatement } from "../statements/ISelectStatement.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { ReadonlyRepository } from "../ReadonlyRepository.js";
+import type { ReadonlyRepositoryMappingOptions } from "../ReadonlyRepositoryMappingOptions.js";
+import type { Response } from "../Response.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class MockRepository<T = unknown> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+    readonly ids: readonly string[];
+    items: T[];
+    readSingleCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined>;
+    readCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined>;
+    addCalls: T[];
+    updateCalls: Array<{
+        item: T;
+        byWhere?: IWhere;
+    }>;
+    deleteCalls: Array<{
+        item: T;
+        byWhere?: IWhere;
+    }>;
+    readSingleError?: unknown;
+    readError?: unknown;
+    addError?: unknown;
+    updateError?: unknown;
+    deleteError?: unknown;
+    addResponse: Response;
+    updateResponse: Response;
+    deleteResponse: Response;
+    constructor(_connection: IConnection, type?: Constructable<T>);
+    readSingle(query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement, _parameters?: Parameter[], _options?: ReadonlyRepositoryMappingOptions<T>): Promise<T | undefined>;
+    read(query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement, _parameters?: Parameter[], _options?: ReadonlyRepositoryMappingOptions<T>): AsyncIterable<T>;
+    create(item: T): Promise<T>;
+    update(item: T, byWhere?: IWhere): Promise<Response>;
+    delete(item: T, byWhere?: IWhere): Promise<Response>;
+    readSingleById: (_id: Scalar | Cells) => Promise<T | undefined>;
+}

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

@@ -0,0 +1,10 @@
+import type { ISelectStatement } from "../statements/ISelectStatement.js";
+import type { IStatementVisitor } from "../statements/IStatementVisitor.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class MockSelectStatement implements ISelectStatement {
+    text: string;
+    where?: IWhere | undefined;
+    acceptCalls: number;
+    constructor(text: string, where?: IWhere | undefined);
+    accept(_visitor: IStatementVisitor): string;
+}

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

@@ -0,0 +1,16 @@
+import type { IConnection } from "../IConnection.js";
+import type { ITransaction } from "../ITransaction.js";
+import { IsolationLevel } from "../IsolationLevel.js";
+export declare class MockTransaction implements ITransaction {
+    readonly connection: IConnection;
+    commitCalls: number;
+    abortCalls: number;
+    commitError?: unknown;
+    abortError?: unknown;
+    committed: boolean;
+    aborted: boolean;
+    isolation: IsolationLevel;
+    constructor(connection: IConnection);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { IConditionVisitor } from "../statements/IConditionVisitor.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class MockWhere implements IWhere {
+    text: string;
+    acceptCalls: number;
+    constructor(text: string);
+    accept(_visitor: IConditionVisitor): string;
+}

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

@@ -0,0 +1,2 @@
+import type { Parameter } from "./Parameter.js";
+export declare function parametersToRecord<T>(parameters?: Parameter<T>[] | null): Record<string, T>;

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

@@ -0,0 +1,2 @@
+import type { IReader } from "./IReader.js";
+export declare function readerToAsyncIterable<T>(reader: IReader<T>): AsyncIterable<T>;

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

@@ -0,0 +1 @@
+export declare const splitStatements: (sql: string) => string[];

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

@@ -0,0 +1 @@
+export declare const statementParameters: (sql: string) => string[];

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

@@ -0,0 +1 @@
+export declare const statementUsesParameter: (sql: string, name: string) => boolean;

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

@@ -0,0 +1,6 @@
+export declare const Aggregate: {
+    count: (column: string, alias?: string) => string;
+    sum: (column: string, alias?: string) => string;
+    min: (column: string, alias?: string) => string;
+    max: (column: string, alias?: string) => string;
+};

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;
+}