@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/CRUDRepositoryStatements.js

@@ -0,0 +1,19 @@
+import { IdentityMapper } from "./mappers/IdentityMapper.js";
+import { StatementMappers } from "./StatementMappers.js";
+import { DeleteStatement } from "./statements/DeleteStatement.js";
+import { InsertStatement } from "./statements/InsertStatement.js";
+import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.js";
+import { UpdateStatement } from "./statements/UpdateStatement.js";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+const same = (_name, value) => value;
+export class CRUDRepositoryStatements extends ReadonlyRepositoryStatements {
+    mappings;
+    constructor(table, columns, entityMappers = new IdentityMapper(), propertyMappers = new IdentityMapper()) {
+        super(table, columns);
+        this.mappings = new StatementMappers(entityMappers, propertyMappers);
+    }
+    insert = (fields) => this.mappings.apply(new InsertStatement(this.table, fields), same);
+    update = (fields, where, cell = same) => this.mappings.apply(new UpdateStatement(this.table, fields, where), cell);
+    delete = (where, cell = same) => this.mappings.apply(new DeleteStatement(this.table, where), cell);
+    selectInsertedId = (column) => this.mappings.apply(new SelectInsertedIdStatement(this.table, column), same);
+}

package/dist/CascadeDeleteEnrichmentStrategy.d.ts

@@ -0,0 +1,7 @@
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+export declare class CascadeDeleteEnrichmentStrategy<T> extends DeleteEnrichmentStrategy<T> {
+    deleteChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T, deleteNested: (rows: TChild[]) => Promise<void>): Promise<void>;
+    deleteLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

package/dist/CascadeDeleteEnrichmentStrategy.js

@@ -0,0 +1,28 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import { Operator, Where } from "./statements/index.js";
+const get = (item, name) => item[name];
+const present = (value) => value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
+const linkWhere = (association, parentKey, relatedKey) => new Where(new Operator.And(new Operator.Equals(association.parent, parentKey), new Operator.Equals(association.related, relatedKey)));
+export class CascadeDeleteEnrichmentStrategy extends DeleteEnrichmentStrategy {
+    async deleteChildren(writer, enrichment, parent, deleteNested) {
+        const existing = await DeleteEnrichmentStrategy.load(writer, enrichment, parent);
+        await deleteNested(existing);
+        for (const row of existing)
+            await writer.delete(row, DeleteEnrichmentStrategy.childrenWhere(writer, enrichment, parent));
+    }
+    async deleteLinked(writer, enrichment, parent) {
+        const association = enrichment.association;
+        if (!association)
+            throw new DatasourceError("Missing association");
+        const key = get(parent, enrichment.sourceProperty);
+        if (!present(key))
+            return;
+        for (const row of await DeleteEnrichmentStrategy.loadLinks(writer, association.parent, key)) {
+            const id = get(row, association.related);
+            if (!present(id))
+                continue;
+            await writer.delete(row, linkWhere(association, key, id));
+        }
+    }
+}

package/dist/CascadeDeleteUpdateEnrichmentStrategy.d.ts

@@ -0,0 +1,8 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export declare class CascadeDeleteUpdateEnrichmentStrategy<T> extends UpdateEnrichmentStrategy<T> {
+    private readonly create;
+    updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+}

package/dist/CascadeDeleteUpdateEnrichmentStrategy.js

