@deterministic-code/datasources 0.1.1 → 0.1.3

package/dist/DefaultWriteEnrichmentStrategy.js

@@ -0,0 +1,135 @@
+import { CascadeDeleteEnrichmentStrategy } from "./CascadeDeleteEnrichmentStrategy.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.js";
+import { EnrichmentPropertyType } from "./EnrichmentPropertyType.js";
+import { DefaultUpdateEnrichmentStrategy } from "./DefaultUpdateEnrichmentStrategy.js";
+import { enrichmentsOf } from "./ReadonlyRepository.js";
+const unloaded = (parent, into) => {
+    const value = parent[into];
+    return value === undefined || value === null;
+};
+const childWriter = (entry, into) => {
+    if (entry.persist)
+        return entry.persist;
+    throw new DatasourceError(`Deep write requires a CRUD repository for "${into}"`);
+};
+const linkWriter = (entry, into) => {
+    if (entry.link)
+        return entry.link;
+    throw new DatasourceError(`Deep write requires a CRUD repository for "${into}"`);
+};
+const dispatch = (mode, runs) => (runs[mode] ??
+    (() => {
+        throw new DatasourceError("Unknown persist mode");
+    }))();
+export class DefaultWriteEnrichmentStrategy {
+    skipUnloaded = false;
+    useTransaction;
+    createStrategy;
+    deleteStrategy;
+    updateStrategy;
+    constructor(deleteStrategy = new CascadeDeleteEnrichmentStrategy(), updateStrategy = new DefaultUpdateEnrichmentStrategy(), createStrategy = new DefaultCreateEnrichmentStrategy(), useTransaction = false) {
+        this.deleteStrategy = deleteStrategy;
+        this.updateStrategy = updateStrategy;
+        this.createStrategy = createStrategy;
+        this.useTransaction = useTransaction;
+    }
+    persist = async (tree, items, mode) => {
+        await this.walk(tree.parent.value, items, mode);
+    };
+    persistBulk = async (tree, items, mode) => {
+        if (mode === "delete")
+            return this.persist(tree, items, mode);
+        await this.walkBulk(tree.parent.value, items, mode);
+    };
+    walk = async (host, parents, mode) => {
+        const entries = enrichmentsOf(host);
+        if (!entries)
+            return;
+        for (const entry of entries)
+            await this.persistEntry(entry, parents, mode);
+    };
+    walkBulk = async (host, parents, mode) => {
+        const entries = enrichmentsOf(host);
+        if (!entries)
+            return;
+        for (const entry of entries)
+            await this.persistEntryBulk(entry, parents, mode);
+    };
+    persistEntryBulk = async (entry, parents, mode) => {
+        const enrichment = entry.enrichment;
+        const type = enrichment.type ?? EnrichmentPropertyType.Object;
+        if (type === EnrichmentPropertyType.Custom)
+            throw new DatasourceError(`Unsupported enrichment type "${type}"`);
+        if (enrichment.association) {
+            const writer = linkWriter(entry, enrichment.destinationProperty);
+            for (const parent of parents) {
+                if (this.skip(parent, enrichment.destinationProperty, mode))
+                    continue;
+                await dispatch(mode, {
+                    create: () => this.createStrategy.createLinked(writer, enrichment, parent),
+                    update: () => this.updateStrategy.updateLinked(writer, enrichment, parent),
+                    delete: () => this.deleteStrategy.deleteLinked(writer, enrichment, parent),
+                });
+            }
+            return;
+        }
+        if (type === EnrichmentPropertyType.List && enrichment.relatedProperty)
+            return;
+        if (type !== EnrichmentPropertyType.List && type !== EnrichmentPropertyType.Dictionary)
+            return;
+        const writer = childWriter(entry, enrichment.destinationProperty);
+        const ready = parents.filter((parent) => !this.skip(parent, enrichment.destinationProperty, mode));
+        const children = ready.flatMap((parent) => this.createStrategy.collectChildren(writer, enrichment, parent));
+        if (children.length === 0)
+            return;
+        const bulk = writer;
+        if (mode === "create") {
+            if (bulk.createBulk)
+                await bulk.createBulk(children);
+            else
+                for (const child of children)
+                    await writer.create(child);
+            return;
+        }
+        if (bulk.updateBulk)
+            await bulk.updateBulk(children);
+        else
+            for (const child of children)
+                await writer.update(child);
+    };
+    persistEntry = async (entry, parents, mode) => {
+        const enrichment = entry.enrichment;
+        const type = enrichment.type ?? EnrichmentPropertyType.Object;
+        if (type === EnrichmentPropertyType.Custom)
+            throw new DatasourceError(`Unsupported enrichment type "${type}"`);
+        if (enrichment.association) {
+            const writer = linkWriter(entry, enrichment.destinationProperty);
+            for (const parent of parents) {
+                if (this.skip(parent, enrichment.destinationProperty, mode))
+                    continue;
+                await dispatch(mode, {
+                    create: () => this.createStrategy.createLinked(writer, enrichment, parent),
+                    update: () => this.updateStrategy.updateLinked(writer, enrichment, parent),
+                    delete: () => this.deleteStrategy.deleteLinked(writer, enrichment, parent),
+                });
+            }
+            return;
+        }
+        if (type === EnrichmentPropertyType.List && enrichment.relatedProperty)
+            return;
+        if (type !== EnrichmentPropertyType.List && type !== EnrichmentPropertyType.Dictionary)
+            return;
+        const writer = childWriter(entry, enrichment.destinationProperty);
+        for (const parent of parents) {
+            if (this.skip(parent, enrichment.destinationProperty, mode))
+                continue;
+            await dispatch(mode, {
+                create: () => this.createStrategy.createChildren(writer, enrichment, parent),
+                update: () => this.updateStrategy.updateChildren(writer, enrichment, parent),
+                delete: () => this.deleteStrategy.deleteChildren(writer, enrichment, parent, async () => { }),
+            });
+        }
+    };
+    skip = (parent, into, mode) => this.skipUnloaded && mode !== "delete" && unloaded(parent, into);
+}

