@deterministic-code/datasources 0.1.0 → 0.1.1

package/src/edgeCases.test.ts

@@ -0,0 +1,485 @@
+import { describe, expect, it } from "vitest";
+import { MemoryDriver } from "@datasources/memory";
+import { collectAsync } from "./collectAsync.ts";
+import { BulkCRUDRepository } from "./BulkCRUDRepository.ts";
+import { CascadeDeleteEnrichmentStrategy } from "./CascadeDeleteEnrichmentStrategy.ts";
+import { CascadeDeleteUpdateEnrichmentStrategy } from "./CascadeDeleteUpdateEnrichmentStrategy.ts";
+import { CRUDRepository } from "./CRUDRepository.ts";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.ts";
+import { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.ts";
+import { DefaultUpdateEnrichmentStrategy } from "./DefaultUpdateEnrichmentStrategy.ts";
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+import { LazyWriteEnrichmentStrategy } from "./LazyWriteEnrichmentStrategy.ts";
+import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.ts";
+import { HashsetOptimizedReadonlyEnrichmentStrategy } from "./HashsetOptimizedReadonlyEnrichmentStrategy.ts";
+import { NestedToObjectEnrichmentStrategy } from "./NestedToObjectEnrichmentStrategy.ts";
+import { ReadonlyRepository } from "./ReadonlyRepository.ts";
+import { RepositoryTree } from "./RepositoryTree.ts";
+import { RepositoryTreeNode } from "./RepositoryTreeNode.ts";
+import { BatchCommandIBulkWriteStrategy } from "./BatchCommandIBulkWriteStrategy.ts";
+import { SingleCommandIBulkWriteStrategy } from "./SingleCommandIBulkWriteStrategy.ts";
+import { StoredProcedureBulkWriteStrategy } from "./StoredProcedureBulkWriteStrategy.ts";
+import type { Cells } from "./converters/Cell.ts";
+import type { Scalar } from "./builders/Scalar.ts";
+import { TypeConverter } from "./converters/TypeConverter.ts";
+import { MockCommand } from "./mocks/mock-command.ts";
+import { MockConnection } from "./mocks/mock-connection.ts";
+import { MockReader } from "./mocks/mock-reader.ts";
+import { n } from "./statements/Native.ts";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
+import { WhereText } from "./statements/WhereText.ts";
+import { RowTypeConverter } from "./converters/RowTypeConverter.ts";
+import type { WriteMode } from "./WriteMode.ts";
+
+class Item {
+  id = 0;
+  name = "";
+}
+
+type Bag = Record<string, Scalar | object>;
+
+class Plain extends TypeConverter<Item, Cells> {
+  convert = (row: Cells): Item => Object.assign(new Item(), row);
+  reverseConvert = (row: Item): Cells => ({ id: row.id, name: row.name });
+}
+
+class OpenUpdate extends DefaultUpdateEnrichmentStrategy<Item> {
+  stamp = <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined): void =>
+    this.stampCell(related, by, key);
+
+  payload = <TParent extends object>(parent: TParent, into: string): object[] => this.payloadOf(parent, into);
+
+  key = <TItem extends object>(item: TItem, keys: readonly string[]): string => this.keyOf(item, keys);
+}
+
+class OpenCreate extends DefaultCreateEnrichmentStrategy<Item> {
+  payload = <TParent extends object>(parent: TParent, into: string): object[] => this.payloadOf(parent, into);
+}
+
+class DropId extends TypeConverter<Item, Cells> {
+  convert = (row: Cells): Item => Object.assign(new Item(), row);
+  reverseConvert = (): Cells => ({ name: "a" });
+}
+
+const mock = (rows: Cells[] = []) => {
+  const connection = new MockConnection();
+  const command = new MockCommand(connection);
+  command.reader = new MockReader(rows);
+  command.response = { result: 9, rowsAffected: 1 };
+  connection.command = command;
+  return { connection, command };
+};
+
+const enrichment = (into: string, extra: object = {}) =>
+  ({ destinationProperty: into, sourceProperty: "id", relatedKey: "parent_id", type: "list", ...extra });
+
+describe("statement and repository edges", () => {
+  it("names a native fragment", () => {
+    expect(n("select 1").text).toBe("select 1");
+  });
+
+  it("reads without a connection and without statements", async () => {
+    const repo = new ReadonlyRepository();
+    await expect(collectAsync(repo.read(new WhereText("id = $id")))).rejects.toThrow();
+    await expect(collectAsync(repo.read())).rejects.toThrow();
+  });
+
+  it("converts with a plain object converter", async () => {
+    const { connection, command } = mock([{ generated: 9 }]);
+    const repo = new CRUDRepository<Item>(connection, {
+      type: Item,
+      entity: "items",
+      objectConverter: new Plain(),
+    });
+    expect(await collectAsync(repo.read())).toHaveLength(1);
+    const converted = new ReadonlyRepository<Item>(connection, {
+      type: Item,
+      entity: "items",
+      objectConverter: new Plain(),
+      rowConverter: new RowTypeConverter({}),
+    });
+    command.reader = new MockReader([{ id: 1, name: "a" }]);
+    expect(await collectAsync(converted.read())).toHaveLength(1);
+    command.reader = new MockReader([]);
+    await expect(
+      collectAsync(converted.read(new ExecuteStoredProcedureStatement("save_item", []))),
+    ).resolves.toEqual([]);
+    command.reader = new MockReader([{ generated: 9 }]);
+    const created = await repo.create(Object.assign(new Item(), { name: "a" }));
+    expect(created.id).toBe(9);
+  });
+
+  it("bulk write covers transaction, strategy position, and where text", async () => {
+    const { connection, command } = mock();
+    const strategy = new SingleCommandIBulkWriteStrategy<Item>();
+    const transactional = new BulkCRUDRepository<Item>(
+      connection,
+      { type: Item, entity: "items", write: { useTransaction: true, persist: async () => {} } },
+      strategy,
+    );
+    const created = await transactional.createBulk([Object.assign(new Item(), { name: "a" })]);
+    expect(created).toHaveLength(1);
+    expect(connection.startTransactionCalls).toBe(1);
+
+    expect(() => new BulkCRUDRepository<Item>(connection, strategy)).toThrow();
+
+    const open = new MemoryDriver().connection();
+    await open.open();
+    const repo = new BulkCRUDRepository<Item>(open, { type: Item, entity: "items", ids: [] });
+    await repo.create(Object.assign(new Item(), { name: "a" }));
+    await repo.deleteBulk([Object.assign(new Item(), { name: "a" })], new WhereText("id = $id"));
+    await repo.deleteBulk([new Item()], new WhereText("1 = 1"));
+
+    const batch = new BatchCommandIBulkWriteStrategy<Item>();
+    const listedRepo = new BulkCRUDRepository<Item>(connection, { type: Item, entity: "items", ids: [] }, batch);
+    command.executeCalls = [];
+    await listedRepo.deleteBulk([Object.assign(new Item(), { name: "a" })], new WhereText("id = $id"));
+    expect(command.executeCalls[0]?.text).toContain("$id");
+    command.executeCalls = [];
+    await listedRepo.deleteBulk([new Item()], new WhereText("1 = 1"));
+    expect(command.executeCalls[0]?.parameters).toEqual([]);
+    command.executeCalls = [];
+    await listedRepo.deleteBulk([new Item()]);
+    expect(command.executeCalls[0]?.text).toContain("1 = 1");
+    expect(await repo.createBulk([new Item()])).toEqual([new Item()]);
+    const both = new BulkCRUDRepository<Item>(
+      connection,
+      { type: Item, entity: "items", ids: ["id", "name"] },
+      new BatchCommandIBulkWriteStrategy<Item>(),
+    );
+    await expect(both.updateBulk([new Item()])).rejects.toThrow(/non-Id field/);
+    const stored = new StoredProcedureBulkWriteStrategy<Item>("create_item", "update_item", "delete_item");
+    const wide = new BulkCRUDRepository<Item>(connection, {
+      type: Item,
+      entity: "items",
+      ids: ["id", "name"],
+      rowConverter: new RowTypeConverter({}),
+      write: { persist: async () => {} },
+    }, stored);
+    command.executeCalls = [];
+    await wide.createBulk([new Item()]);
+    expect(String(command.executeCalls[0]?.parameters?.[0]?.value)).toContain('"id":0');
+    expect(String(command.executeCalls[0]?.parameters?.[0]?.value)).toContain('"name":""');
+    expect(await wide.createBulk([new Item()])).toEqual([new Item()]);
+
+    const dropped = new BulkCRUDRepository<Item>(
+      connection,
+      { type: Item, entity: "items", objectConverter: new DropId() },
+      new BatchCommandIBulkWriteStrategy<Item>(),
+    );
+    command.response = { result: undefined, rowsAffected: 1 };
+    await expect(dropped.deleteBulk([new Item()])).rejects.toThrow(/id/);
+
+    const plain = new BulkCRUDRepository<Item>(connection, { type: Item, entity: "items" });
+    command.reader = new MockReader([]);
+    expect(
+      await plain.createBulk([Object.assign(new Item(), { id: { nested: true } as unknown as number })]),
+    ).toEqual([Object.assign(new Item(), { id: { nested: true } as unknown as number })]);
+  });
+
+  it("create follows enrichment and inserted-id edges", async () => {
+    const { connection, command } = mock([]);
+    const writer = new CRUDRepository<Item>(connection, { type: Item, entity: "items" });
+    const host = new CRUDRepository<Item>(connection, { type: Item, entity: "parents" });
+    host.addEnriched({ destinationProperty: "Children", sourceProperty: "id", relatedKey: "parent_id", type: "list" }, writer);
+    const objectId = Object.assign(new Item(), { id: { nested: true } as unknown as number, name: "a" });
+    expect(await host.create(objectId)).toBe(objectId);
+    const numeric = Object.assign(new Item(), { name: "b" });
+    expect(await host.create(numeric)).toBe(numeric);
+    const wide = new CRUDRepository<Item>(connection, {
+      type: Item,
+      entity: "parents",
+      ids: ["id", "name"],
+    });
+    wide.addEnriched({ destinationProperty: "Children", sourceProperty: "id", relatedKey: "parent_id", type: "list" }, writer);
+    expect(await wide.create(new Item())).toBeInstanceOf(Item);
+
+    command.reader = new MockReader([undefined as unknown as Cells]);
+    await expect(host.create(new Item())).rejects.toThrow("Reader current must be a row");
+
+    const plainSide = mock([{ id: 9 }]);
+    const plainRepo = new CRUDRepository<Item>(plainSide.connection, { type: Item, entity: "items" });
+    expect((await plainRepo.create(Object.assign(new Item(), { name: "a" }))).id).toBe(9);
+    const convertedSide = mock([{ generated: 4 }]);
+    const convertedRepo = new CRUDRepository<Item>(convertedSide.connection, {
+      type: Item,
+      entity: "items",
+      objectConverter: new Plain(),
+      rowConverter: new RowTypeConverter({}),
+    });
+    expect((await convertedRepo.create(Object.assign(new Item(), { name: "a" }))).id).toBe(4);
+  });
+});
+
+describe("enrichment edges", () => {
+  it("requires a writer and an association", async () => {
+    const owned = enrichment("Children");
+    const cascade = new CascadeDeleteEnrichmentStrategy<Bag>();
+    await expect(cascade.deleteLinked(new CRUDRepository<Item>(mock([]).connection, { entity: "items" }), owned, {})).rejects.toThrow(
+      "Missing association",
+    );
+    const update = new CascadeDeleteUpdateEnrichmentStrategy<Bag>();
+    await expect(update.updateLinked(new CRUDRepository<Item>(mock([]).connection, { entity: "items" }), owned, {})).rejects.toThrow(
+      "Missing association",
+    );
+    const replacing = new DefaultUpdateEnrichmentStrategy<Bag>();
+    await expect(replacing.updateLinked(new CRUDRepository<Item>(mock([]).connection, { entity: "items" }), owned, {})).rejects.toThrow(
+      "Missing association",
+    );
+
+    const { connection } = mock([]);
+    const writer = new CRUDRepository<Item>(connection, { type: Item, entity: "items" });
+    const tags = {
+      destinationProperty: "Tags",
+      sourceProperty: "id",
+      relatedKey: "id",
+      association: { parent: "parent_id", related: "tag_id" },
+    };
+    await cascade.deleteLinked(writer, tags, { id: 0 });
+    await cascade.deleteLinked(writer, tags, { id: "" });
+    await expect(DeleteEnrichmentStrategy.load(writer, owned, { id: { nested: true } })).resolves.toEqual([]);
+
+    const host = new CRUDRepository<Item>(connection, { type: Item, entity: "items" });
+    host.addEnriched({ destinationProperty: "Children", sourceProperty: "id", relatedKey: "parent_id", type: "list" }, writer);
+    const tree = new RepositoryTree(new RepositoryTreeNode(host, ""));
+    await expect(
+      new DefaultWriteEnrichmentStrategy<Item>().persist(tree, [new Item()], "nope" as WriteMode),
+    ).rejects.toThrow("Unknown persist mode");
+    await new DefaultWriteEnrichmentStrategy<Item>().persist(
+      new RepositoryTree(new RepositoryTreeNode({}, "")),
+      [],
+      "create",
+    );
+
+    await new HashsetOptimizedReadonlyEnrichmentStrategy<Item>().apply(
+      writer,
+      { destinationProperty: "name", sourceProperty: "missing", relatedKey: "id", relatedProperty: "name" },
+      [{}],
+    );
+    await new NestedToObjectEnrichmentStrategy<Item>({ key: "id", fields: { id: "id" } }).apply(
+      writer,
+      { destinationProperty: "name", sourceProperty: "id", relatedKey: "id" },
+      [],
+    );
+  });
+
+  it("walks lookup, link, and replace edges", async () => {
+    const tags = { destinationProperty: "Tags", sourceProperty: "id", relatedKey: "id", association: { parent: "parent_id", related: "tag_id" } };
+    const empty = mock([]);
+    const via = new CRUDRepository<Item>(empty.connection, { type: Item, entity: "tags" });
+    const lookup = new DefaultReadonlyEnrichmentStrategy<Item>();
+    await lookup.apply(via, { destinationProperty: "name", sourceProperty: "id", relatedKey: "id" }, [{ id: null }, { id: 1 }]);
+    await lookup.apply(via, { destinationProperty: "Children", sourceProperty: "id", relatedKey: "parent_id", type: "list" }, [{ id: null }, {}]);
+    await expect(lookup.applyLinked(via, via, { destinationProperty: "Tags", sourceProperty: "id", relatedKey: "id" }, [{ id: 1 }])).rejects.toThrow(
+      "Missing association",
+    );
+    await lookup.applyLinked(via, via, tags, [{ id: null }]);
+    const linkSide = mock([{ tag_id: null }, { tag_id: { nested: true } as never }, { tag_id: 2 }]);
+    const linkRepo = new CRUDRepository<Item>(linkSide.connection, { entity: "links" });
+    await lookup.applyLinked(via, linkRepo, tags, [{ id: 1 }]);
+
+    const hash = new HashsetOptimizedReadonlyEnrichmentStrategy<Item>();
+    await hash.apply(via, { destinationProperty: "name", sourceProperty: "id", relatedKey: "id", relatedProperty: "name", type: "list" }, [{}]);
+    const named = mock([{ id: 1, name: "a" }]);
+    const namedRepo = new CRUDRepository<Item>(named.connection, { type: Item, entity: "tags" });
+    await hash.apply(namedRepo, { destinationProperty: "name", sourceProperty: "id", relatedKey: "id", relatedProperty: "name" }, [{ id: 1 }, {}]);
+    const many = mock([{ parent_id: 1, name: "a" }]);
+    const manyRepo = new CRUDRepository<Item>(many.connection, { type: Item, entity: "children" });
+    await hash.apply(manyRepo, { destinationProperty: "Children", sourceProperty: "id", relatedKey: "parent_id", type: "list" }, [{ id: 1 }, { id: null }]);
+
+    const children = { destinationProperty: "Children", sourceProperty: "id", relatedKey: "parent_id", type: "list" };
+    const quiet = mock([]);
+    const writer = new CRUDRepository<Item>(quiet.connection, { type: Item, entity: "children", ids: ["id"] });
+    const replacing = new DefaultUpdateEnrichmentStrategy<Bag>();
+    await replacing.updateChildren(writer, children, { id: 1 });
+    const existing = mock([
+      { id: 1, parent_id: 1, name: "old" },
+      { id: 9, parent_id: 1, name: "gone" },
+    ]);
+    const existingRepo = new CRUDRepository<Item>(existing.connection, { type: Item, entity: "children", ids: ["id"] });
+    await replacing.updateChildren(existingRepo, children, {
+      id: 1,
+      Children: [{ id: 1, name: "kept" }, { name: "fresh" }, null, "skip"],
+    });
+
+    const linkedRows = mock([{ tag_id: 0 }, { tag_id: 2 }, {}]);
+    const linkWriter = new CRUDRepository<Item>(linkedRows.connection, { entity: "links", ids: ["id"] });
+    await replacing.updateLinked(linkWriter, tags, { id: 1, Tags: [{ id: 2 }, { id: 2 }, { id: 3 }] });
+    await expect(new DefaultCreateEnrichmentStrategy<Bag>().createLinked(writer, { destinationProperty: "Tags", sourceProperty: "id", relatedKey: "id" }, { id: 1 })).rejects.toThrow(
+      "Missing association",
+    );
+    const noIds = new CRUDRepository<Item>(mock([]).connection, { entity: "children", ids: [] });
+    await replacing.updateChildren(noIds, children, {
+      id: 1,
+      Children: [{ name: "a" }],
+    });
+    const creating = new DefaultCreateEnrichmentStrategy<Bag>();
+    await expect(creating.createLinked(writer, tags, { id: 0, Tags: [{ id: 1 }] })).rejects.toThrow(/requires/);
+    await expect(creating.createLinked(writer, tags, { id: 1, Tags: [{ id: 0 }] })).rejects.toThrow(/requires/);
+
+    const open = new OpenUpdate();
+    expect(open.key({ name: "a" }, ["missing"])).toBe("");
+    expect(open.key({ id: 5 }, ["id"])).toBe("5");
+    expect(open.key({ id: null as unknown as number }, ["id"])).toBe("");
+    expect(open["requiredKey"]({ id: 1 }, {
+      destinationProperty: "Tags",
+      sourceProperty: "id",
+      relatedKey: "id",
+    })).toBe(1);
+    expect(() =>
+      open["requiredKey"]({ id: 0 }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    open.stamp({ parent: null as unknown as object }, "parent", 8);
+    expect(open.payload({ Children: { not: "array" } }, "Children")).toEqual([]);
+    expect(open.payload({ Children: "text" }, "Children")).toEqual([]);
+    const creatingOpen = new OpenCreate();
+    expect(creatingOpen.payload({ Children: { not: "array" } }, "Children")).toEqual([]);
+    expect(creatingOpen.payload({ Children: [null, "skip", { id: 1n }] }, "Children")).toEqual([{ id: 1n }]);
+    const stamped = { parent: { Id: 0 } };
+    creatingOpen["stampCell"](stamped, "parent", 9);
+    expect(stamped.parent.Id).toBe(9);
+    const createSnake = { parent: { name: "a" } };
+    creatingOpen["stampCell"](createSnake, "parent", 5);
+    expect((createSnake.parent as { id?: number }).id).toBe(5);
+    const createFlat = { parent_id: 0 };
+    creatingOpen["stampCell"](createFlat, "parent_id", 6);
+    expect(createFlat.parent_id).toBe(6);
+    creatingOpen["stampCell"](createFlat, "parent_id", undefined);
+    creatingOpen["stampCell"](createFlat, "parent_id", null);
+    creatingOpen["stampCell"](createFlat, "parent_id", { nested: true });
+    creatingOpen["stampCell"](createFlat, "parent_id", []);
+    expect(open["namesOf"]({ ids: [] } as never, { id: 1, name: "a" })).toEqual(["id"]);
+    expect(open["namesOf"]({ ids: ["id"] } as never, { id: 1 })).toEqual(["id"]);
+    expect(() =>
+      creatingOpen["relatedIds"]({ Tags: [{ id: 0 }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    expect(() =>
+      creatingOpen["relatedIds"]({ Tags: [{ id: 0n }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    expect(() =>
+      creatingOpen["relatedIds"]({ Tags: [{ id: "" }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    expect(() =>
+      creatingOpen["relatedIds"]({ Tags: [{ id: { nested: true } }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    expect(
+      creatingOpen["relatedIds"]({ Tags: [{ id: 2 }, { id: 2 }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toEqual([2]);
+    expect(open.payload({ Children: [null, "skip", { id: 1 }] }, "Children")).toEqual([{ id: 1 }]);
+    expect(() =>
+      open["relatedIds"]({ Tags: [{ id: 0 }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    expect(() =>
+      open["relatedIds"]({ Tags: [{ id: 0n }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    expect(() =>
+      open["relatedIds"]({ Tags: [{ id: "" }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toThrow(/requires/);
+    expect(
+      open["relatedIds"]({ Tags: [{ id: 2 }, { id: 2 }] }, {
+        destinationProperty: "Tags",
+        sourceProperty: "id",
+        relatedKey: "id",
+      }),
+    ).toEqual([2]);
+    expect(open["hasKey"]({}, [])).toBe(false);
+    expect(open["hasKey"]({ id: 1 }, ["id"])).toBe(true);
+    expect(open["hasKey"]({ id: 0 }, ["id"])).toBe(false);
+    expect(open["hasKey"]({ id: 1 }, ["id", "missing"])).toBe(false);
+    const nested = { parent: { Id: 0 } };
+    open.stamp(nested, "parent", 4);
+    expect(nested.parent.Id).toBe(4);
+    const snake = { parent: { name: "a" } };
+    open.stamp(snake, "parent", 5);
+    expect((snake.parent as { id?: number }).id).toBe(5);
+    const flat = { parent_id: 0 };
+    open.stamp(flat, "parent_id", 6);
+    expect(flat.parent_id).toBe(6);
+    open.stamp(flat, "parent_id", { nested: true });
+    const withArray = { parent_id: [1, 2] as unknown as number };
+    open.stamp(withArray, "parent_id", 7);
+    expect(withArray.parent_id).toBe(7);
+
+    const cascade = new CascadeDeleteEnrichmentStrategy<Bag>();
+    const cascadeRows = mock([{ tag_id: 0 }, { tag_id: 2 }]);
+    const cascadeWriter = new CRUDRepository<Item>(cascadeRows.connection, { entity: "links", ids: ["id"] });
+    await cascade.deleteLinked(cascadeWriter, tags, { id: 1 });
+    const cascadeUpdate = new CascadeDeleteUpdateEnrichmentStrategy<Bag>();
+    const cascadeUpdateRows = mock([{ tag_id: 0 }, { tag_id: 3 }]);
+    const cascadeUpdateWriter = new CRUDRepository<Item>(cascadeUpdateRows.connection, { entity: "links", ids: ["id"] });
+    await cascadeUpdate.updateLinked(cascadeUpdateWriter, tags, { id: 1, Tags: [{ id: 4 }] });
+
+    const parents = mock([]);
+    const host = new CRUDRepository<Item>(parents.connection, { type: Item, entity: "parents" });
+    host.addEnriched(children, writer);
+    const tree = new RepositoryTree(new RepositoryTreeNode(host, ""));
+    await new LazyWriteEnrichmentStrategy<Item>().persist(tree, [new Item()], "create");
+    const associated = new CRUDRepository<Item>(parents.connection, { type: Item, entity: "parents" });
+    associated.addEnriched(tags, writer);
+    await expect(
+      new DefaultWriteEnrichmentStrategy<Item>().persist(
+        new RepositoryTree(new RepositoryTreeNode(associated, "")),
+        [{ id: 1, Tags: [{ id: 2 }] } as unknown as Item],
+        "create",
+      ),
+    ).rejects.toThrow(/Tags/);
+  });
+
+  it("rejects custom fills", async () => {
+    const { connection } = mock([]);
+    const via = new CRUDRepository<Item>(connection, { type: Item, entity: "items" });
+    const read = new DefaultReadonlyEnrichmentStrategy<Item>();
+    const fill = {
+      destinationProperty: "name",
+      sourceProperty: "id",
+      relatedKey: "id",
+      type: "custom" as const,
+    };
+    await expect(read.apply(via, fill, [])).rejects.toThrow('Unsupported enrichment type "custom"');
+    const custom = new CRUDRepository<Item>(connection, { type: Item, entity: "parents" });
+    custom.addEnriched(fill, via);
+    await expect(
+      new DefaultWriteEnrichmentStrategy<Item>().persist(
+        new RepositoryTree(new RepositoryTreeNode(custom, "")),
+        [new Item()],
+        "create",
+      ),
+    ).rejects.toThrow('Unsupported enrichment type "custom"');
+  });
+});

package/src/mappers/ChangeCasingMapper.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { ChangeCasingMapper } from "./ChangeCasingMapper.ts";
+
+describe("ChangeCasingMapper", () => {
+  it("maps pascal to snake and back", () => {
+    const mapper = new ChangeCasingMapper("pascalCase", "snakeCase");
+    expect(mapper.map("UserType")).toBe("user_type");
+    expect(mapper.map("Id")).toBe("id");
+    expect(mapper.reverseMap("user_type")).toBe("UserType");
+    expect(mapper.reverseMap("id")).toBe("Id");
+  });
+
+  it("maps contact names", () => {
+    const mapper = new ChangeCasingMapper("pascalCase", "snakeCase");
+    const contact = mapper.map("Contact");
+    const firstName = mapper.map("FirstName");
+    const emailAddress = mapper.map("EmailAddress");
+    expect(contact).toBe("contact");
+    expect(firstName).toBe("first_name");
+    expect(emailAddress).toBe("email_address");
+  });
+
+  it("reverse maps contact names", () => {
+    const mapper = new ChangeCasingMapper("pascalCase", "snakeCase");
+    const contact = mapper.reverseMap("contact");
+    const firstName = mapper.reverseMap("first_name");
+    const emailAddress = mapper.reverseMap("email_address");
+    expect(contact).toBe("Contact");
+    expect(firstName).toBe("FirstName");
+    expect(emailAddress).toBe("EmailAddress");
+  });
+});

package/src/mappers/DictionaryMapper.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { DictionaryMapper } from "./DictionaryMapper.ts";
+import { MockCommand } from "../mocks/mock-command.ts";
+import { MockConnection } from "../mocks/mock-connection.ts";
+import { MockReader } from "../mocks/mock-reader.ts";
+import { ReadonlyRepository } from "../ReadonlyRepository.ts";
+
+class Account {
+  Key = 0;
+  Login = "";
+}
+
+describe("DictionaryMapper", () => {
+  it("maps known names and passes through the rest", () => {
+    const mapper = new DictionaryMapper([
+      ["FirstName", "given_name"],
+      ["LastName", "family_name"],
+      ["Email", "email_address"],
+    ]);
+    const firstName = mapper.map("FirstName");
+    const lastName = mapper.map("LastName");
+    const email = mapper.map("Email");
+    const phone = mapper.map("Phone");
+    const fromFirst = mapper.reverseMap("given_name");
+    const fromLast = mapper.reverseMap("family_name");
+    const fromEmail = mapper.reverseMap("email_address");
+    const fromPhone = mapper.reverseMap("Phone");
+    expect(firstName).toBe("given_name");
+    expect(lastName).toBe("family_name");
+    expect(email).toBe("email_address");
+    expect(phone).toBe("Phone");
+    expect(fromFirst).toBe("FirstName");
+    expect(fromLast).toBe("LastName");
+    expect(fromEmail).toBe("Email");
+    expect(fromPhone).toBe("Phone");
+  });
+
+  it("first key wins on reverse", () => {
+    const mapper = new DictionaryMapper([
+      ["Home", "address"],
+      ["Work", "address"],
+    ]);
+    const home = mapper.map("Home");
+    const work = mapper.map("Work");
+    const address = mapper.reverseMap("address");
+    expect(home).toBe("address");
+    expect(work).toBe("address");
+    expect(address).toBe("Home");
+  });
+
+  it("read reverse-maps column names", async () => {
+    const connection = new MockConnection(undefined, "memory");
+    const command = new MockCommand(connection);
+    connection.command = command;
+    const repo = new ReadonlyRepository(connection, {
+      type: Account,
+      entity: "user",
+      propertyMappings: new DictionaryMapper([
+        ["Key", "id"],
+        ["Login", "username"],
+      ]),
+    });
+    command.reader = new MockReader([{ id: 7, username: "ada" }]);
+    const row = await repo.readSingle();
+    expect(row?.Key).toBe(7);
+    expect(row?.Login).toBe("ada");
+    expect(command.executeReaderCalls[0]?.text).toBe("SELECT id, username FROM user");
+  });
+});