@@ -0,0 +1,25 @@
+import { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export class CascadeDeleteUpdateEnrichmentStrategy extends UpdateEnrichmentStrategy {
+    create = new DefaultCreateEnrichmentStrategy();
+    async updateChildren(writer, enrichment, parent) {
+        for (const row of await DeleteEnrichmentStrategy.load(writer, enrichment, parent))
+            await writer.delete(row, DeleteEnrichmentStrategy.childrenWhere(writer, enrichment, parent));
+        await this.create.createChildren(writer, enrichment, parent);
+    }
+    async updateLinked(writer, enrichment, parent) {
+        const association = enrichment.association;
+        if (!association)
+            throw new DatasourceError("Missing association");
+        const parentKey = this.requiredKey(parent, enrichment);
+        for (const row of await DeleteEnrichmentStrategy.loadLinks(writer, association.parent, parentKey)) {
+            const id = this.getCell(row, association.related);
+            if (!this.presentCell(id))
+                continue;
+            await writer.delete(row, this.linkWhere(association, parentKey, id));
+        }
+        await this.create.createLinked(writer, enrichment, parent);
+    }
+}

package/dist/CommandMiddlewareHost.d.ts

@@ -0,0 +1,22 @@
+import type { ICommandMiddleware } from "./ICommandMiddleware.js";
+import type { IReader } from "./IReader.js";
+import type { Parameter } from "./Parameter.js";
+import type { Response } from "./Response.js";
+import type { Row } from "./Row.js";
+import type { Cells } from "./converters/Cell.js";
+import type { IStatement } from "./statements/IStatement.js";
+import { Native } from "./statements/Native.js";
+export declare class CommandMiddlewareHost {
+    private readonly middlewares;
+    addMiddleware(middleware: ICommandMiddleware): this;
+    execute(text: string, parameters?: Parameter[]): Promise<Response>;
+    executeReader(text: string, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
+    executeReaderStatement(statement: IStatement, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeNative(_text: Native, _parameters?: Parameter[]): Promise<Response>;
+    executeReaderNative(_text: Native, _parameters?: Parameter[]): Promise<IReader<Cells>>;
+    run<T>(text: string, params: Parameter[] | undefined, fn: (text: string, params?: Parameter[]) => Promise<{
+        value: T;
+        rows: readonly Row[];
+    }>): Promise<T>;
+}

package/dist/CommandMiddlewareHost.js

@@ -0,0 +1,73 @@
+import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.js";
+import { Native } from "./statements/Native.js";
+import { StatementParser } from "./statements/StatementParser.js";
+const asError = (error) => error instanceof Error ? error : new Error(String(error));
+const resultOf = (value) => value instanceof Date ||
+    value instanceof Uint8Array ||
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    typeof value === "bigint"
+    ? value
+    : String(value);
+const isResponse = (value) => "rowsAffected" in value && typeof value.rowsAffected === "number";
+const logged = (value, rows) => rows.length > 0 || value === null || typeof value !== "object" || !isResponse(value)
+    ? rows
+    : [{ result: resultOf(value.result), rowsAffected: value.rowsAffected }];
+export class CommandMiddlewareHost {
+    middlewares = [];
+    addMiddleware(middleware) {
+        this.middlewares.push(middleware);
+        return this;
+    }
+    execute(text, parameters) {
+        if (!text.trim())
+            throw new Error("empty command");
+        return this.executeStatement(StatementParser.parse(text), parameters);
+    }
+    executeReader(text, parameters) {
+        if (!text.trim())
+            throw new Error("empty command");
+        return this.executeReaderStatement(StatementParser.parse(text), parameters);
+    }
+    executeStatement(statement, parameters) {
+        return this.executeNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);
+    }
+    executeReaderStatement(statement, parameters) {
+        return this.executeReaderNative(new Native(DefaultStatementTextRenderer.instance.render(statement)), parameters);
+    }
+    executeNative(_text, _parameters) {
+        throw new Error("executeNative");
+    }
+    executeReaderNative(_text, _parameters) {
+        throw new Error("executeReaderNative");
+    }
+    async run(text, params, fn) {
+        let q = text.trim();
+        let p = params;
+        for (const middleware of this.middlewares) {
+            const rewritten = await middleware.beforeCommand(q, p);
+            if (rewritten) {
+                q = rewritten.text;
+                p = rewritten.params;
+            }
+        }
+        const start = performance.now();
+        try {
+            const { value, rows } = await fn(q, p);
+            const elapsedMs = performance.now() - start;
+            for (const middleware of this.middlewares) {
+                await middleware.afterCommand(q, p, logged(value, rows), elapsedMs);
+            }
+            return value;
+        }
+        catch (error) {
+            const elapsedMs = performance.now() - start;
+            for (const middleware of this.middlewares) {
+                await middleware.afterCommand(q, p, [], elapsedMs, asError(error));
+            }
+            throw error;
+        }
+    }
+}

package/dist/ConsoleCommandMiddleware.d.ts

@@ -0,0 +1,14 @@
+import type { ICommandMiddleware } from "./ICommandMiddleware.js";
+import type { Parameter } from "./Parameter.js";
+import type { Row } from "./Row.js";
+export declare const formatElapsed: (elapsedMs: number) => string;
+export declare class ConsoleCommandMiddleware implements ICommandMiddleware {
+    private readonly write;
+    private readonly now;
+    private readonly options;
+    constructor(write?: (line: string) => void, now?: () => Date, options?: Record<string, string>);
+    beforeCommand: (text: string, params?: ReadonlyArray<Parameter>) => void;
+    afterCommand: (text: string, _params: ReadonlyArray<Parameter> | undefined, results: ReadonlyArray<Row>, elapsedMs: number) => void;
+    private verbose;
+    private line;
+}

package/dist/ConsoleCommandMiddleware.js

@@ -0,0 +1,45 @@
+export const formatElapsed = (elapsedMs) => elapsedMs < 1
+    ? `${Math.round(elapsedMs * 1000)}μs`
+    : `${Math.round(elapsedMs)}ms`;
+const cellOf = (value) => value === null
+    ? "null"
+    : value instanceof Date
+        ? value.toISOString()
+        : value instanceof Uint8Array
+            ? Buffer.from(value).toString("base64")
+            : typeof value === "bigint"
+                ? String(value)
+                : typeof value === "boolean"
+                    ? value ? "True" : "False"
+                    : typeof value === "string"
+                        ? value
+                        : String(value);
+const paramsOf = (params) => `{${(params ?? []).map((param) => `${param.name}: ${cellOf(param.value)}`).join(", ")}}`;
+const rowsOf = (rows) => rows
+    .map((row) => `{${Object.entries(row).sort(([left], [right]) => left < right ? -1 : 1).map(([key, value]) => `${key}: ${cellOf(value)}`).join(", ")}}`)
+    .join(", ");
+export class ConsoleCommandMiddleware {
+    write;
+    now;
+    options;
+    constructor(write = (line) => {
+        console.log(line);
+    }, now = () => new Date(), options = {}) {
+        this.write = write;
+        this.now = now;
+        this.options = options;
+    }
+    beforeCommand = (text, params) => {
+        this.write(this.line("Start", text));
+        if (this.verbose())
+            this.write(this.line("Request", paramsOf(params)));
+    };
+    afterCommand = (text, _params, results, elapsedMs) => {
+        const options = { ...this.options, elapsedMs: formatElapsed(elapsedMs) };
+        this.write(`${this.line("Finish", text)} ${options.elapsedMs}`);
+        if (this.verbose())
+            this.write(this.line("AfterCommand", rowsOf(results)));
+    };
+    verbose = () => this.options.isVerbose === "true" || this.options.isVerbose === "1";
+    line = (phase, text) => `[${this.now().toISOString()}]-[datasource][${phase}]-[${text}]`;
+}

package/dist/CreateEnrichmentStrategy.d.ts

@@ -0,0 +1,14 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { Scalar } from "./builders/Scalar.js";
+export declare abstract class CreateEnrichmentStrategy<T> {
+    abstract createChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    abstract createLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    collectChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): TChild[];
+    protected getCell: <TItem>(item: TItem, name: string) => Scalar | object | undefined;
+    protected presentCell: (value: Scalar | object | undefined) => value is Scalar;
+    protected payloadOf: <TChild extends object, TParent>(parent: TParent, into: string, enrichment?: Enrichment) => TChild[];
+    protected stampCell: <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined) => void;
+    protected relatedIds: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar[];
+    protected requiredKey: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar;
+}