package/dist/DeleteEnrichmentStrategy.js

@@ -0,0 +1,28 @@
+import { Operator, Where } from "./statements/index.js";
+const get = (item, name) => item[name];
+export class DeleteEnrichmentStrategy {
+    static load = async (writer, enrichment, parent) => {
+        const key = get(parent, enrichment.sourceProperty);
+        if (key === undefined || key === null || typeof key === "object")
+            return [];
+        const items = [];
+        for await (const item of writer.read(new Where(new Operator.Equals(enrichment.relatedKey, key))))
+            items.push(item);
+        return items;
+    };
+    static childrenWhere = (writer, enrichment, parent) => {
+        if (writer.ids.length > 0)
+            return undefined;
+        const key = get(parent, enrichment.sourceProperty);
+        return key === undefined || key === null || typeof key === "object"
+            ? undefined
+            : new Where(new Operator.Equals(enrichment.relatedKey, key));
+    };
+    static loadLinks = async (writer, column, key) => {
+        const items = [];
+        for await (const item of writer.read(new Where(new Operator.Equals(column, key))))
+            items.push(item);
+        return items;
+    };
+}
+;

package/dist/DriverLoader.js

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import { createRequire, registerHooks } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { ProviderNotInstalledError } from "./ProviderNotInstalledError.js";
+const require = createRequire(import.meta.url);
+const appRequire = () => createRequire(join(process.cwd(), "package.json"));
+const virtual = new Map();
+const virtualBySource = new Map();
+let typeScriptHook = false;
+let compiling = false;
+let nextVirtual = 0;
+const installTypeScriptHook = () => {
+    if (typeScriptHook)
+        return;
+    const typescript = require("typescript");
+    /* v8 ignore start */
+    registerHooks({
+        resolve: (specifier, context, nextResolve) => {
+            const parentURL = context.parentURL ? virtual.get(context.parentURL) ?? context.parentURL : undefined;
+            const resolved = nextResolve(specifier, parentURL ? { ...context, parentURL } : context);
+            /* v8 ignore next */
+            if (!compiling || !resolved.url.endsWith(".ts"))
+                return resolved;
+            const existing = virtualBySource.get(resolved.url);
+            /* v8 ignore next */
+            if (existing)
+                return { url: existing, shortCircuit: true };
+            const url = pathToFileURL(`${tmpdir()}/datasources-plugin-${nextVirtual++}.mjs`).href;
+            virtual.set(url, resolved.url);
+            virtualBySource.set(resolved.url, url);
+            return { url, shortCircuit: true };
+        },
+        load: (url, context, nextLoad) => {
+            const original = virtual.get(url) ?? (compiling && url.endsWith(".ts") ? url : undefined);
+            /* v8 ignore next */
+            if (!original)
+                return nextLoad(url, context);
+            const filename = fileURLToPath(original);
+            const source = typescript.transpileModule(readFileSync(filename, "utf8"), {
+                compilerOptions: {
+                    module: typescript.ModuleKind.ESNext,
+                    target: typescript.ScriptTarget.ES2022,
+                },
+                fileName: filename,
+            }).outputText;
+            return { format: "module", source, shortCircuit: true };
+        },
+    });
+    /* v8 ignore stop */
+    typeScriptHook = true;
+};
+const instantiate = (catalog) => {
+    compiling = true;
+    try {
+        return instantiateLoaded(catalog);
+    }
+    finally {
+        compiling = false;
+    }
+};
+const instantiateLoaded = (catalog) => {
+    const loaded = appRequire()(catalog.location);
+    const Type = loaded[catalog.module];
+    if (typeof Type !== "function")
+        throw new ProviderNotInstalledError(catalog.name);
+    return new Type();
+};
+export class DriverLoader {
+    static load = (catalog) => {
+        try {
+            return instantiate(catalog);
+        }
+        catch (error) {
+            if (error instanceof ProviderNotInstalledError)
+                throw error;
+            try {
+                installTypeScriptHook();
+                return instantiate(catalog);
+            }
+            catch {
+                throw new ProviderNotInstalledError(catalog.name);
+            }
+        }
+    };
+}

