@deterministic-code/datasources 0.1.0 → 0.1.2

package/src/CRUDRepositoryStatements.ts

@@ -1,43 +0,0 @@
-import type { Cell } from "./converters/Cell.ts";
-import type { Field } from "./builders/Field.ts";
-import type { IMapper } from "./mappers/IMapper.ts";
-import { IdentityMapper } from "./mappers/IdentityMapper.ts";
-import { StatementMappers } from "./StatementMappers.ts";
-import { DeleteStatement } from "./statements/DeleteStatement.ts";
-import { InsertStatement } from "./statements/InsertStatement.ts";
-import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.ts";
-import { UpdateStatement } from "./statements/UpdateStatement.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
-
-const same = (_name: string, value: Cell): Cell => value;
-
-export class CRUDRepositoryStatements extends ReadonlyRepositoryStatements {
-  private readonly mappings: StatementMappers;
-
-  constructor(
-    table: string,
-    columns: readonly string[],
-    entityMappers: IMapper<string, string> = new IdentityMapper(),
-    propertyMappers: IMapper<string, string> = new IdentityMapper(),
-  ) {
-    super(table, columns);
-    this.mappings = new StatementMappers(entityMappers, propertyMappers);
-  }
-
-  insert = (fields: Field[]): InsertStatement =>
-    this.mappings.apply(new InsertStatement(this.table, fields), same) as InsertStatement;
-
-  update = (
-    fields: Field[],
-    where?: IWhere,
-    cell: (name: string, value: Cell) => Cell = same,
-  ): UpdateStatement =>
-    this.mappings.apply(new UpdateStatement(this.table, fields, where), cell) as UpdateStatement;
-
-  delete = (where?: IWhere, cell: (name: string, value: Cell) => Cell = same): DeleteStatement =>
-    this.mappings.apply(new DeleteStatement(this.table, where), cell) as DeleteStatement;
-
-  selectInsertedId = (column: string): SelectInsertedIdStatement =>
-    this.mappings.apply(new SelectInsertedIdStatement(this.table, column), same) as SelectInsertedIdStatement;
-}

package/src/CascadeDeleteEnrichmentStrategy.ts