package/dist/CreateEnrichmentStrategy.js

@@ -0,0 +1,64 @@
+import { DatasourceError } from "./DatasourceError.js";
+export class CreateEnrichmentStrategy {
+    collectChildren(writer, enrichment, parent) {
+        const children = this.payloadOf(parent, enrichment.destinationProperty, enrichment);
+        if (children.length === 0)
+            return children;
+        const key = this.requiredKey(parent, enrichment);
+        for (const child of children)
+            this.stampCell(child, enrichment.relatedKey, key);
+        return children;
+    }
+    getCell = (item, name) => item[name];
+    presentCell = (value) => value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
+    payloadOf = (parent, into, enrichment) => mapPayload(this.getCell(parent, into), enrichment);
+    stampCell = (related, by, key) => {
+        if (key === undefined || key === null || typeof key === "object")
+            return;
+        const current = this.getCell(related, by);
+        if (current !== null && typeof current === "object" && !Array.isArray(current)) {
+            const target = current;
+            const id = "Id" in target ? "Id" : "id";
+            target[id] = key;
+            return;
+        }
+        Object.assign(related, { [by]: key });
+    };
+    relatedIds = (parent, enrichment) => {
+        const ids = [];
+        const seen = new Set();
+        for (const related of this.payloadOf(parent, enrichment.destinationProperty)) {
+            const id = this.getCell(related, enrichment.relatedKey);
+            if (!this.presentCell(id))
+                throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.relatedKey}"`);
+            const key = String(id);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            ids.push(id);
+        }
+        return ids;
+    };
+    requiredKey = (parent, enrichment) => {
+        const key = this.getCell(parent, enrichment.sourceProperty);
+        if (!this.presentCell(key))
+            throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.sourceProperty}"`);
+        return key;
+    };
+}
+const mapPayload = (value, enrichment) => {
+    if (value === undefined || value === null || typeof value === "string")
+        return [];
+    if (Array.isArray(value))
+        return value.filter((item) => item !== null && typeof item === "object");
+    if (enrichment?.type !== "dictionary" || typeof value !== "object")
+        return [];
+    const keyName = mapKeyName(enrichment.relatedKey);
+    const valueName = enrichment.relatedProperty ?? (keyName === "Key" ? "Value" : "value");
+    return Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, cell]) => cell !== null && typeof cell === "object" && !Array.isArray(cell)
+        ? { [keyName]: key, ...cell }
+        : { [keyName]: key, [valueName]: cell });
+};
+const mapKeyName = (relatedKey) => relatedKey.includes("_") || relatedKey[0] !== relatedKey[0]?.toUpperCase() ? "key" : "Key";