package/dist/Enrichment.js

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

package/dist/EnrichmentPropertyType.js

@@ -0,0 +1,6 @@
+export const EnrichmentPropertyType = {
+    Object: "object",
+    List: "list",
+    Dictionary: "dictionary",
+    Custom: "custom",
+};

package/dist/ExpectConsoleMiddleware.js

@@ -0,0 +1,30 @@
+import { ConsoleCommandMiddleware } from "./ConsoleCommandMiddleware.js";
+export const consoleSignature = (line) => {
+    const duration = line.lastIndexOf("] ");
+    return duration >= 0 && (line.endsWith("ms") || line.endsWith("μs"))
+        ? line.slice(0, duration + 1)
+        : line;
+};
+export class ExpectConsoleMiddleware {
+    expected;
+    normalize;
+    inner;
+    index = 0;
+    constructor(expected, now, normalize = consoleSignature) {
+        this.expected = expected;
+        this.normalize = normalize;
+        this.inner = new ConsoleCommandMiddleware((line) => this.check(line), now, { isVerbose: "true" });
+    }
+    beforeCommand = (text, params) => this.inner.beforeCommand(text, params);
+    afterCommand = (text, params, results, elapsedMs, error) => this.inner.afterCommand(text, params, results, elapsedMs, error);
+    complete = () => {
+        if (this.index !== this.expected.length)
+            throw new Error(`console mismatch at ${this.index}\nexpected: ${this.expected[this.index]}\nactual:   <missing>`);
+    };
+    check = (line) => {
+        const actual = this.normalize(line);
+        if (this.index >= this.expected.length || actual !== this.expected[this.index])
+            throw new Error(`console mismatch at ${this.index}\nexpected: ${this.index < this.expected.length ? this.expected[this.index] : "<missing>"}\nactual:   ${actual}`);
+        this.index++;
+    };
+}

package/dist/FirstResultReader.js

