@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/CRUDRepository.test.ts

@@ -0,0 +1,420 @@
+import { describe, expect, it } from "vitest";
+import { MemoryDriver } from "@datasources/memory";
+import { collectAsync } from "./collectAsync.ts";
+import { CRUDRepository } from "./CRUDRepository.ts";
+import { CascadeDeleteUpdateEnrichmentStrategy } from "./CascadeDeleteUpdateEnrichmentStrategy.ts";
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+import { ReadonlyRepository } from "./ReadonlyRepository.ts";
+import type { IConnection } from "./IConnection.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.ts";
+import type { Scalar } from "./builders/Scalar.ts";
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.ts";
+import { ChangeCasingMapper } from "./mappers/ChangeCasingMapper.ts";
+import { DictionaryMapper } from "./mappers/DictionaryMapper.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+import { TransformMapper } from "./mappers/TransformMapper.ts";
+
+class UserType {
+  Id = 0;
+  Name = "";
+}
+
+class Pref {
+  Locale = "";
+  Timezone = "";
+}
+
+class Setting {
+  Id = 0;
+  ParentId = 0;
+  Key = "";
+  Value = "";
+}
+
+class PrefRow {
+  Id = 0;
+  ParentId = 0;
+  Key = "";
+  Locale = "";
+  Timezone = "";
+}
+
+class Host {
+  Id = 0;
+  Label = "";
+  Settings: Record<string, string> = {};
+  Prefs: Record<string, Pref> = {};
+}
+
+class Parent {
+  Id = 0;
+  Type = new UserType();
+  TypeName = "";
+  Children: Child[] = [];
+}
+
+class Child {
+  Id = 0;
+  ParentId = 0;
+  Type = new UserType();
+  TypeName = "";
+  Label = "";
+  Notes: Note[] = [];
+}
+
+class Note {
+  Id = 0;
+  ChildId = 0;
+  Text = "";
+}
+
+class Tagged {
+  Id = 0;
+  Label = "";
+  Tags: Tag[] = [];
+}
+
+class Tag {
+  Id = 0;
+  Name = "";
+}
+
+class ParentTag {
+  Id = 0;
+  ParentId = 0;
+  TagId = 0;
+}
+
+class SkipDelete<T extends object> extends DeleteEnrichmentStrategy<T> {
+  deleteChildren(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  deleteLinked(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+type Seed = Record<string, Scalar>;
+
+const snake = new ChangeCasingMapper("pascalCase", "snakeCase");
+const references = new DictionaryMapper<string>([["Type", "type_id"]]);
+const columns: IMapper<string, string> = new TransformMapper(
+  (name) => {
+    const mapped = references.map(name);
+    return mapped !== name ? mapped : snake.map(name);
+  },
+  (name) => {
+    const from = references.reverseMap(name);
+    return from !== name ? from : snake.reverseMap(name);
+  },
+);
+
+const repo = <T extends object>(
+  type: new () => T,
+  connection: IConnection,
+  write?: IWriteEnrichmentStrategy<T>,
+) => new CRUDRepository<T>(connection, { type, propertyMappings: columns, write });
+
+const read = <T extends object>(type: new () => T, connection: IConnection) =>
+  new ReadonlyRepository(connection, { type, propertyMappings: columns });
+
+const setup = async (rows: Seed[] = []): Promise<IConnection> => {
+  const connection = new MemoryDriver().connection();
+  await connection.open();
+  for (const row of rows) {
+    const response = await connection.createCommand().execute(
+      "insert",
+      Object.entries(row).map(([name, value]) => ({ name, value })),
+    );
+    if (typeof response.result === "number") row.id = response.result;
+  }
+  return connection;
+};
+
+const relate = (
+  parentsRepo: CRUDRepository<Parent>,
+  typesRepo: IReadonlyRepository<UserType>,
+  childrenRepo: IReadonlyRepository<Child>,
+) => {
+  parentsRepo.addEnriched({ destinationProperty: "TypeName", sourceProperty: "Type", relatedKey: "Id", relatedProperty: "Name" }, typesRepo);
+  parentsRepo.addEnriched({ destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" }, childrenRepo);
+};
+
+describe("CRUDRepository", () => {
+  it("round-trips string and object dictionaries", async () => {
+    const connection = await setup();
+    const hostsRepo = repo(Host, connection);
+    const settingsRepo = repo(Setting, connection);
+    const prefsRepo = repo(PrefRow, connection);
+    hostsRepo.addEnriched(
+      { destinationProperty: "Settings", sourceProperty: "Id", relatedKey: "ParentId", relatedProperty: "Value", type: "dictionary" },
+      settingsRepo,
+    );
+    hostsRepo.addEnriched(
+      { destinationProperty: "Prefs", sourceProperty: "Id", relatedKey: "ParentId", type: "dictionary" },
+      prefsRepo,
+    );
+    const created = await hostsRepo.create(
+      Object.assign(new Host(), {
+        Label: "ada",
+        Settings: { theme: "dark", density: "comfortable" },
+        Prefs: {
+          home: Object.assign(new Pref(), { Locale: "en-GB", Timezone: "Europe/London" }),
+          travel: Object.assign(new Pref(), { Locale: "en-US", Timezone: "America/New_York" }),
+        },
+      }),
+    );
+    expect(created.Id).toBeGreaterThan(0);
+    const loaded = await hostsRepo.readSingle();
+    expect(loaded?.Settings).toEqual({ theme: "dark", density: "comfortable" });
+    expect(loaded?.Prefs.home).toEqual({ Locale: "en-GB", Timezone: "Europe/London" });
+    expect(loaded?.Prefs.travel).toEqual({ Locale: "en-US", Timezone: "America/New_York" });
+    await hostsRepo.update(
+      Object.assign(new Host(), {
+        Id: created.Id,
+        Label: "ada",
+        Settings: { theme: "light", locale: "en" },
+        Prefs: {
+          home: Object.assign(new Pref(), { Locale: "en-GB", Timezone: "Europe/Paris" }),
+          work: Object.assign(new Pref(), { Locale: "en-US", Timezone: "America/New_York" }),
+        },
+      }),
+    );
+    const updated = await hostsRepo.readSingle();
+    expect(updated?.Settings).toEqual({ theme: "light", locale: "en" });
+    expect(updated?.Prefs.home).toEqual({ Locale: "en-GB", Timezone: "Europe/Paris" });
+    expect(updated?.Prefs.work).toEqual({ Locale: "en-US", Timezone: "America/New_York" });
+    expect(updated?.Prefs.travel).toBeUndefined();
+  });
+
+  it("creates children, stamps FK, and skips select", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(Parent, connection);
+    const typesRepo = repo(UserType, connection);
+    const childrenRepo = repo(Child, connection);
+    const type = await typesRepo.create(Object.assign(new UserType(), { Name: "person" }));
+    expect(type.Id).toBeGreaterThan(0);
+    relate(parentsRepo, typesRepo, childrenRepo);
+    const created = await parentsRepo.create(Object.assign(new Parent(), {
+      Type: Object.assign(new UserType(), { Id: type.Id }),
+      Children: [
+        Object.assign(new Child(), { Label: "a" }),
+        Object.assign(new Child(), { Label: "b" }),
+      ],
+    }));
+    expect(created.Id).toBeGreaterThan(0);
+    const parent = (await collectAsync(parentsRepo.read()))[0];
+    const children = await collectAsync(childrenRepo.read());
+    expect(parent?.Id).toBe(created.Id);
+    expect(children).toHaveLength(2);
+    expect(children.every((child) => child.ParentId === parent?.Id)).toBe(true);
+    expect(children.map((child) => child.Label)).toEqual(["a", "b"]);
+    expect((await typesRepo.readSingle())?.Name).toBe("person");
+  });
+
+  it("applies generated parent id before child FKs", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(Parent, connection);
+    const childrenRepo = repo(Child, connection);
+    parentsRepo.addEnriched({ destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" }, childrenRepo);
+    const created = await parentsRepo.create(Object.assign(new Parent(), {
+      Children: [Object.assign(new Child(), { Label: "n" })],
+    }));
+    expect(created.Id).toBeGreaterThan(0);
+    const parent = await parentsRepo.readSingle();
+    const child = await childrenRepo.readSingle();
+    expect(parent?.Id).toBe(created.Id);
+    expect(child?.ParentId).toBe(parent?.Id);
+  });
+
+  it("update replace-syncs children", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(Parent, connection);
+    const childrenRepo = repo(Child, connection);
+    const parent = await parentsRepo.create(new Parent());
+    expect(parent.Id).toBeGreaterThan(0);
+    const kept = await childrenRepo.create(Object.assign(new Child(), { ParentId: parent.Id, Label: "a" }));
+    expect(kept.Id).toBeGreaterThan(0);
+    const dropped = await childrenRepo.create(Object.assign(new Child(), { ParentId: parent.Id, Label: "b" }));
+    expect(dropped.Id).toBeGreaterThan(0);
+    parentsRepo.addEnriched({ destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" }, childrenRepo);
+    const updated = await parentsRepo.update(Object.assign(new Parent(), {
+      Id: parent.Id,
+      Children: [
+        Object.assign(new Child(), { Id: kept.Id, Label: "aa" }),
+        Object.assign(new Child(), { Label: "c" }),
+      ],
+    }));
+    expect(updated.rowsAffected).toBe(1);
+    const children = await collectAsync(childrenRepo.read());
+    expect(children).toHaveLength(2);
+    expect(children.find((child) => child.Id === kept?.Id)?.Label).toBe("aa");
+    expect(children.find((child) => child.Id !== kept?.Id)?.Label).toBe("c");
+    expect(children.every((child) => child.ParentId === parent?.Id)).toBe(true);
+  });
+
+  it("cascade update deletes children and recreates", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(
+      Parent,
+      connection,
+      new DefaultWriteEnrichmentStrategy(undefined, new CascadeDeleteUpdateEnrichmentStrategy()),
+    );
+    const childrenRepo = repo(Child, connection);
+    const notesRepo = repo(Note, connection);
+    const parent = await parentsRepo.create(new Parent());
+    expect(parent.Id).toBeGreaterThan(0);
+    const child = await childrenRepo.create(Object.assign(new Child(), { ParentId: parent.Id, Label: "a" }));
+    expect(child.Id).toBeGreaterThan(0);
+    const other = await childrenRepo.create(Object.assign(new Child(), { Label: "other" }));
+    expect(other.Id).toBeGreaterThan(0);
+    const note = await notesRepo.create(Object.assign(new Note(), { ChildId: child.Id, Text: "n" }));
+    expect(note.Id).toBeGreaterThan(0);
+    childrenRepo.addEnriched({ destinationProperty: "Notes", sourceProperty: "Id", relatedKey: "ChildId", type: "list" }, notesRepo);
+    parentsRepo.addEnriched({ destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" }, childrenRepo);
+    const updated = await parentsRepo.update(Object.assign(new Parent(), {
+      Id: parent.Id,
+      Children: [Object.assign(new Child(), { Id: child.Id, Label: "fresh" })],
+    }));
+    expect(updated.rowsAffected).toBe(1);
+    const created = (await collectAsync(childrenRepo.read())).find((row) => row.Label === "fresh");
+    expect(created?.Id).toBe(child?.Id);
+    expect(created?.Label).toBe("fresh");
+    expect(created?.ParentId).toBe(parent?.Id);
+    expect(await collectAsync(notesRepo.read())).toEqual([]);
+  });
+
+  it("cascade update replaces links and keeps related rows", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(
+      Tagged,
+      connection,
+      new DefaultWriteEnrichmentStrategy(undefined, new CascadeDeleteUpdateEnrichmentStrategy()),
+    );
+    const tagsRepo = repo(Tag, connection);
+    const linksRepo = repo(ParentTag, connection);
+    const parent = await parentsRepo.create(new Tagged());
+    expect(parent.Id).toBeGreaterThan(0);
+    const keep = await tagsRepo.create(Object.assign(new Tag(), { Name: "keep" }));
+    expect(keep.Id).toBeGreaterThan(0);
+    const drop = await tagsRepo.create(Object.assign(new Tag(), { Name: "drop" }));
+    expect(drop.Id).toBeGreaterThan(0);
+    const oldLink = await linksRepo.create(Object.assign(new ParentTag(), { ParentId: parent.Id, TagId: keep.Id }));
+    expect(oldLink.Id).toBeGreaterThan(0);
+    const droppedLink = await linksRepo.create(Object.assign(new ParentTag(), { ParentId: parent.Id, TagId: drop.Id }));
+    expect(droppedLink.Id).toBeGreaterThan(0);
+    const leftover = await linksRepo.create(Object.assign(new ParentTag(), { TagId: keep.Id }));
+    expect(leftover.Id).toBeGreaterThan(0);
+    parentsRepo.addLinked(
+      { destinationProperty: "Tags", sourceProperty: "Id", relatedKey: "Id", association: { parent: "ParentId", related: "TagId" } },
+      tagsRepo,
+      linksRepo,
+    );
+    const updated = await parentsRepo.update(Object.assign(new Tagged(), {
+      Id: parent.Id,
+      Label: "p",
+      Tags: [Object.assign(new Tag(), { Id: keep.Id })],
+    }));
+    expect(updated.rowsAffected).toBe(1);
+    const links = (await collectAsync(linksRepo.read())).filter((link) => link.ParentId === parent.Id);
+    expect(links).toHaveLength(1);
+    expect(links[0]?.TagId).toBe(keep.Id);
+    expect(links[0]?.ParentId).toBe(parent.Id);
+    expect(links[0]?.Id).not.toBe(oldLink?.Id);
+    expect(await collectAsync(tagsRepo.read())).toHaveLength(2);
+  });
+
+  it("delete cascades children then parent", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(Parent, connection);
+    const childrenRepo = repo(Child, connection);
+    const notesRepo = repo(Note, connection);
+    const parent = await parentsRepo.create(new Parent());
+    expect(parent.Id).toBeGreaterThan(0);
+    const child = await childrenRepo.create(Object.assign(new Child(), { ParentId: parent.Id, Label: "a" }));
+    expect(child.Id).toBeGreaterThan(0);
+    const note = await notesRepo.create(Object.assign(new Note(), { ChildId: child.Id, Text: "n" }));
+    expect(note.Id).toBeGreaterThan(0);
+    const other = await notesRepo.create(Object.assign(new Note(), { Text: "other" }));
+    expect(other.Id).toBeGreaterThan(0);
+    childrenRepo.addEnriched({ destinationProperty: "Notes", sourceProperty: "Id", relatedKey: "ChildId", type: "list" }, notesRepo);
+    parentsRepo.addEnriched({ destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" }, childrenRepo);
+    const removed = await parentsRepo.delete(Object.assign(new Parent(), { Id: parent.Id }));
+    expect(removed.rowsAffected).toBe(1);
+    expect(await collectAsync(parentsRepo.read())).toEqual([]);
+    expect(await collectAsync(childrenRepo.read())).toEqual([]);
+    expect((await notesRepo.readSingle())?.Text).toBe("other");
+  });
+
+  it("delete strategy can skip children", async () => {
+    const connection = await setup();
+    const childrenRepo = repo(Child, connection);
+    const parentsRepo = repo(Parent, connection, new DefaultWriteEnrichmentStrategy(new SkipDelete()));
+    const parent = await parentsRepo.create(new Parent());
+    expect(parent.Id).toBeGreaterThan(0);
+    const child = await childrenRepo.create(Object.assign(new Child(), { ParentId: parent.Id, Label: "a" }));
+    expect(child.Id).toBeGreaterThan(0);
+    parentsRepo.addEnriched({ destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" }, childrenRepo);
+    const removed = await parentsRepo.delete(Object.assign(new Parent(), { Id: parent.Id }));
+    expect(removed.rowsAffected).toBe(1);
+    expect(await collectAsync(parentsRepo.read())).toEqual([]);
+    expect((await childrenRepo.readSingle())?.Label).toBe("a");
+  });
+
+  it("writes nested many and skips nested select", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(Parent, connection);
+    const childrenRepo = repo(Child, connection);
+    const notesRepo = repo(Note, connection);
+    const childTypesRepo = repo(UserType, connection);
+    const home = await childTypesRepo.create(Object.assign(new UserType(), { Name: "home" }));
+    expect(home.Id).toBeGreaterThan(0);
+    childrenRepo.addEnriched({ destinationProperty: "TypeName", sourceProperty: "Type", relatedKey: "Id", relatedProperty: "Name" }, childTypesRepo);
+    childrenRepo.addEnriched({ destinationProperty: "Notes", sourceProperty: "Id", relatedKey: "ChildId", type: "list" }, notesRepo);
+    parentsRepo.addEnriched({ destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" }, childrenRepo);
+    const created = await parentsRepo.create(Object.assign(new Parent(), {
+      Children: [Object.assign(new Child(), {
+        Type: Object.assign(new UserType(), { Id: home.Id }),
+        Label: "a",
+        Notes: [Object.assign(new Note(), { Text: "hi" })],
+      })],
+    }));
+    expect(created.Id).toBeGreaterThan(0);
+    const note = await notesRepo.readSingle();
+    const child = await childrenRepo.readSingle();
+    expect(note?.Text).toBe("hi");
+    expect(note?.ChildId).toBe(child?.Id);
+    expect((await childTypesRepo.readSingle())?.Name).toBe("home");
+  });
+
+  it("throws when many via is readonly", async () => {
+    const connection = await setup();
+    const parentsRepo = repo(Parent, connection);
+    parentsRepo.addEnriched(
+      { destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" },
+      read(Child, connection),
+    );
+    await expect(parentsRepo.create(Object.assign(new Parent(), {
+      Children: [Object.assign(new Child(), { Label: "a" })],
+    }))).rejects.toThrow(/Children/);
+  });
+
+  it("get still enriches", async () => {
+    const org: Seed = { name: "org" };
+    const typesConnection = await setup([org]);
+    const parent: Seed = { type_id: org.id };
+    const connection = await setup([parent]);
+    const parentsRepo = repo(Parent, connection);
+    const childrenConnection = await setup([{ parent_id: parent.id, label: "a" }]);
+    relate(
+      parentsRepo,
+      read(UserType, typesConnection),
+      read(Child, childrenConnection),
+    );
+    const item = await parentsRepo.readSingle();
+    expect(item?.TypeName).toBe("org");
+    expect(item?.Children.map((child) => child.Label)).toEqual(["a"]);
+  });
+});

package/src/CRUDRepository.ts

@@ -0,0 +1,264 @@
+import type { IConnection } from "./IConnection.ts";
+import type { ICRUDRepository } from "./ICRUDRepository.ts";
+import type { Response } from "./Response.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import type { Field } from "./builders/Field.ts";
+import type { Scalar } from "./builders/Scalar.ts";
+import type { IExpression } from "./statements/IExpression.ts";
+import { Literal } from "./statements/Literal.ts";
+import { DefaultStatementTextRenderer, Operator, Where } from "./statements/index.ts";
+import type { Cell, Cells } from "./converters/Cell.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+import { repositoryParts } from "./CRUDRepositoryBuilder.ts";
+import type { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.ts";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
+import { enrichmentsOf, ReadonlyRepository } from "./ReadonlyRepository.ts";
+import type { Enrichment } from "./Enrichment.ts";
+import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.ts";
+import type { IReadonlyRepository } from "./IReadonlyRepository.ts";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
+import { StoredEnrichment } from "./StoredEnrichment.ts";
+import { execute, executeReader } from "./ICommand.ts";
+import { DatasourceError } from "./DatasourceError.ts";
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.ts";
+import { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.ts";
+import type { IRepositoryTree } from "./IRepositoryTree.ts";
+import { RepositoryTree } from "./RepositoryTree.ts";
+import { RepositoryTreeNode } from "./RepositoryTreeNode.ts";
+
+type Props = Record<string, Scalar | object>;
+
+const assigned = (value: Cell): boolean =>
+  value !== null && value !== "" && value !== 0 && value !== 0n;
+
+const fieldsOf = (
+  record: Cells,
+  include: (col: string) => boolean,
+  cell: (property: string, value: Cell, fieldsApplied: boolean) => Cell,
+  enrichmentInto: (name: string) => boolean,
+): Field[] =>
+  Object.entries(record)
+    .filter(([key, value]) => include(key) && !enrichmentInto(key) && value !== null && value !== undefined)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([name, value]) => ({ name, value: cell(name, value, true) as Scalar }));
+
+const isCells = (id: Scalar | Cells): id is Cells => typeof id === "object" && id !== null;
+
+const named = (row: Cells, property: string, sqlColumn: string): Cells => {
+  if (property === sqlColumn || !(sqlColumn in row)) return row;
+  const { [sqlColumn]: cell, ...rest } = row;
+  return { ...rest, [property]: cell };
+};
+
+const identified = (row: Cells, column: string): Cells => {
+  const values = Object.values(row);
+  return column in row || values.length !== 1 ? row : { [column]: values[0] };
+};
+
+const scalarOf = (value: Scalar | object | undefined): Scalar | undefined =>
+  value === undefined || value === null || typeof value === "object" ? undefined : value;
+
+
+export class CRUDRepository<T = Cells>
+  extends ReadonlyRepository<T>
+  implements ICRUDRepository<T>
+{
+  readonly ids: readonly string[];
+  private readonly crudStatements: CRUDRepositoryStatements;
+  private readonly tree: IRepositoryTree;
+  private readonly write: IWriteEnrichmentStrategy<T>;
+  private get useTransaction(): boolean {
+    return this.write.useTransaction;
+  }
+
+  constructor(type: Constructable<T>, connection: IConnection);
+  constructor(connection: IConnection, options: CRUDRepositoryOptions<T>);
+  constructor(
+    typeOrConnection: Constructable<T> | IConnection,
+    connectionOrOptions?: IConnection | CRUDRepositoryOptions<T>,
+  ) {
+    const options = connectionOrOptions as IConnection | CRUDRepositoryOptions<T>;
+    const opened = repositoryParts(typeOrConnection, options);
+    super(opened.built);
+    this.ids = opened.built.ids;
+    this.crudStatements = opened.statements;
+    this.tree = new RepositoryTree(new RepositoryTreeNode(this, ""));
+    this.write = (options as CRUDRepositoryOptions<T>).write ?? new DefaultWriteEnrichmentStrategy<T>();
+  }
+
+  override addEnriched<TRelated extends object>(
+    enrichment: Enrichment,
+    via: IReadonlyRepository<TRelated>,
+    strategy?: IReadonlyEnrichmentStrategy<T & object>,
+  ): this {
+    super.addEnriched(enrichment, via, strategy);
+    const writer = writerOf(via);
+    if (writer) lastEnrichment(this).persist = writer;
+    return this;
+  }
+
+  addLinked<TRelated extends object, TLink extends object>(
+    enrichment: Enrichment,
+    via: IReadonlyRepository<TRelated>,
+    link: ICRUDRepository<TLink>,
+    strategy?: IReadonlyEnrichmentStrategy<T & object>,
+  ): this {
+    const chosen = strategy ?? new DefaultReadonlyEnrichmentStrategy<T & object>();
+    super.addEnriched(enrichment, via, strategy);
+    const stored = lastEnrichment(this) as StoredEnrichment<T & object>;
+    stored.apply = (parents, sources) =>
+      chosen.applyLinked(via, link, enrichment, parents, sources);
+    stored.link = link as ICRUDRepository<object>;
+    return this;
+  }
+
+  create = (item: T): Promise<T> => this.inTransaction(() => this.createCore(item));
+
+  update = (item: T, byWhere?: IWhere): Promise<Response> =>
+    this.inTransaction(() => this.updateCore(item, byWhere));
+
+  delete = (item: T, byWhere?: IWhere): Promise<Response> =>
+    this.inTransaction(() => this.deleteCore(item, byWhere));
+
+  private inTransaction = async <TResult>(write: () => Promise<TResult>): Promise<TResult> => {
+    if (!this.useTransaction) return write();
+    const work = new UnitOfWorkTransaction(this.command().connection);
+    await work.begin();
+    try {
+      const result = await write();
+      await work.commit();
+      return result;
+    } catch (error) {
+      await work.abort();
+      throw error;
+    }
+  };
+
+  private createCore = async (item: T): Promise<T> => {
+    await this.insert(item);
+    if (!this.enriched) return item;
+    await this.write.persist(this.tree, [item], "create");
+    if (this.ids.length !== 1) return item;
+    const id = this.idValue(item);
+    return id === undefined ? item : (await this.readSingleById(id)) ?? item;
+  };
+
+  private updateCore = async (item: T, byWhere?: IWhere): Promise<Response> => {
+    const response = await this.save(item, byWhere);
+    if (this.enriched) await this.write.persist(this.tree, [item], "update");
+    return response;
+  };
+
+  private deleteCore = async (item: T, byWhere?: IWhere): Promise<Response> => {
+    if (this.enriched) await this.write.persist(this.tree, [item], "delete");
+    return this.remove(item, byWhere);
+  };
+
+  readSingleById = async (id: Scalar | Cells): Promise<T | undefined> =>
+    this.readSingle(this.byId(id));
+
+  private insert = async (item: T): Promise<Response> => {
+    const record = this.reverseConvert(item);
+    const fields = fieldsOf(
+      record,
+      (col) => !this.ids.includes(col) || assigned(record[col] ?? null),
+      this.cell,
+      this.enrichmentInto,
+    );
+    const statement = this.crudStatements.insert(fields);
+    const response = await execute(this.command(), statement, statement.fields);
+    if (this.ids.length === 1 && !fields.some((field) => field.name === this.ids[0]))
+      await this.copyInsertedId(item, fields);
+    return response;
+  };
+
+  private copyInsertedId = async (target: T, fields: Field[]): Promise<void> => {
+    void fields;
+    const column = this.ids[0]!;
+    const statement = this.crudStatements.selectInsertedId(column);
+    const sqlColumn = statement.column;
+    const reader = await executeReader(this.command(), statement);
+    try {
+      if (!(await reader.next())) return;
+      const current = reader.current;
+      if (!current) throw new DatasourceError("Reader current must be a row");
+      const row = identified(named(current, column, sqlColumn), column);
+      const cells = this.rowConverter ? this.rowConverter.convert(row) : row;
+      const converted =
+        this.objectConverter instanceof MetaDataRowTypeConverter
+          ? this.objectConverter.convert(cells, this.type)
+          : this.objectConverter!.convert(cells);
+      const value = scalarOf((converted as Props)[column]);
+      if (value !== undefined) (target as Props)[column] = value;
+    } finally {
+      await reader.dispose();
+    }
+  };
+
+  private idValue = (item: T): Scalar | undefined => scalarOf((item as Props)[this.ids[0]!]);
+
+  private save = async (item: T, byWhere?: IWhere): Promise<Response> => {
+    const record = this.reverseConvert(item);
+    const fields = fieldsOf(record, (col) => !this.ids.includes(col), this.cell, this.enrichmentInto);
+    if (fields.length === 0) throw new DatasourceError("Update requires at least one non-Id field");
+    const statement = this.crudStatements.update(
+      fields,
+      byWhere ?? this.idWhere(record),
+      (name, value) => this.cell(name, value, byWhere === undefined),
+    );
+    return execute(this.command(), statement, statement.parameters);
+  };
+
+  private remove = async (item: T, byWhere?: IWhere): Promise<Response> => {
+    const record = this.reverseConvert(item);
+    const statement = this.crudStatements.delete(
+      byWhere ?? this.idWhere(record),
+      (name, value) => this.cell(name, value, byWhere === undefined),
+    );
+    const listed = statement.where?.parameters ?? [];
+    const parameters = listed.length
+      ? listed
+      : DefaultStatementTextRenderer.instance.render(statement).includes("$")
+        ? fieldsOf(record, () => true, this.cell, this.enrichmentInto)
+        : [];
+    return execute(this.command(), statement, parameters);
+  };
+
+  private byId = (id: Scalar | Cells): IWhere => {
+    if (this.ids.length === 0) throw new DatasourceError("ReadSingleById requires an Id column");
+    if (isCells(id)) return this.idWhere(id);
+    if (this.ids.length !== 1)
+      throw new DatasourceError("Composite id requires a row keyed by each Id column");
+    return this.idWhere({ [this.ids[0]!]: id });
+  };
+
+  private reverseConvert = (item: T): Cells => {
+    const row = this.objectConverter!.reverseConvert(item);
+    return this.rowConverter ? this.rowConverter.reverseConvert(row) : row;
+  };
+
+  private idWhere = (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)),
+    );
+  };
+
+  protected enrichmentInto = (name: string): boolean =>
+    enrichmentsOf(this)!.some((entry) => entry.enrichment.destinationProperty === name);
+}
+
+const writerOf = <TRelated extends object>(
+  via: IReadonlyRepository<TRelated>,
+): ICRUDRepository<object> | undefined =>
+  "create" in via && typeof via.create === "function" ? (via as ICRUDRepository<object>) : undefined;
+
+const lastEnrichment = (host: object): StoredEnrichment => enrichmentsOf(host)!.at(-1)!;