@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/dist/statements/Where.d.ts

@@ -0,0 +1,16 @@
+import type { Parameter } from "../Parameter.js";
+import type { Cell } from "../converters/Cell.js";
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IExpression } from "./IExpression.js";
+import type { IWhere } from "./IWhere.js";
+import type { Comparison } from "./Cmp.js";
+export declare class Where implements IWhere {
+    readonly condition: IExpression;
+    constructor(condition: IExpression);
+    constructor(column: string, op: Comparison, value: Cell);
+    and(column: string, op: Comparison, value: Cell): Where;
+    or(column: string, op: Comparison, value: Cell): Where;
+    map(column: (name: string) => string, value: (name: string, cell: Cell) => Cell): Where;
+    accept: (visitor: IConditionVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/WhereText.d.ts

@@ -0,0 +1,8 @@
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IWhere } from "./IWhere.js";
+export declare class WhereText implements IWhere {
+    private readonly text;
+    constructor(text: string);
+    get rawText(): string;
+    accept: (visitor: IConditionVisitor) => string;
+}

package/dist/statements/index.d.ts

@@ -0,0 +1,75 @@
+export type { IExpression } from "./IExpression.js";
+export type { IStatement } from "./IStatement.js";
+export type { IStatementVisitor } from "./IStatementVisitor.js";
+export type { ICondition } from "./ICondition.js";
+export type { IConditionVisitor } from "./IConditionVisitor.js";
+export type { IWhere } from "./IWhere.js";
+export type { ISelectStatement } from "./ISelectStatement.js";
+export type { IInsertStatement } from "./IInsertStatement.js";
+export type { IUpdateStatement } from "./IUpdateStatement.js";
+export type { IDeleteStatement } from "./IDeleteStatement.js";
+export type { IBulkInsertStatement } from "./IBulkInsertStatement.js";
+export type { IBulkUpdateStatement } from "./IBulkUpdateStatement.js";
+export type { IBulkDeleteStatement } from "./IBulkDeleteStatement.js";
+export type { ICreateTableStatement } from "./ICreateTableStatement.js";
+export type { ICreateIndexStatement } from "./ICreateIndexStatement.js";
+export type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.js";
+export type { IReturnStatement } from "./IReturnStatement.js";
+export type { Column } from "./Column.js";
+export type { ITableConstraint, TableConstraintKind } from "./ITableConstraint.js";
+export { Join } from "./Join.js";
+export type { JoinKind } from "./Join.js";
+export { Aggregate } from "./Aggregate.js";
+export type { SortDirection } from "./OrderBy.js";
+export { OrderBy } from "./OrderBy.js";
+export type { SelectStatementOptions } from "./SelectStatementOptions.js";
+export { Condition } from "./Condition.js";
+export { Operator } from "./Operator.js";
+export { eq, ne, gt, lt, ge, le } from "./Cmp.js";
+export type { Comparison } from "./Cmp.js";
+export { Identifier } from "./Identifier.js";
+export { Literal } from "./Literal.js";
+export { ArrayExpression } from "./ArrayExpression.js";
+export { Where } from "./Where.js";
+export { ExpressionEvaluator } from "./ExpressionEvaluator.js";
+export { StatementEvaluator } from "./StatementEvaluator.js";
+export { WhereText } from "./WhereText.js";
+export { SelectStatement } from "./SelectStatement.js";
+export { StatementParser } from "./StatementParser.js";
+export { StatementTextRenderer } from "./StatementTextRenderer.js";
+export { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
+export { StatementRenderer } from "./StatementRenderer.js";
+export { ExpressionRenderer } from "./ExpressionRenderer.js";
+export { ConditionRenderer } from "./ConditionRenderer.js";
+export { Native, n } from "./Native.js";
+export { Subquery } from "./Subquery.js";
+export { InsertStatement } from "./InsertStatement.js";
+export { UpdateStatement } from "./UpdateStatement.js";
+export { DeleteStatement } from "./DeleteStatement.js";
+export { BulkInsertStatement } from "./BulkInsertStatement.js";
+export { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+export { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+export { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.js";
+export { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.js";
+export { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.js";
+export { CreateTableStatement } from "./CreateTableStatement.js";
+export { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+export { CreateIndexStatement } from "./CreateIndexStatement.js";
+export { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.js";
+export { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.js";
+export { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.js";
+export { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";
+export { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.js";
+export { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.js";
+export { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.js";
+export { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.js";
+export { ColumnDefault } from "./ColumnDefault.js";
+export { NotNull } from "./NotNull.js";
+export { PrimaryKey } from "./PrimaryKey.js";
+export { ForeignKey, ReferentialAction } from "./ForeignKey.js";
+export type { ReferentialAction as ReferentialActionName } from "./ForeignKey.js";
+export { UniqueConstraint } from "./UniqueConstraint.js";
+export { CheckConstraint } from "./CheckConstraint.js";
+export { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+export { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+export { ReturnStatement } from "./ReturnStatement.js";

package/dist/stubs/StubCommand.d.ts

@@ -0,0 +1,15 @@
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { Cells } from "../converters/Cell.js";
+import type { IReader } from "../IReader.js";
+import type { Response } from "../Response.js";
+import type { Parameter } from "../Parameter.js";
+import { CommandMiddlewareHost } from "../CommandMiddlewareHost.js";
+import { Native } from "../statements/Native.js";
+export declare class StubCommand extends CommandMiddlewareHost implements ICommand {
+    readonly provider: string;
+    readonly connection: IConnection;
+    constructor(provider: string, connection: IConnection);
+    executeReaderNative: (text: Native, parameters?: Parameter[]) => Promise<IReader<Cells>>;
+    executeNative: (text: Native, parameters?: Parameter[]) => Promise<Response>;
+}

package/dist/stubs/StubConnection.d.ts

@@ -0,0 +1,13 @@
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { ITransaction } from "../ITransaction.js";
+export declare class StubConnection implements IConnection {
+    readonly provider: string;
+    isOpen: boolean;
+    constructor(provider: string);
+    createCommand: () => ICommand;
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction: () => Promise<ITransaction>;
+}

package/dist/stubs/StubDatasource.d.ts

@@ -0,0 +1,20 @@
+import type { Constructable } from "../converters/Constructable.js";
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { IDatasource } from "../IDatasource.js";
+import type { IReadonlyRepository } from "../IReadonlyRepository.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { RepositoryFactory } from "../RepositoryFactory.js";
+export declare class StubDatasource implements IDatasource {
+    readonly provider: string;
+    private connection?;
+    readonly repositories: RepositoryFactory;
+    constructor(provider: string);
+    private defaultConnection;
+    createConnection: () => Promise<IConnection>;
+    createCommand: (connection?: IConnection) => Promise<ICommand>;
+    createRepository<T>(type: Constructable<T>, connection?: IConnection): ICRUDRepository<T>;
+    createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+    createReadonlyRepository<T>(type: Constructable<T>, connection?: IConnection): IReadonlyRepository<T>;
+    createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+}

package/dist/stubs/StubReader.d.ts

@@ -0,0 +1,11 @@
+import type { IReader } from "../IReader.js";
+export declare class StubReader<T = unknown> implements IReader<T> {
+    readonly provider: string;
+    current: T | undefined;
+    constructor(provider: string);
+    next(): Promise<boolean>;
+    read(): AsyncIterable<T>;
+    nextResult(): Promise<boolean>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}

package/dist/stubs/StubRepository.d.ts

@@ -0,0 +1,22 @@
+import type { Scalar } from "../builders/Scalar.js";
+import type { Cells } from "../converters/Cell.js";
+import type { Constructable } from "../converters/Constructable.js";
+import type { IConnection } from "../IConnection.js";
+import type { Parameter } from "../Parameter.js";
+import type { IExecuteStoredProcedureStatement } from "../statements/IExecuteStoredProcedureStatement.js";
+import type { ISelectStatement } from "../statements/ISelectStatement.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { ReadonlyRepository } from "../ReadonlyRepository.js";
+import type { ReadonlyRepositoryMappingOptions } from "../ReadonlyRepositoryMappingOptions.js";
+import type { Response } from "../Response.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class StubRepository<T = unknown> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+    readonly provider: string;
+    readonly ids: readonly string[];
+    constructor(provider: string, _connection: IConnection, type?: Constructable<T>);
+    read(_query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement, _parameters?: Parameter[], _options?: ReadonlyRepositoryMappingOptions<T>): AsyncIterable<T>;
+    create: (_item: T) => Promise<T>;
+    update: (_item: T, _byWhere?: IWhere) => Promise<Response>;
+    delete: (_item: T, _byWhere?: IWhere) => Promise<Response>;
+    readSingleById: (_id: Scalar | Cells) => Promise<T | undefined>;
+}

package/dist/stubs/StubTransaction.d.ts

@@ -0,0 +1,10 @@
+import type { IConnection } from "../IConnection.js";
+import type { ITransaction } from "../ITransaction.js";
+export declare class StubTransaction implements ITransaction {
+    readonly provider: string;
+    readonly connection: IConnection;
+    readonly isolation: "readCommitted";
+    constructor(provider: string, connection: IConnection);
+    commit: () => Promise<void>;
+    abort: () => Promise<void>;
+}

package/dist/stubs/createStubDatasource.d.ts

@@ -0,0 +1,2 @@
+import { StubDatasource } from "./StubDatasource.js";
+export declare const createStubDatasource: (provider: string) => StubDatasource;

package/dist/stubs/index.d.ts

@@ -0,0 +1,7 @@
+export { createStubDatasource } from "./createStubDatasource.js";
+export { StubCommand } from "./StubCommand.js";
+export { StubConnection } from "./StubConnection.js";
+export { StubDatasource } from "./StubDatasource.js";
+export { StubReader } from "./StubReader.js";
+export { StubRepository } from "./StubRepository.js";
+export { StubTransaction } from "./StubTransaction.js";

package/dist/stubs/notImplemented.d.ts

@@ -0,0 +1 @@
+export declare const notImplemented: (provider: string) => never;

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@deterministic-code/datasources",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./mocks": {
+      "types": "./dist/mocks/index.d.ts",
+      "import": "./src/mocks/index.ts",
+      "default": "./src/mocks/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/ArrayReader.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { ArrayReader } from "./index.ts";
+
+describe("ArrayReader", () => {
+  it("walks an array including the empty case", async () => {
+    const empty = new ArrayReader([]);
+    expect(empty.current).toBeUndefined();
+    expect(await empty.next()).toBe(false);
+    expect(empty.current).toBeUndefined();
+
+    const reader = new ArrayReader([{ id: 1 }, { id: 2 }]);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 1 });
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 2 });
+    expect(await reader.next()).toBe(false);
+    expect(reader.current).toBeUndefined();
+    expect(await reader.nextResult()).toBe(false);
+    expect(await Array.fromAsync(new ArrayReader(["a", "b"]).read())).toEqual(["a", "b"]);
+    await reader.dispose();
+    await reader[Symbol.asyncDispose]();
+  });
+});

package/src/ArrayReader.ts

@@ -0,0 +1,32 @@
+import type { IReader } from "./IReader.ts";
+import { readerToAsyncIterable } from "./readerToAsyncIterable.ts";
+
+export class ArrayReader<T = unknown> implements IReader<T> {
+  private index = -1;
+  current: T | undefined = undefined;
+
+  constructor(private readonly rows: readonly T[]) {}
+
+  async next(): Promise<boolean> {
+    this.index += 1;
+    if (this.index < this.rows.length) {
+      this.current = this.rows[this.index];
+      return true;
+    }
+    this.current = undefined;
+    return false;
+  }
+
+  read(): AsyncIterable<T> {
+    return readerToAsyncIterable(this);
+  }
+
+  async nextResult(): Promise<boolean> {
+    this.current = undefined;
+    return false;
+  }
+
+  async dispose(): Promise<void> {}
+
+  [Symbol.asyncDispose] = (): Promise<void> => this.dispose();
+}

package/src/BatchCommandIBulkWriteStrategy.ts

@@ -0,0 +1,228 @@
+import type { CRUDRepository } from "./CRUDRepository.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+import type { Response } from "./Response.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import type { BulkCommand } from "./BulkCommand.ts";
+import { Native } from "./statements/Native.ts";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
+import { execute, type ICommand } from "./ICommand.ts";
+import type { Cell, Cells } from "./converters/Cell.ts";
+import type { Field } from "./builders/Field.ts";
+import type { Scalar } from "./builders/Scalar.ts";
+import type { IExpression } from "./statements/IExpression.ts";
+import {
+  BulkDeleteStatement,
+  BulkInsertStatement,
+  BulkUpdateStatement,
+  DefaultStatementTextRenderer,
+  Literal,
+  Operator,
+  Where,
+} from "./statements/index.ts";
+import { DatasourceError } from "./DatasourceError.ts";
+import { repositoryParts } from "./CRUDRepositoryBuilder.ts";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+import type { Parameter } from "./Parameter.ts";
+import { afterBulkWrite } from "./BulkWriteEnrichment.ts";
+
+const empty = (): Response => ({ result: null, rowsAffected: 0 });
+const budget = 8000;
+const maxRows = 250;
+
+const assigned = (value: Cell): boolean =>
+  value !== null && value !== "" && value !== 0 && value !== 0n;
+
+const columnsOf = (rows: readonly { name: string }[][]): string[] => {
+  const seen = new Set<string>();
+  const columns: string[] = [];
+  for (const row of rows)
+    for (const field of row)
+      if (!seen.has(field.name)) {
+        seen.add(field.name);
+        columns.push(field.name);
+      }
+  return columns;
+};
+
+type Inserted = { table: string; fields: Parameter[] };
+type Updated = { table: string; fields: Parameter[]; ids: Parameter[] };
+type Deleted = { table: string; ids: Parameter[] };
+
+export class BatchCommandIBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
+  repo!: CRUDRepository<T>;
+  command!: ICommand;
+  options!: CRUDRepositoryOptions<T>;
+  private cached?: ReturnType<typeof repositoryParts>["statements"];
+
+  attach = (command: ICommand, options: CRUDRepositoryOptions<T>): void => {
+    this.command = command;
+    this.options = options;
+  };
+
+  create = (items: T[]): Promise<Response> => this.then(this.writeCreates(items), items, "create");
+
+  update = (items: T[], byWhere: IWhere | undefined): Promise<Response> =>
+    this.then(
+      byWhere ? this.sendEach(items.map((item) => this.updateCommand(item, byWhere))) : this.writeUpdates(items),
+      items,
+      "update",
+    );
+
+  delete = (items: T[], byWhere: IWhere | undefined): Promise<Response> =>
+    this.then(
+      byWhere ? this.sendEach(items.map((item) => this.deleteCommand(item, byWhere))) : this.writeDeletes(items),
+      items,
+      "delete",
+    );
+
+  private then = async (write: Promise<Response>, items: T[], mode: "create" | "update" | "delete"): Promise<Response> => {
+    const response = await write;
+    await afterBulkWrite(this.repo, this.options, items, mode);
+    return response;
+  };
+
+  private writeCreates = async (items: T[]): Promise<Response> => {
+    if (items.length === 0) return empty();
+    const rows = items.map(this.mappedInsert);
+    const columns = columnsOf(rows.map((row) => row.fields));
+    return this.chunked(rows, columns.length, (chunk) => {
+      const statement = new BulkInsertStatement(
+        rows[0]!.table,
+        columns,
+        chunk.map((row) => row.fields),
+      );
+      return execute(this.command, statement, statement.parameters);
+    });
+  };
+
+  private writeUpdates = async (items: T[]): Promise<Response> => {
+    if (items.length === 0) return empty();
+    const rows = items.map(this.mappedUpdate);
+    const set = columnsOf(rows.map((row) => row.fields));
+    const ids = columnsOf(rows.map((row) => row.ids));
+    return this.chunked(rows, set.length + ids.length, (chunk) => {
+      const statement = new BulkUpdateStatement(rows[0]!.table, set, ids, chunk);
+      return execute(this.command, statement, statement.parameters);
+    });
+  };
+
+  private writeDeletes = async (items: T[]): Promise<Response> => {
+    if (items.length === 0) return empty();
+    const rows = items.map(this.mappedDelete);
+    const ids = columnsOf(rows.map((row) => row.ids));
+    return this.chunked(rows, ids.length, (chunk) => {
+      const statement = new BulkDeleteStatement(
+        rows[0]!.table,
+        ids,
+        chunk.map((row) => row.ids),
+      );
+      return execute(this.command, statement, statement.parameters);
+    });
+  };
+
+  private chunked = async <TRow>(
+    rows: TRow[],
+    width: number,
+    write: (chunk: TRow[]) => Promise<Response>,
+  ): Promise<Response> => {
+    const size = Math.min(maxRows, Math.max(1, Math.floor(budget / Math.max(1, width))));
+    let rowsAffected = 0;
+    for (let at = 0; at < rows.length; at += size) rowsAffected += (await write(rows.slice(at, at + size))).rowsAffected;
+    return { result: null, rowsAffected };
+  };
+
+  private sendEach = async (commands: BulkCommand[]): Promise<Response> => {
+    let rowsAffected = 0;
+    for (const command of commands)
+      rowsAffected += (await this.command.executeNative(new Native(command.text), command.parameters)).rowsAffected;
+    return { result: null, rowsAffected };
+  };
+
+  private mappedInsert = (item: T): Inserted => {
+    const record = this.reverse(item);
+    const statement = this.statements().insert(
+      this.fields(record, (col) => !this.ids.includes(col) || assigned(record[col] ?? null)),
+    );
+    return { table: statement.table, fields: statement.fields };
+  };
+
+  private mappedUpdate = (item: T): Updated => {
+    const record = this.reverse(item);
+    const fields = this.fields(record, (col) => !this.ids.includes(col));
+    if (fields.length === 0) throw new DatasourceError("Update requires at least one non-Id field");
+    const statement = this.statements().update(fields, this.idsWhere(record), (name, value) =>
+      this.cell(name, value, true),
+    );
+    return { table: statement.table, fields: statement.fields, ids: statement.where?.parameters ?? [] };
+  };
+
+  private mappedDelete = (item: T): Deleted => {
+    const record = this.reverse(item);
+    const statement = this.statements().delete(this.idsWhere(record), (name, value) => this.cell(name, value, true));
+    return { table: statement.table, ids: statement.where?.parameters ?? [] };
+  };
+
+  private updateCommand = (item: T, byWhere?: IWhere): BulkCommand => {
+    const record = this.reverse(item);
+    const fields = this.fields(record, (col) => !this.ids.includes(col));
+    if (fields.length === 0) throw new DatasourceError("Update requires at least one non-Id field");
+    const statement = this.statements().update(fields, byWhere ?? this.idsWhere(record), (name, value) =>
+      this.cell(name, value, byWhere === undefined),
+    );
+    return { text: DefaultStatementTextRenderer.instance.render(statement), parameters: statement.parameters };
+  };
+
+  private deleteCommand = (item: T, byWhere?: IWhere): BulkCommand => {
+    const record = this.reverse(item);
+    const statement = this.statements().delete(byWhere ?? this.idsWhere(record), (name, value) =>
+      this.cell(name, value, byWhere === undefined),
+    );
+    const listed = statement.where?.parameters ?? [];
+    const parameters: Parameter[] = listed.length
+      ? listed
+      : DefaultStatementTextRenderer.instance.render(statement).includes("$")
+        ? this.fields(record, () => true)
+        : [];
+    return { text: DefaultStatementTextRenderer.instance.render(statement), parameters };
+  };
+
+  private statements = () =>
+    (this.cached ??= repositoryParts(this.command.connection, this.options).statements);
+
+  private get ids(): readonly string[] {
+    return this.options.ids ?? this.repo.ids;
+  }
+
+  private reverse = (item: T): Cells => {
+    const objects = this.options.objectConverter ?? new MetaDataRowTypeConverter<T>();
+    const row = objects.reverseConvert(item);
+    return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
+  };
+
+  private fields = (record: Cells, include: (col: string) => boolean): Field[] =>
+    Object.entries(record)
+      .filter(([key, value]) => include(key) && value !== null && value !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([name, value]) => ({ name, value: this.cell(name, value, true) as Scalar }));
+
+  private cell = (property: string, value: Cell, fieldsApplied: boolean): Cell =>
+    fieldsApplied
+      ? value
+      : this.options.objectConverter instanceof MetaDataRowTypeConverter &&
+          this.options.objectConverter.fields[property]
+        ? this.options.objectConverter.fields[property]!.reverseConvert(value)
+        : value;
+
+  private idsWhere = (record: Cells): IWhere => {
+    const parts: IExpression[] = this.ids.map((col) => {
+      if (!Object.prototype.hasOwnProperty.call(record, col))
+        throw new DatasourceError(`Missing Id value "${col}"`);
+      return new Operator.Equals(col, record[col] as Scalar);
+    });
+    return new Where(
+      parts.length === 0
+        ? new Operator.Equals(new Literal(1), new Literal(1))
+        : parts.reduce((left, right) => new Operator.And(left, right)),
+    );
+  };
+}

package/src/BuiltRepository.ts

@@ -0,0 +1,17 @@
+import type { IConnection } from "./IConnection.ts";
+import type { 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";
+import type { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
+
+export type BuiltRepository<T = Cells> = {
+  connection: IConnection;
+  rowConverter?: TypeConverter<Cells, Cells>;
+  objectConverter: TypeConverter<T, Cells>;
+  propertyMappings: IMapper<string, string>;
+  entityMapper: IMapper<string, string>;
+  statements: ReadonlyRepositoryStatements;
+  ids: string[];
+  type: Constructable<T>;
+};