@@ -0,0 +1,43 @@
+import { readerToAsyncIterable } from "./readerToAsyncIterable.js";
+export class FirstResultReader {
+    first;
+    live;
+    current = undefined;
+    index = -1;
+    firstSet = true;
+    constructor(first, live) {
+        this.first = first;
+        this.live = live;
+    }
+    static async capture(live) {
+        const rows = [];
+        while (await live.next())
+            if (live.current != null)
+                rows.push(live.current);
+        return { value: new FirstResultReader(rows, live), rows };
+    }
+    async next() {
+        if (!this.firstSet) {
+            const moved = await this.live.next();
+            this.current = this.live.current;
+            return moved;
+        }
+        this.index += 1;
+        if (this.index < this.first.length) {
+            this.current = this.first[this.index];
+            return true;
+        }
+        this.current = undefined;
+        return false;
+    }
+    async nextResult() {
+        this.firstSet = false;
+        this.current = undefined;
+        return this.live.nextResult();
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    dispose = () => this.live.dispose();
+    [Symbol.asyncDispose] = () => this.dispose();
+}

package/dist/HashsetOptimizedReadonlyEnrichmentStrategy.js

@@ -0,0 +1,58 @@
+import { Operator, Where } from "./statements/index.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+const hasKey = (value) => value !== undefined && value !== null;
+export class HashsetOptimizedReadonlyEnrichmentStrategy extends DefaultReadonlyEnrichmentStrategy {
+    async applyObject(via, enrichment, parents, sources) {
+        const keys = this.keysOf(parents, sources, enrichment.sourceProperty);
+        if (keys.size === 0)
+            return;
+        const index = new Map();
+        for await (const item of via.read(new Where(new Operator.In(enrichment.relatedKey, [...keys.values()])))) {
+            const by = this.props(item)[enrichment.relatedKey];
+            if (hasKey(by))
+                index.set(this.keyOf(by), item);
+        }
+        for (const [indexOfParent, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, indexOfParent);
+            if (key === undefined || key === null)
+                continue;
+            const related = index.get(this.keyOf(key));
+            if (!related)
+                continue;
+            Object.assign(parent, {
+                [enrichment.destinationProperty]: enrichment.relatedProperty ? this.props(related)[enrichment.relatedProperty] : related,
+            });
+        }
+    }
+    async applyList(via, enrichment, parents, sources) {
+        const keys = this.keysOf(parents, sources, enrichment.sourceProperty);
+        if (keys.size === 0)
+            return;
+        const index = new Map();
+        for await (const item of via.read(new Where(new Operator.In(enrichment.relatedKey, [...keys.values()])))) {
+            const by = this.props(item)[enrichment.relatedKey];
+            if (hasKey(by)) {
+                const cacheKey = this.keyOf(by);
+                const list = index.get(cacheKey) ?? [];
+                list.push(item);
+                index.set(cacheKey, list);
+            }
+        }
+        for (const [indexOfParent, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, enrichment.sourceProperty, sources, indexOfParent);
+            if (key === undefined || key === null)
+                continue;
+            Object.assign(parent, { [enrichment.destinationProperty]: index.get(this.keyOf(key)) ?? [] });
+        }
+    }
+    keysOf(parents, sources, from) {
+        const keys = new Map();
+        for (const [index, parent] of parents.entries()) {
+            const key = this.sourceKey(parent, from, sources, index);
+            if (key === undefined || key === null)
+                continue;
+            keys.set(this.keyOf(key), this.scalar(key));
+        }
+        return keys;
+    }
+}

package/dist/IBulkWriteStrategy.js

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

package/dist/ICRUDRepository.js

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

package/dist/ICRUDRepositoryFactory.js

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

package/dist/ICommand.js

@@ -0,0 +1,6 @@
+import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.js";
+import { Native } from "./statements/Native.js";
+export const execute = (command, statement, parameters) => command.executeStatement?.(statement, parameters) ??
+    command.executeNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);
+export const executeReader = (command, statement, parameters) => command.executeReaderStatement?.(statement, parameters) ??
+    command.executeReaderNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);

package/dist/ICommandMiddleware.js

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

package/dist/IConnection.js

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

package/dist/IDatasource.js

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

package/dist/IDatasourceFactory.js

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

package/dist/IDriver.d.ts

@@ -4,6 +4,8 @@ import type { ITransaction } from "./ITransaction.js";
 import type { IsolationLevel } from "./IsolationLevel.js";
 import type { DatasourceOptions } from "./DatasourceOptions.js";
 import type { Cell } from "./converters/Cell.js";
+import type { DefaultValueConverter } from "./converters/DefaultValueConverter.js";
+import type { IMapping } from "./converters/IMapping.js";
 import type { TypeConverter } from "./converters/TypeConverter.js";
 import type { Information } from "./Information.js";
 import type { StatementTextRenderer } from "./statements/StatementTextRenderer.js";
@@ -14,6 +16,8 @@ export interface IDriver {
     transaction(connection: IConnection, isolation?: IsolationLevel): ITransaction;
     rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
     columnType(name: string): string;
+    typeConverter?: IMapping<string, string> | null;
+    defaultValueConverter?: DefaultValueConverter | null;
     statementRenderer?: StatementTextRenderer | null;
     information?: Information | null;
 }

package/dist/IDriver.js

@@ -0,0 +1 @@
+export const columnType = (name) => name;

