@deterministic-code/datasources 0.0.0-stage → 0.1.0

package/src/IDriver.ts

@@ -0,0 +1,24 @@
+import type { ICommand } from "./ICommand.ts";
+import type { IConnection } from "./IConnection.ts";
+import type { ITransaction } from "./ITransaction.ts";
+import type { IsolationLevel } from "./IsolationLevel.ts";
+import type { DatasourceOptions } from "./DatasourceOptions.ts";
+import type { Cell } from "./converters/Cell.ts";
+import type { TypeConverter } from "./converters/TypeConverter.ts";
+import type { Information } from "./Information.ts";
+import type { StatementTextRenderer } from "./statements/StatementTextRenderer.ts";
+
+export const columnType = (name: string): string => name;
+
+export interface IDriver {
+  connection(options?: DatasourceOptions): IConnection;
+  command(connection: IConnection): ICommand;
+  transaction(
+    connection: IConnection,
+    isolation?: IsolationLevel,
+  ): ITransaction;
+  rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+  columnType(name: string): string;
+  statementRenderer?: StatementTextRenderer | null;
+  information?: Information | null;
+}

package/src/IEnriched.ts

@@ -0,0 +1,11 @@
+import type { Enrichment } from "./Enrichment.ts";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+
+export interface IEnriched<T> {
+  addEnriched<TRelated extends object>(
+    enrichment: Enrichment,
+    via: IReadonlyRepository<TRelated>,
+    strategy?: IReadonlyEnrichmentStrategy<T & object>,
+  ): this;
+}

package/src/IReader.ts