@@ -1,51 +0,0 @@
-import { DatasourceError } from "./DatasourceError.ts";
-import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.ts";
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { Scalar } from "./builders/Scalar.ts";
-import { Operator, Where } from "./statements/index.ts";
-
-type Props = Record<string, Scalar | object>;
-
-const get = <TItem>(item: TItem, name: string): Scalar | object | undefined =>
-  (item as never as Props)[name];
-
-const present = (value: Scalar | object | undefined): value is Scalar =>
-  value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
-
-const linkWhere = (
-  association: NonNullable<Enrichment["association"]>,
-  parentKey: Scalar,
-  relatedKey: Scalar,
-): Where =>
-  new Where(
-    new Operator.And(
-      new Operator.Equals(association.parent, parentKey),
-      new Operator.Equals(association.related, relatedKey),
-    ),
-  );
-
-export class CascadeDeleteEnrichmentStrategy<T> extends DeleteEnrichmentStrategy<T> {
-  async deleteChildren<TChild extends object>(
-    writer: ICRUDRepository<TChild>,
-    enrichment: Enrichment,
-    parent: T,
-    deleteNested: (rows: TChild[]) => Promise<void>,
-  ): Promise<void> {
-    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<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void> {
-    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/src/CascadeDeleteUpdateEnrichmentStrategy.ts

@@ -1,28 +0,0 @@
-import { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.ts";
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.ts";
-
-export class CascadeDeleteUpdateEnrichmentStrategy<T> extends UpdateEnrichmentStrategy<T> {
-  private readonly create = new DefaultCreateEnrichmentStrategy<T>();
-
-  async updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void> {
-    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<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void> {
-    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/src/CommandMiddlewareHost.ts

@@ -1,113 +0,0 @@
-import type { ICommandMiddleware } from "./ICommandMiddleware.ts";
-import type { IReader } from "./IReader.ts";
-import type { Parameter } from "./Parameter.ts";
-import type { Response } from "./Response.ts";
-import type { Row } from "./Row.ts";
-import type { Cell, Cells } from "./converters/Cell.ts";
-import type { IStatement } from "./statements/IStatement.ts";
-import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.ts";
-import { Native } from "./statements/Native.ts";
-import { StatementParser } from "./statements/StatementParser.ts";
-
-const asError = (error: unknown): Error =>
-  error instanceof Error ? error : new Error(String(error));
-
-type ExecuteBody = { result: Cell; rowsAffected: number };
-
-const resultOf = (value: Cell | object | null): Cell =>
-  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: object): value is ExecuteBody =>
-  "rowsAffected" in value && typeof (value as ExecuteBody).rowsAffected === "number";
-
-const logged = <T>(value: T, rows: readonly Row[]): readonly Row[] =>
-  rows.length > 0 || value === null || typeof value !== "object" || !isResponse(value)
-    ? rows
-    : [{ result: resultOf(value.result), rowsAffected: value.rowsAffected }];
-
-export class CommandMiddlewareHost {
-  private readonly middlewares: ICommandMiddleware[] = [];
-
-  addMiddleware(middleware: ICommandMiddleware): this {
-    this.middlewares.push(middleware);
-    return this;
-  }
-
-  execute(text: string, parameters?: Parameter[]): Promise<Response> {
-    if (!text.trim()) throw new Error("empty command");
-    return this.executeStatement(StatementParser.parse(text), parameters);
-  }
-
-  executeReader(text: string, parameters?: Parameter[]): Promise<IReader<Cells>> {
-    if (!text.trim()) throw new Error("empty command");
-    return this.executeReaderStatement(StatementParser.parse(text), parameters);
-  }
-
-  executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
-    return this.executeNative(
-      new Native(DefaultStatementTextRenderer.instance.render(statement)),
-      parameters,
-    );
-  }
-
-  executeReaderStatement(
-    statement: IStatement,
-    parameters?: Parameter[],
-  ): Promise<IReader<Cells>> {
-    return this.executeReaderNative(
-      new Native(DefaultStatementTextRenderer.instance.render(statement)),
-      parameters,
-    );
-  }
-
-  executeNative(_text: Native, _parameters?: Parameter[]): Promise<Response> {
-    throw new Error("executeNative");
-  }
-
-  executeReaderNative(_text: Native, _parameters?: Parameter[]): Promise<IReader<Cells>> {
-    throw new Error("executeReaderNative");
-  }
-
-  async run<T>(
-    text: string,
-    params: Parameter[] | undefined,
-    fn: (
-      text: string,
-      params?: Parameter[],
-    ) => Promise<{ value: T; rows: readonly Row[] }>,
-  ): Promise<T> {
-    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 as Parameter[] | undefined;
-      }
-    }
-
-    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/src/ConsoleCommandMiddleware.ts

@@ -1,64 +0,0 @@
-import type { ICommandMiddleware } from "./ICommandMiddleware.ts";
-import type { Parameter } from "./Parameter.ts";
-import type { Row } from "./Row.ts";
-import type { Cell } from "./converters/Cell.ts";
-
-export const formatElapsed = (elapsedMs: number): string =>
-  elapsedMs < 1
-    ? `${Math.round(elapsedMs * 1000)}μs`
-    : `${Math.round(elapsedMs)}ms`;
-
-const cellOf = (value: Cell): string =>
-  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?: ReadonlyArray<Parameter>) =>
-  `{${(params ?? []).map((param) => `${param.name}: ${cellOf(param.value as Cell)}`).join(", ")}}`;
-
-const rowsOf = (rows: ReadonlyArray<Row>) =>
-  rows
-    .map((row) => `{${Object.entries(row).sort(([left], [right]) => left < right ? -1 : 1).map(([key, value]) => `${key}: ${cellOf(value)}`).join(", ")}}`)
-    .join(", ");
-
-export class ConsoleCommandMiddleware implements ICommandMiddleware {
-  constructor(
-    private readonly write: (line: string) => void = (line) => {
-      console.log(line);
-    },
-    private readonly now: () => Date = () => new Date(),
-    private readonly options: Record<string, string> = {},
-  ) {}
-
-  beforeCommand = (text: string, params?: ReadonlyArray<Parameter>): void => {
-    this.write(this.line("Start", text));
-    if (this.verbose()) this.write(this.line("Request", paramsOf(params)));
-  };
-
-  afterCommand = (
-    text: string,
-    _params: ReadonlyArray<Parameter> | undefined,
-    results: ReadonlyArray<Row>,
-    elapsedMs: number,
-  ): void => {
-    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)));
-  };
-
-  private verbose = (): boolean =>
-    this.options.isVerbose === "true" || this.options.isVerbose === "1";
-
-  private line = (phase: string, text: string): string =>
-    `[${this.now().toISOString()}]-[datasource][${phase}]-[${text}]`;
-}

package/src/CreateEnrichmentStrategy.ts

@@ -1,82 +0,0 @@
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { Scalar } from "./builders/Scalar.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-
-type Props = Record<string, Scalar | object>;
-
-export 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[] {
-    const children = this.payloadOf<TChild, T>(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;
-  }
-
-  protected getCell = <TItem>(item: TItem, name: string): Scalar | object | undefined =>
-    (item as never as Props)[name];
-
-  protected presentCell = (value: Scalar | object | undefined): value is Scalar =>
-    value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
-
-  protected payloadOf = <TChild extends object, TParent>(
-    parent: TParent,
-    into: string,
-    enrichment?: Enrichment,
-  ): TChild[] => mapPayload(this.getCell(parent, into), enrichment) as TChild[];
-
-  protected stampCell = <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined): void => {
-    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 as Props;
-      const id = "Id" in target ? "Id" : "id";
-      target[id] = key;
-      return;
-    }
-    Object.assign(related, { [by]: key });
-  };
-
-  protected relatedIds = <TParent>(parent: TParent, enrichment: Enrichment): Scalar[] => {
-    const ids: Scalar[] = [];
-    const seen = new Set<string>();
-    for (const related of this.payloadOf<object, TParent>(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;
-  };
-
-  protected requiredKey = <TParent>(parent: TParent, enrichment: Enrichment): Scalar => {
-    const key = this.getCell(parent, enrichment.sourceProperty);
-    if (!this.presentCell(key)) throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.sourceProperty}"`);
-    return key;
-  };
-}
-
-const mapPayload = (value: Scalar | object | undefined, enrichment?: Enrichment): object[] => {
-  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 as Record<string, Scalar | object>)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, cell]) =>
-      cell !== null && typeof cell === "object" && !Array.isArray(cell)
-        ? { [keyName]: key, ...(cell as object) }
-        : { [keyName]: key, [valueName]: cell },
-    );
-};
-
-const mapKeyName = (relatedKey: string): string =>
-  relatedKey.includes("_") || relatedKey[0] !== relatedKey[0]?.toUpperCase() ? "key" : "Key";