package/dist/Datasource.d.ts

@@ -0,0 +1,30 @@
+import type { Constructable } from "./converters/Constructable.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { ICommand } from "./ICommand.js";
+import type { IConnection } from "./IConnection.js";
+import type { IDatasource } from "./IDatasource.js";
+import type { IDriver } from "./IDriver.js";
+import type { IReadonlyRepository } from "./IReadonlyRepository.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+import { RepositoryFactory } from "./RepositoryFactory.js";
+export declare class Datasource implements IDatasource {
+    readonly provider: string;
+    private readonly driver;
+    private readonly options?;
+    private connection?;
+    readonly repositories: RepositoryFactory;
+    constructor(provider: string, driver: IDriver, options?: DatasourceOptions | undefined);
+    private defaultConnection;
+    createConnection: () => Promise<IConnection>;
+    createCommand: (connection?: IConnection) => Promise<ICommand>;
+    private applyCrud;
+    private applyReadonly;
+    createRepository<T>(type: Constructable<T>, connection?: IConnection, options?: CRUDRepositoryOptions<T>): ICRUDRepository<T>;
+    createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+    createReadonlyRepository<T>(type: Constructable<T>, connection?: IConnection, options?: ReadonlyRepositoryMappingOptions<T>): IReadonlyRepository<T>;
+    createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+    static create: (options?: DatasourceOptions) => Datasource;
+    static get default(): Datasource;
+}

package/dist/Datasource.js