@@ -0,0 +1,8 @@
+export interface IReader<T = unknown> {
+  readonly current: T | undefined;
+  next(): Promise<boolean>;
+  nextResult(): Promise<boolean>;
+  read(): AsyncIterable<T>;
+  dispose(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+}

package/src/IReadonlyEnrichmentStrategy.ts

@@ -0,0 +1,19 @@
+import type { Enrichment } from "./Enrichment.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+import type { Row } from "./Row.ts";
+
+export interface IReadonlyEnrichmentStrategy<T extends object> {
+  apply<TRelated extends object>(
+    via: IReadonlyRepository<TRelated>,
+    enrichment: Enrichment,
+    parents: T[],
+    sources?: (Row | undefined)[],
+  ): Promise<void>;
+  applyLinked<TRelated extends object, TLink extends object>(
+    via: IReadonlyRepository<TRelated>,
+    link: IReadonlyRepository<TLink>,
+    enrichment: Enrichment,
+    parents: T[],
+    sources?: (Row | undefined)[],
+  ): Promise<void>;
+}

package/src/IReadonlyRepository.ts

@@ -0,0 +1,21 @@
+import type { Parameter } from "./Parameter.ts";
+import type { IExecuteStoredProcedureStatement } from "./statements/IExecuteStoredProcedureStatement.ts";
+import type { ISelectStatement } from "./statements/ISelectStatement.ts";
+import type { IRepository } from "./IRepository.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+
+export type ReadQuery = ISelectStatement | IWhere | IExecuteStoredProcedureStatement;
+
+export interface IReadonlyRepository<T = unknown> extends IRepository<T> {
+  readSingle(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): Promise<T | undefined>;
+  read(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<T>;
+}

package/src/IRepository.ts

@@ -0,0 +1,5 @@
+import type { Constructable } from "./converters/Constructable.ts";
+
+export interface IRepository<T = unknown> {
+  readonly type: Constructable<T>;
+}

package/src/IRepositoryFactory.ts

@@ -0,0 +1,8 @@
+import type { Constructable } from "./converters/Constructable.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+import type { IRepository } from "./IRepository.ts";
+
+export interface IRepositoryFactory {
+  register(repository: IRepository): void;
+  create<T>(type: Constructable<T>): IReadonlyRepository<T>;
+}

package/src/IRepositoryTree.ts

@@ -0,0 +1,5 @@
+import type { IRepositoryTreeNode } from "./IRepositoryTreeNode.ts";
+
+export interface IRepositoryTree {
+  readonly parent: IRepositoryTreeNode;
+}

package/src/IRepositoryTreeNode.ts

@@ -0,0 +1,8 @@
+import type { Enrichment } from "./Enrichment.ts";
+
+export interface IRepositoryTreeNode {
+  readonly value: object;
+  readonly propertyName: string;
+  readonly parent?: IRepositoryTreeNode;
+  readonly enrichment?: Enrichment;
+}

package/src/ITransaction.ts

@@ -0,0 +1,9 @@
+import type { IConnection } from "./IConnection.ts";
+import type { IsolationLevel } from "./IsolationLevel.ts";
+
+export interface ITransaction {
+  readonly connection: IConnection;
+  readonly isolation: IsolationLevel;
+  commit(): Promise<void>;
+  abort(): Promise<void>;
+}

package/src/IUnitOfWork.ts

@@ -0,0 +1,5 @@
+export interface IUnitOfWork {
+  begin(): Promise<void>;
+  commit(): Promise<void>;
+  abort(): Promise<void>;
+}

package/src/IWriteEnrichmentStrategy.ts

@@ -0,0 +1,8 @@
+import type { IRepositoryTree } from "./IRepositoryTree.ts";
+import type { WriteMode } from "./WriteMode.ts";
+
+export interface IWriteEnrichmentStrategy<T> {
+  readonly useTransaction: boolean;
+  persist(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
+  persistBulk?(tree: IRepositoryTree, items: T[], mode: WriteMode): Promise<void>;
+}

package/src/Information.ts

@@ -0,0 +1,5 @@
+export type Information = {
+  descriptions: readonly string[];
+  overrides: readonly string[];
+  changeLogs: readonly string[];
+};

package/src/IsolationLevel.ts

@@ -0,0 +1,8 @@
+export const IsolationLevel = {
+  ReadUncommitted: "readUncommitted",
+  ReadCommitted: "readCommitted",
+  RepeatableRead: "repeatableRead",
+  Serializable: "serializable",
+} as const;
+
+export type IsolationLevel = (typeof IsolationLevel)[keyof typeof IsolationLevel];

package/src/LazyWriteEnrichmentStrategy.ts

@@ -0,0 +1,5 @@
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+
+export class LazyWriteEnrichmentStrategy<T> extends DefaultWriteEnrichmentStrategy<T> {
+  protected override skipUnloaded = true;
+}

package/src/NestedToObjectEnrichmentStrategy.ts

@@ -0,0 +1,33 @@
+import type { Cells } from "./converters/Cell.ts";
+import type { Enrichment } from "./Enrichment.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+import { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.ts";
+import type { TypeMap } from "./mappers/TypeMap.ts";
+import type { Row } from "./Row.ts";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
+
+export class NestedToObjectEnrichmentStrategy<T extends object>
+  extends DefaultReadonlyEnrichmentStrategy<T>
+{
+  private readonly nested: FlatToNestedMapper<T>;
+
+  constructor(typeMap: TypeMap<T>) {
+    super();
+    this.nested = new FlatToNestedMapper(typeMap);
+  }
+
+  override apply<TRelated extends object>(
+    _via: IReadonlyRepository<TRelated>,
+    _enrichment: Enrichment,
+    parents: T[],
+    sources?: (Row | undefined)[],
+  ): Promise<void> {
+    parents.length = 0;
+    for (const item of this.nested.map(rows(sources))) parents.push(item);
+    return Promise.resolve();
+  }
+}
+
+function* rows(sources?: (Row | undefined)[]): Iterable<Cells> {
+  for (const source of sources ?? []) if (source) yield source;
+}

package/src/Parameter.ts

@@ -0,0 +1,8 @@
+import type { Scalar } from "./builders/Scalar.ts";
+import type { ParameterDirection } from "./ParameterDirection.ts";
+
+export interface Parameter<T = Scalar> {
+  name: string;
+  value?: T;
+  direction?: ParameterDirection;
+}

package/src/ParameterDirection.ts

@@ -0,0 +1,9 @@
+export const ParameterDirection = {
+  Input: "input",
+  Output: "output",
+  InputOutput: "inputOutput",
+  ReturnValue: "returnValue",
+} as const;
+
+export type ParameterDirection =
+  (typeof ParameterDirection)[keyof typeof ParameterDirection];

package/src/ProviderCatalog.ts

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

package/src/ProviderNotImplementedError.ts

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

package/src/ProviderNotInstalledError.ts

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

package/src/ReadonlyRepository.ts

@@ -0,0 +1,276 @@
+import type { ICommand } from "./ICommand.ts";
+import { executeReader } from "./ICommand.ts";
+import type { ICommandMiddleware } from "./ICommandMiddleware.ts";
+import type { IConnection } from "./IConnection.ts";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
+import type { Parameter } from "./Parameter.ts";
+import type { ISelectStatement } from "./statements/ISelectStatement.ts";
+import type { IStatement } from "./statements/IStatement.ts";
+import type { IReadonlyRepository, ReadQuery } from "./IReadonlyRepository.ts";
+import type { Row } from "./Row.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import { DatasourceError } from "./DatasourceError.ts";
+import type { Cell, Cells } from "./converters/Cell.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+import { SelectStatement } from "./statements/SelectStatement.ts";
+import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.ts";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+import type { BuiltRepository } from "./BuiltRepository.ts";
+import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.ts";
+import type { TypeConverter } from "./converters/TypeConverter.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+import { IdentityMapper } from "./mappers/IdentityMapper.ts";
+import type { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
+import { StatementMappers } from "./StatementMappers.ts";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
+import type { Enrichment } from "./Enrichment.ts";
+import type { IEnriched } from "./IEnriched.ts";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.ts";
+import { StoredEnrichment } from "./StoredEnrichment.ts";
+
+export const untyped = <T>(): Constructable<T> => Object as never as Constructable<T>;
+
+export type Sourced<T> = { item: T; source?: Row };
+
+const storedEnrichments = new WeakMap<object, StoredEnrichment[]>();
+
+export const enrichmentsOf = (host: object): readonly StoredEnrichment[] | undefined =>
+  storedEnrichments.get(host);
+
+export const isBuilt = <T>(
+  value: IConnection | BuiltRepository<T>,
+): value is BuiltRepository<T> =>
+  "statements" in value && "objectConverter" in value && "propertyMappings" in value;
+
+export const builtOf = <T>(
+  typeOrConnectionOrBuilt: Constructable<T> | IConnection | BuiltRepository<T>,
+  connectionOrOptions?: IConnection | ReadonlyRepositoryMappingOptions<T>,
+): BuiltRepository<T> | undefined =>
+  typeof typeOrConnectionOrBuilt === "function"
+    ? connectionOrOptions === undefined
+      ? undefined
+      : new ReadonlyRepositoryBuilder<T>().parts(
+          connectionOrOptions as IConnection,
+          createReadonlyRepositoryMappingOptions(typeOrConnectionOrBuilt),
+        )
+    : isBuilt(typeOrConnectionOrBuilt)
+      ? typeOrConnectionOrBuilt
+      : new ReadonlyRepositoryBuilder<T>().parts(
+          typeOrConnectionOrBuilt,
+          connectionOrOptions as ReadonlyRepositoryMappingOptions<T>,
+        );
+
+export class ReadonlyRepository<T> implements IReadonlyRepository<T>, IEnriched<T> {
+  readonly type: Constructable<T>;
+  private connection?: IConnection;
+  protected rowConverter?: TypeConverter<Cells, Cells>;
+  protected objectConverter?: TypeConverter<T, Cells>;
+  private entityMappers: IMapper<string, string> = new IdentityMapper();
+  private propertyMappers: IMapper<string, string> = new IdentityMapper();
+  private statementMappers = new StatementMappers(new IdentityMapper(), new IdentityMapper());
+  private readonlyStatements?: ReadonlyRepositoryStatements;
+  private readonly middlewares: ICommandMiddleware[] = [];
+
+  constructor(type: Constructable<T>);
+  constructor(type: Constructable<T>, connection: IConnection);
+  constructor(connection: IConnection, options: ReadonlyRepositoryMappingOptions<T>);
+  constructor(built: BuiltRepository<T>);
+  constructor();
+  constructor(
+    typeOrConnectionOrBuilt?: Constructable<T> | IConnection | BuiltRepository<T>,
+    connectionOrOptions?: IConnection | ReadonlyRepositoryMappingOptions<T>,
+  ) {
+    storedEnrichments.set(this, []);
+    if (typeOrConnectionOrBuilt === undefined) {
+      this.type = untyped();
+      return;
+    }
+    const built = builtOf(typeOrConnectionOrBuilt, connectionOrOptions);
+    if (!built) {
+      this.type = typeOrConnectionOrBuilt as Constructable<T>;
+      return;
+    }
+    this.type = built.type;
+    this.connection = built.connection;
+    this.rowConverter = built.rowConverter;
+    this.objectConverter = built.objectConverter;
+    this.entityMappers = built.entityMapper;
+    this.propertyMappers = built.propertyMappings;
+    this.statementMappers = new StatementMappers(built.entityMapper, built.propertyMappings);
+    this.readonlyStatements = built.statements;
+  }
+
+  addMiddleware = (middleware: ICommandMiddleware): this => {
+    this.middlewares.push(middleware);
+    return this;
+  };
+
+  addEnriched<TRelated extends object>(
+    enrichment: Enrichment,
+    via: IReadonlyRepository<TRelated>,
+    strategy?: IReadonlyEnrichmentStrategy<T & object>,
+  ): this {
+    const chosen = strategy ?? new DefaultReadonlyEnrichmentStrategy<T & object>();
+    this.entries().push(
+      new StoredEnrichment<T & object>(
+        enrichment,
+        (parents, sources) => chosen.apply(via, enrichment, parents, sources),
+      ),
+    );
+    return this;
+  }
+
+  async *read(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<T> {
+    for await (const sourced of this.readTracked(query, parameters, options)) yield sourced.item;
+  }
+
+  async readSingle(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): Promise<T | undefined> {
+    for await (const item of this.read(query, parameters, options)) return item;
+    return undefined;
+  }
+
+  protected get enriched(): boolean {
+    return this.entries().length > 0;
+  }
+
+  protected command = (): ICommand =>
+    this.middlewares.reduce(
+      (command, middleware) => command.addMiddleware(middleware),
+      this.connection!.createCommand(),
+    );
+
+  protected column = (property: string): string => this.statementMappers.column(property);
+
+  protected cell = (
+    property: string,
+    value: Cell,
+    fieldsApplied: boolean,
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): Cell => {
+    const objects = options?.objectConverter ?? this.objectConverter;
+    const field =
+      objects instanceof MetaDataRowTypeConverter ? objects.fields[property] : undefined;
+    return field && !fieldsApplied ? field.reverseConvert(value) : value;
+  };
+
+  private entries = (): StoredEnrichment<T & object>[] =>
+    storedEnrichments.get(this) as StoredEnrichment<T & object>[];
+
+  private mappers = (options?: ReadonlyRepositoryMappingOptions<T>): StatementMappers =>
+    options?.entityMapper === undefined && options?.propertyMappings === undefined
+      ? this.statementMappers
+      : new StatementMappers(
+          options?.entityMapper ?? this.entityMappers,
+          options?.propertyMappings ?? this.propertyMappers,
+        );
+
+  private rowConverterOf = (options?: ReadonlyRepositoryMappingOptions<T>): TypeConverter<Cells, Cells> | undefined =>
+    options?.rowConverter ?? this.rowConverter;
+
+  private objects = (options?: ReadonlyRepositoryMappingOptions<T>): TypeConverter<T, Cells> =>
+    options?.objectConverter ??
+    this.objectConverter ??
+    (() => {
+      throw new DatasourceError("Object converter required");
+    })();
+
+  private async *readTracked(
+    query?: ReadQuery,
+    parameters?: Parameter[],
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<Sourced<T>> {
+    const mappers = this.mappers(options);
+    const statement = mappers.apply(
+      query instanceof ExecuteStoredProcedureStatement ? query : this.readQuery(query, mappers, options),
+      (name, value) => this.cell(name, value, false, options),
+    );
+    const listed =
+      parameters ??
+      (statement instanceof SelectStatement ? statement.where?.parameters : undefined);
+    yield* this.apply(this.readItems(statement, listed, mappers, this.rowConverterOf(options), this.objects(options)));
+  }
+
+  private async *apply(pairs: AsyncIterable<Sourced<T>>): AsyncIterable<Sourced<T>> {
+    if (!this.enriched) {
+      yield* pairs;
+      return;
+    }
+    yield* this.sourced(pairs);
+  }
+
+  private convertObject = (row: Cells, objects: TypeConverter<T, Cells>): T =>
+    objects instanceof MetaDataRowTypeConverter
+      ? objects.convert(row, this.type)
+      : objects.convert(row);
+
+  private async *readItems(
+    query: IStatement | undefined,
+    parameters: Parameter[] | undefined,
+    mappers: StatementMappers,
+    rows: TypeConverter<Cells, Cells> | undefined,
+    objects: TypeConverter<T, Cells>,
+  ): AsyncIterable<Sourced<T>> {
+    const statement = query ?? this.readonlyStatements!.select();
+    const reader = await executeReader(this.command(), statement, parameters);
+    try {
+      while (await reader.next()) {
+        const renamed = this.columnToPropertyName(
+          reader.current ??
+            (() => {
+              throw new DatasourceError("Reader current must be a row");
+            })(),
+          mappers,
+        );
+        yield {
+          item: this.convertObject(rows ? rows.convert(renamed) : renamed, objects),
+          source: renamed,
+        };
+      }
+    } finally {
+      await reader.dispose();
+    }
+  }
+
+  private async *sourced(pairs: AsyncIterable<Sourced<T>>): AsyncIterable<Sourced<T>> {
+    const items: T[] = [];
+    const sources: (Row | undefined)[] = [];
+    for await (const sourced of pairs) {
+      items.push(sourced.item);
+      sources.push(sourced.source);
+    }
+    await this.fill(items as (T & object)[], sources);
+    for (let index = 0; index < items.length; index++)
+      yield { item: items[index]!, source: sources[index] };
+  }
+
+  private fill = async (parents: (T & object)[], sources?: (Row | undefined)[]): Promise<void> => {
+    for (const entry of this.entries()) await entry.apply(parents, sources);
+  };
+
+  private columnToPropertyName = (row: Cells, mappers: StatementMappers): Cells =>
+    Object.fromEntries(Object.entries(row).map(([key, value]) => [mappers.property(key), value]));
+
+  private readQuery = (
+    query: ISelectStatement | IWhere | undefined,
+    mappers: StatementMappers,
+    options?: ReadonlyRepositoryMappingOptions<T>,
+  ): ISelectStatement | undefined =>
+    !query
+      ? this.readonlyStatements?.select()
+      : "where" in query
+        ? query
+        : this.readonlyStatements
+          ? this.readonlyStatements.select(
+              mappers.applyWhere(query, (name, cell) => this.cell(name, cell, false, options))!,
+            )
+          : new SelectStatement({ where: query });
+}

package/src/ReadonlyRepositoryBuilder.ts

@@ -0,0 +1,53 @@
+import type { IConnection } from "./IConnection.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+import { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.ts";
+import type { BuiltRepository } from "./BuiltRepository.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
+import { IdentityMapper } from "./mappers/IdentityMapper.ts";
+
+export class ReadonlyRepositoryBuilder<T = object> {
+  protected entityMapper: IMapper<string, string> = new IdentityMapper();
+  protected propertyMapper: IMapper<string, string> = new IdentityMapper();
+
+  parts = (connection: IConnection, options: ReadonlyRepositoryMappingOptions<T>): BuiltRepository<T> => {
+    const rowConverter = options.rowConverter;
+    const objectConverter = options.objectConverter ?? new MetaDataRowTypeConverter<T>();
+    const entityMapper = options.entityMapper ?? new IdentityMapper<string>();
+    const propertyMappings = options.propertyMappings ?? new IdentityMapper<string>();
+    this.entityMapper = entityMapper;
+    this.propertyMapper = propertyMappings;
+    const entity = entityMapper.map(options.entity ?? options.type?.name ?? "");
+    const names = options.readProperties ?? (options.type ? fieldNamesOf(options.type) : []);
+    if (objectConverter instanceof MetaDataRowTypeConverter && options.type) {
+      const instance = new options.type() as Record<string, string | number | boolean | bigint | null | object>;
+      objectConverter.references.clear();
+      objectConverter.referenceColumns = propertyMappings;
+      for (const name of names) {
+        const value = instance[name];
+        if (value !== null && typeof value === "object" && !Array.isArray(value))
+          objectConverter.references.add(name);
+      }
+    }
+    const columns = [...names]
+      .map((name) => propertyMappings.map(name))
+      .sort((left, right) => left.localeCompare(right));
+    return {
+      connection,
+      rowConverter,
+      objectConverter,
+      propertyMappings,
+      entityMapper,
+      statements: this.statements(entity, columns),
+      ids: this.ids(options),
+      type: options.type ?? (Object as never as Constructable<T>),
+    };
+  };
+
+  protected ids = (_options: ReadonlyRepositoryMappingOptions<T>): string[] => [];
+
+  protected statements = (table: string, columns: string[]): ReadonlyRepositoryStatements =>
+    new ReadonlyRepositoryStatements(table, columns);
+}

package/src/ReadonlyRepositoryMappingOptions.ts

@@ -0,0 +1,15 @@
+import type { Cell, Cells } from "./converters/Cell.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import type { TypeConverter } from "./converters/TypeConverter.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+
+export type ReadonlyRepositoryMappingOptions<T = Cells> = {
+  entity?: string;
+  entityMapper?: IMapper<string, string>;
+  propertyMappings?: IMapper<string, string>;
+  rowConverter?: TypeConverter<Cells, Cells>;
+  objectConverter?: TypeConverter<T, Cells>;
+  type?: Constructable<T>;
+  rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>;
+  readProperties?: string[];
+};

package/src/ReadonlyRepositoryStatements.ts

@@ -0,0 +1,13 @@
+import type { ISelectStatement } from "./statements/ISelectStatement.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import { SelectStatement } from "./statements/SelectStatement.ts";
+
+export class ReadonlyRepositoryStatements {
+  constructor(
+    protected readonly table: string,
+    readonly readColumns: readonly string[],
+  ) {}
+
+  select = (where?: IWhere): ISelectStatement =>
+    new SelectStatement({ table: this.table, fields: [...this.readColumns], where });
+}

package/src/RepositoryAccess.ts

@@ -0,0 +1,14 @@
+import type { IConnection } from "./IConnection.ts";
+import type { ICRUDRepository } from "./ICRUDRepository.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+
+export class RepositoryAccess {
+  constructor(
+    private readonly createRepo: (connection: IConnection) => ICRUDRepository,
+    private readonly createReadonlyRepo: (connection: IConnection) => IReadonlyRepository,
+    private readonly connection: IConnection,
+  ) {}
+
+  create = (): ICRUDRepository => this.createRepo(this.connection);
+  createReadonly = (): IReadonlyRepository => this.createReadonlyRepo(this.connection);
+}