@deterministic-code/datasources 0.0.0-stage → 0.1.0

package/src/CRUDRepositoryBuilder.ts

@@ -0,0 +1,53 @@
+import type { IConnection } from "./IConnection.ts";
+import { defaultId, fieldNamesOf, createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+import { CRUDRepository } from "./CRUDRepository.ts";
+import { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.ts";
+import type { BuiltRepository } from "./BuiltRepository.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.ts";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+
+const isCrud = <T>(options: ReadonlyRepositoryMappingOptions<T>): options is CRUDRepositoryOptions<T> =>
+  "ids" in options || "write" in options;
+
+const withIds = <T>(options: CRUDRepositoryOptions<T>): CRUDRepositoryOptions<T> =>
+  "ids" in options
+    ? options
+    : {
+        ...options,
+        ids: options.type ? defaultId(fieldNamesOf(options.type)) : ["id"],
+      };
+
+export const repositoryParts = <T>(
+  typeOrConnection: Constructable<T> | IConnection,
+  connectionOrOptions?: IConnection | CRUDRepositoryOptions<T>,
+): { built: BuiltRepository<T>; statements: CRUDRepositoryStatements } => {
+  const builder = new CRUDRepositoryBuilder<T>();
+  const built =
+    typeof typeOrConnection === "function"
+      ? builder.parts(
+          connectionOrOptions as IConnection,
+          createCRUDRepositoryOptions(typeOrConnection),
+        )
+      : builder.parts(typeOrConnection, withIds(connectionOrOptions as CRUDRepositoryOptions<T>));
+  return { built, statements: builder.crudStatements! };
+};
+
+export class CRUDRepositoryBuilder<T = object> extends ReadonlyRepositoryBuilder<T> {
+  crudStatements?: CRUDRepositoryStatements;
+
+  protected override ids = (options: ReadonlyRepositoryMappingOptions<T>): string[] =>
+    isCrud(options)
+      ? (options.ids ?? (options.type ? defaultId(fieldNamesOf(options.type)) : ["id"]))
+      : [];
+
+  protected override statements = (table: string, columns: string[]): ReadonlyRepositoryStatements => {
+    this.crudStatements = new CRUDRepositoryStatements(table, columns, this.entityMapper, this.propertyMapper);
+    return new ReadonlyRepositoryStatements(table, columns);
+  };
+
+  build = (connection: IConnection, options: CRUDRepositoryOptions<T>): CRUDRepository<T> =>
+    new CRUDRepository(connection, options);
+}

package/src/CRUDRepositoryOptions.ts

@@ -0,0 +1,8 @@
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+import type { Cells } from "./converters/Cell.ts";
+import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.ts";
+
+export type CRUDRepositoryOptions<T = Cells> = ReadonlyRepositoryMappingOptions<T> & {
+  ids?: string[];
+  write?: IWriteEnrichmentStrategy<T>;
+};

package/src/CRUDRepositoryStatements.ts

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,152 @@
+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

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