package/src/Datasource.ts

@@ -1,152 +0,0 @@
-import type { Cell } from "./converters/Cell.ts";
-import type { Constructable } from "./converters/Constructable.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-import type { ICommand } from "./ICommand.ts";
-import type { IConnection } from "./IConnection.ts";
-import type { IDatasource } from "./IDatasource.ts";
-import type { IDriver } from "./IDriver.ts";
-import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { DatasourceOptions } from "./DatasourceOptions.ts";
-import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-import { CRUDRepository } from "./CRUDRepository.ts";
-import { ReadonlyRepository } from "./ReadonlyRepository.ts";
-import { RepositoryFactory } from "./RepositoryFactory.ts";
-import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.ts";
-import { RowTypeConverter } from "./converters/RowTypeConverter.ts";
-import { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.ts";
-import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.ts";
-
-export class Datasource implements IDatasource {
-  private connection?: IConnection;
-  readonly repositories = new RepositoryFactory();
-
-  constructor(
-    readonly provider: string,
-    private readonly driver: IDriver,
-    private readonly options?: DatasourceOptions,
-  ) {
-    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);
-      },
-    });
-  }
-
-  private defaultConnection = (): IConnection =>
-    (this.connection ??= this.driver.connection(this.options));
-
-  createConnection = (): Promise<IConnection> =>
-    Promise.resolve(this.defaultConnection());
-
-  createCommand = async (connection?: IConnection): Promise<ICommand> => {
-    if (!connection) {
-      connection = this.defaultConnection();
-      if (connection.isOpen) throw new DatasourceError("Connection is already open");
-      await connection.open();
-    }
-    return this.driver.command(connection);
-  };
-
-  private applyCrud = <T>(
-    type: Constructable<T>,
-    options?: CRUDRepositoryOptions<T>,
-  ): CRUDRepositoryOptions<T> => {
-    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,
-    };
-  };
-
-  private applyReadonly = <T>(
-    type: Constructable<T>,
-    options?: ReadonlyRepositoryMappingOptions<T>,
-  ): ReadonlyRepositoryMappingOptions<T> => {
-    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<T>(
-    type: Constructable<T>,
-    connection?: IConnection,
-    options?: CRUDRepositoryOptions<T>,
-  ): ICRUDRepository<T>;
-  createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
-  createRepository<T>(
-    typeOrName: Constructable<T> | string,
-    connection?: IConnection,
-    options?: CRUDRepositoryOptions<T>,
-  ): ICRUDRepository<T> {
-    if (typeof typeOrName === "string")
-      return this.repositories.create(typeOrName, connection ?? this.defaultConnection()) as ICRUDRepository<T>;
-    return new CRUDRepository(
-      connection ?? this.defaultConnection(),
-      this.applyCrud(typeOrName, options),
-    );
-  }
-
-  createReadonlyRepository<T>(
-    type: Constructable<T>,
-    connection?: IConnection,
-    options?: ReadonlyRepositoryMappingOptions<T>,
-  ): IReadonlyRepository<T>;
-  createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
-  createReadonlyRepository<T>(
-    typeOrName: Constructable<T> | string,
-    connection?: IConnection,
-    options?: ReadonlyRepositoryMappingOptions<T>,
-  ): IReadonlyRepository<T> {
-    if (typeof typeOrName === "string")
-      return this.repositories.createReadonly(typeOrName, connection ?? this.defaultConnection()) as IReadonlyRepository<T>;
-    return new ReadonlyRepository(
-      connection ?? this.defaultConnection(),
-      this.applyReadonly(typeOrName, options),
-    );
-  }
-
-  static create: (options?: DatasourceOptions) => Datasource;
-
-  static get default(): Datasource {
-    return Datasource.create();
-  }
-}
-
-const columnsOf = <T>(type: Constructable<T>): Record<string, string> => {
-  const instance = new type() as Record<string, Cell | object>;
-  const columns: Record<string, string> = {};
-  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: Cell | object): string | undefined =>
-  typeof value === "boolean"
-    ? "bool"
-    : value instanceof Date
-      ? "datetime"
-      : value instanceof Uint8Array
-        ? "binary"
-        : undefined;