package/dist/IEnriched.js

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

package/dist/IReader.js

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

package/dist/IReadonlyEnrichmentStrategy.js

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

package/dist/IReadonlyRepository.js

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

package/dist/IRepository.js

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

package/dist/IRepositoryFactory.js

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

package/dist/IRepositoryTree.js

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

package/dist/IRepositoryTreeNode.js

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

package/dist/ITransaction.js

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

package/dist/IUnitOfWork.js

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

package/dist/IWriteEnrichmentStrategy.js

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

package/dist/Information.js

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

package/dist/IsolationLevel.js

@@ -0,0 +1,6 @@
+export const IsolationLevel = {
+    ReadUncommitted: "readUncommitted",
+    ReadCommitted: "readCommitted",
+    RepeatableRead: "repeatableRead",
+    Serializable: "serializable",
+};

package/dist/LazyWriteEnrichmentStrategy.js

@@ -0,0 +1,4 @@
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.js";
+export class LazyWriteEnrichmentStrategy extends DefaultWriteEnrichmentStrategy {
+    skipUnloaded = true;
+}

package/dist/NestedToObjectEnrichmentStrategy.js

@@ -0,0 +1,20 @@
+import { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+export class NestedToObjectEnrichmentStrategy extends DefaultReadonlyEnrichmentStrategy {
+    nested;
+    constructor(typeMap) {
+        super();
+        this.nested = new FlatToNestedMapper(typeMap);
+    }
+    apply(_via, _enrichment, parents, sources) {
+        parents.length = 0;
+        for (const item of this.nested.map(rows(sources)))
+            parents.push(item);
+        return Promise.resolve();
+    }
+}
+function* rows(sources) {
+    for (const source of sources ?? [])
+        if (source)
+            yield source;
+}

package/dist/Parameter.js

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

package/dist/ParameterDirection.js

@@ -0,0 +1,6 @@
+export const ParameterDirection = {
+    Input: "input",
+    Output: "output",
+    InputOutput: "inputOutput",
+    ReturnValue: "returnValue",
+};

package/dist/ProviderCatalog.js

@@ -0,0 +1,23 @@
+export class ProviderCatalog {
+    name;
+    location;
+    module;
+    constructor(name, location, module) {
+        this.name = name;
+        this.location = location;
+        this.module = module;
+    }
+    static default = {
+        json: new ProviderCatalog("json", "@deterministic-code/datasources-json", "JsonDriver"),
+        memory: new ProviderCatalog("memory", "@deterministic-code/datasources-memory", "MemoryDriver"),
+        sqlite: new ProviderCatalog("sqlite", "@deterministic-code/datasources-sqlite", "SqliteDriver"),
+        xml: new ProviderCatalog("xml", "@deterministic-code/datasources-xml", "XmlDriver"),
+        yaml: new ProviderCatalog("yaml", "@deterministic-code/datasources-yaml", "YamlDriver"),
+        mysql: new ProviderCatalog("mysql", "@deterministic-code/datasources-mysql", "MysqlDriver"),
+        sqlserver: new ProviderCatalog("sqlserver", "@deterministic-code/datasources-sqlserver", "SqlServerDriver"),
+        postgres: new ProviderCatalog("postgres", "@deterministic-code/datasources-postgres", "PostgresDriver"),
+        oracle: new ProviderCatalog("oracle", "@deterministic-code/datasources-oracle", "OracleDriver"),
+        mongodb: new ProviderCatalog("mongodb", "@deterministic-code/datasources-mongodb", "MongoDbDriver"),
+        dynamodb: new ProviderCatalog("dynamodb", "@deterministic-code/datasources-dynamodb", "DynamoDbDriver"),
+    };
+}

package/dist/ProviderNotImplementedError.js

@@ -0,0 +1,8 @@
+export class ProviderNotImplementedError extends Error {
+    provider;
+    constructor(provider) {
+        super(`Provider "${provider}" is not implemented`);
+        this.name = "ProviderNotImplementedError";
+        this.provider = provider;
+    }
+}

package/dist/ProviderNotInstalledError.js

@@ -0,0 +1,8 @@
+export class ProviderNotInstalledError extends Error {
+    provider;
+    constructor(provider) {
+        super(`Provider "${provider}" is not installed`);
+        this.name = "ProviderNotInstalledError";
+        this.provider = provider;
+    }
+}