@@ -0,0 +1,98 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { CRUDRepository } from "./CRUDRepository.js";
+import { ReadonlyRepository } from "./ReadonlyRepository.js";
+import { RepositoryFactory } from "./RepositoryFactory.js";
+import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.js";
+import { RowTypeConverter } from "./converters/RowTypeConverter.js";
+import { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
+import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.js";
+export class Datasource {
+    provider;
+    driver;
+    options;
+    connection;
+    repositories = new RepositoryFactory();
+    constructor(provider, driver, options) {
+        this.provider = provider;
+        this.driver = driver;
+        this.options = options;
+        const self = this;
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (typeof prop !== "string" || Reflect.has(target, prop))
+                    return Reflect.get(target, prop, receiver);
+                if (self.repositories.has(prop))
+                    return self.repositories.create(prop, self.defaultConnection());
+                throw new RepositoryNotRegisteredError(prop);
+            },
+        });
+    }
+    defaultConnection = () => (this.connection ??= this.driver.connection(this.options));
+    createConnection = () => Promise.resolve(this.defaultConnection());
+    createCommand = async (connection) => {
+        if (!connection) {
+            connection = this.defaultConnection();
+            if (connection.isOpen)
+                throw new DatasourceError("Connection is already open");
+            await connection.open();
+        }
+        return this.driver.command(connection);
+    };
+    applyCrud = (type, options) => {
+        const built = createCRUDRepositoryOptions(type, this.driver.rowTypeConverters);
+        const types = this.driver.rowTypeConverters;
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, columnsOf(type));
+        return {
+            ...(options ?? built),
+            entity: options?.entity ?? built.entity,
+            rowConverter: rows,
+            rowTypeConverters: types,
+            type,
+        };
+    };
+    applyReadonly = (type, options) => {
+        const built = createReadonlyRepositoryMappingOptions(type, this.driver.rowTypeConverters);
+        const types = this.driver.rowTypeConverters;
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, columnsOf(type));
+        return {
+            ...(options ?? built),
+            entity: options?.entity ?? built.entity,
+            rowConverter: rows,
+            rowTypeConverters: types,
+            type,
+        };
+    };
+    createRepository(typeOrName, connection, options) {
+        if (typeof typeOrName === "string")
+            return this.repositories.create(typeOrName, connection ?? this.defaultConnection());
+        return new CRUDRepository(connection ?? this.defaultConnection(), this.applyCrud(typeOrName, options));
+    }
+    createReadonlyRepository(typeOrName, connection, options) {
+        if (typeof typeOrName === "string")
+            return this.repositories.createReadonly(typeOrName, connection ?? this.defaultConnection());
+        return new ReadonlyRepository(connection ?? this.defaultConnection(), this.applyReadonly(typeOrName, options));
+    }
+    static create;
+    static get default() {
+        return Datasource.create();
+    }
+}
+const columnsOf = (type) => {
+    const instance = new type();
+    const columns = {};
+    for (const [name, value] of Object.entries(instance)) {
+        if (Array.isArray(value))
+            continue;
+        const canonical = canonicalOf(value);
+        if (canonical)
+            columns[name] = canonical;
+    }
+    return columns;
+};
+const canonicalOf = (value) => typeof value === "boolean"
+    ? "bool"
+    : value instanceof Date
+        ? "datetime"
+        : value instanceof Uint8Array
+            ? "binary"
+            : undefined;

package/dist/DatasourceError.d.ts

@@ -0,0 +1,3 @@
+export declare class DatasourceError extends Error {
+    constructor(message: string);
+}

package/dist/DatasourceError.js

@@ -0,0 +1,6 @@
+export class DatasourceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DatasourceError";
+    }
+}

package/dist/DatasourceFactory.d.ts

@@ -0,0 +1,12 @@
+import type { IDatasource } from "./IDatasource.js";
+import type { IDatasourceFactory } from "./IDatasourceFactory.js";
+import type { IDriver } from "./IDriver.js";
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+export declare class DatasourceFactory implements IDatasourceFactory {
+    static defaults: (options: DatasourceOptions) => void;
+    static register: (provider: string, driver: IDriver) => void;
+    static create: (options?: DatasourceOptions) => IDatasource;
+    create: (options?: DatasourceOptions) => IDatasource;
+    static reset: () => void;
+    static registered: () => string[];
+}

package/dist/DatasourceFactory.js