package/src/DatasourceError.ts

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

package/src/DatasourceFactory.ts

@@ -1,86 +0,0 @@
-import type { IDatasource } from "./IDatasource.ts";
-import type { IDatasourceFactory } from "./IDatasourceFactory.ts";
-import type { IDriver } from "./IDriver.ts";
-import type { DatasourceOptions } from "./DatasourceOptions.ts";
-import { Datasource } from "./Datasource.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-import { DatasourceUrlParser } from "./DatasourceUrlParser.ts";
-import { DriverLoader } from "./DriverLoader.ts";
-import { DotEnv } from "./dotEnv.ts";
-import { ProviderCatalog } from "./ProviderCatalog.ts";
-import { ProviderNotInstalledError } from "./ProviderNotInstalledError.ts";
-
-const factories = new Map<string, IDriver>();
-
-const get = (options: DatasourceOptions | undefined, key: string): string | undefined => {
-  const value = options?.[key];
-  return value && value.trim() ? value.trim() : undefined;
-};
-
-const nonEmpty = (value: string | undefined): string | undefined =>
-  value?.trim() ? value.trim() : undefined;
-
-const merge = (file: DatasourceOptions, env: Record<string, string | undefined>): DatasourceOptions => {
-  const options: DatasourceOptions = { ...file };
-  for (const key of ["INSTALLED_PROVIDERS", "DATASOURCE_URL", "PROVIDER"] as const) {
-    const value = nonEmpty(env[key]);
-    if (value) options[key] = value;
-  }
-  return options;
-};
-
-const split = (value: string | undefined): string[] =>
-  (value ?? "")
-    .split(",")
-    .map((name) => name.trim())
-    .filter((name) => name.length > 0);
-
-function* installed(options: DatasourceOptions): Generator<string> {
-  const names = new Set<string>();
-  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: DatasourceOptions): void => {
-  for (const name of installed(options)) {
-    const catalog = ProviderCatalog.default[name];
-    if (!catalog) throw new ProviderNotInstalledError(name);
-    DatasourceFactory.register(name, DriverLoader.load(catalog));
-  }
-};
-
-const resolve = (options?: DatasourceOptions): IDatasource => {
-  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 implements IDatasourceFactory {
-  static defaults = (options: DatasourceOptions): void => registerInstalled(options);
-
-  static register = (provider: string, driver: IDriver): void => {
-    factories.set(provider, driver);
-  };
-
-  static create = (options?: DatasourceOptions): IDatasource => resolve(options);
-
-  create = (options?: DatasourceOptions): IDatasource => resolve(options);
-
-  static reset = (): void => {
-    factories.clear();
-  };
-
-  static registered = (): string[] => [...factories.keys()].sort();
-}

package/src/DatasourceUrl.ts

@@ -1,37 +0,0 @@
-export 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>>,
-  ) {
-    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(): string | undefined {
-    if (this.path === "") return undefined;
-    if (!this.path.startsWith("/")) return this.path;
-    const rest = this.path.slice(1);
-    return rest === "" ? undefined : rest;
-  }
-}