@@ -0,0 +1,76 @@
+import { Datasource } from "./Datasource.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { DatasourceUrlParser } from "./DatasourceUrlParser.js";
+import { DriverLoader } from "./DriverLoader.js";
+import { DotEnv } from "./dotEnv.js";
+import { ProviderCatalog } from "./ProviderCatalog.js";
+import { ProviderNotInstalledError } from "./ProviderNotInstalledError.js";
+const factories = new Map();
+const get = (options, key) => {
+    const value = options?.[key];
+    return value && value.trim() ? value.trim() : undefined;
+};
+const nonEmpty = (value) => value?.trim() ? value.trim() : undefined;
+const merge = (file, env) => {
+    const options = { ...file };
+    for (const key of ["INSTALLED_PROVIDERS", "DATASOURCE_URL", "PROVIDER"]) {
+        const value = nonEmpty(env[key]);
+        if (value)
+            options[key] = value;
+    }
+    return options;
+};
+const split = (value) => (value ?? "")
+    .split(",")
+    .map((name) => name.trim())
+    .filter((name) => name.length > 0);
+function* installed(options) {
+    const names = new Set();
+    for (const name of split(get(options, "INSTALLED_PROVIDERS"))) {
+        if (names.has(name))
+            continue;
+        names.add(name);
+        yield name;
+    }
+    const url = get(options, "DATASOURCE_URL");
+    if (!url)
+        return;
+    const provider = DatasourceUrlParser.parse(url)?.provider;
+    if (!provider)
+        throw new DatasourceError("DATASOURCE_URL has no provider");
+    if (!names.has(provider))
+        yield provider;
+}
+const registerInstalled = (options) => {
+    for (const name of installed(options)) {
+        const catalog = ProviderCatalog.default[name];
+        if (!catalog)
+            throw new ProviderNotInstalledError(name);
+        if (factories.has(name))
+            continue;
+        DatasourceFactory.register(name, DriverLoader.load(catalog));
+    }
+};
+const resolve = (options) => {
+    const listed = options ?? merge(DotEnv.load(), process.env);
+    if (options === undefined)
+        registerInstalled(listed);
+    const name = get(listed, "PROVIDER")
+        ?? (() => { throw new DatasourceError("Datasource defaults are not specified"); })();
+    const driver = factories.get(name);
+    if (!driver)
+        throw new ProviderNotInstalledError(name);
+    return new Datasource(name, driver, listed);
+};
+export class DatasourceFactory {
+    static defaults = (options) => registerInstalled(options);
+    static register = (provider, driver) => {
+        factories.set(provider, driver);
+    };
+    static create = (options) => resolve(options);
+    create = (options) => resolve(options);
+    static reset = () => {
+        factories.clear();
+    };
+    static registered = () => [...factories.keys()].sort();
+}

package/dist/DatasourceOptions.js

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

package/dist/DatasourceUrl.d.ts

@@ -0,0 +1,12 @@
+export declare class DatasourceUrl {
+    readonly provider: string;
+    readonly username: string | undefined;
+    readonly password: string | undefined;
+    readonly host: string | undefined;
+    readonly port: number | undefined;
+    readonly path: string;
+    readonly schema: string | undefined;
+    readonly options: Readonly<Record<string, string>>;
+    constructor(provider: string, username: string | undefined, password: string | undefined, host: string | undefined, port: number | undefined, path: string, schema: string | undefined, options: Readonly<Record<string, string>>);
+    get datasource(): string | undefined;
+}

package/dist/DatasourceUrl.js

@@ -0,0 +1,28 @@
+export class DatasourceUrl {
+    provider;
+    username;
+    password;
+    host;
+    port;
+    path;
+    schema;
+    options;
+    constructor(provider, username, password, host, port, path, schema, options) {
+        this.provider = provider;
+        this.username = username;
+        this.password = password;
+        this.host = host;
+        this.port = port;
+        this.path = path;
+        this.schema = schema;
+        this.options = options;
+    }
+    get datasource() {
+        if (this.path === "")
+            return undefined;
+        if (!this.path.startsWith("/"))
+            return this.path;
+        const rest = this.path.slice(1);
+        return rest === "" ? undefined : rest;
+    }
+}

package/dist/DatasourceUrlParser.d.ts

@@ -0,0 +1,4 @@
+import { DatasourceUrl } from "./DatasourceUrl.js";
+export declare class DatasourceUrlParser {
+    static parse(url: string | undefined): DatasourceUrl | undefined;
+}