@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/BulkCRUDRepository.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from "vitest";
+import { MemoryDriver } from "@datasources/memory";
+import { collectAsync } from "./collectAsync.ts";
+import { BulkCRUDRepository } from "./BulkCRUDRepository.ts";
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+import { DatasourceError } from "./DatasourceError.ts";
+import type { IConnection } from "./IConnection.ts";
+
+class Parent {
+  id = 0;
+  label = "";
+  children: Child[] = [];
+}
+
+class Child {
+  id = 0;
+  parent_id = 0;
+  label = "";
+}
+
+const setup = async (): Promise<IConnection> => {
+  const connection = new MemoryDriver().connection();
+  await connection.open();
+  return connection;
+};
+
+const relate = (parentsRepo: BulkCRUDRepository<Parent>, childrenRepo: BulkCRUDRepository<Child>) => {
+  parentsRepo.addEnriched({ destinationProperty: "children", sourceProperty: "id", relatedKey: "parent_id", type: "list" }, childrenRepo);
+  return parentsRepo;
+};
+
+describe("BulkCRUDRepository", () => {
+  it("creates parents and children", async () => {
+    const connection = await setup();
+    const parentsRepo = new BulkCRUDRepository(Parent, connection);
+    const childrenRepo = new BulkCRUDRepository(Child, connection);
+    const ids = await relate(parentsRepo, childrenRepo).createBulk([
+      Object.assign(new Parent(), { children: [Object.assign(new Child(), { label: "a" })] }),
+      Object.assign(new Parent(), {
+        children: [Object.assign(new Child(), { label: "b" }), Object.assign(new Child(), { label: "c" })],
+      }),
+    ]);
+    const parents = await collectAsync(parentsRepo.read());
+    const children = await collectAsync(childrenRepo.read());
+    expect(parents).toHaveLength(2);
+    expect(parents.every((parent) => parent.id > 0)).toBe(true);
+    expect(children).toHaveLength(3);
+    expect(ids.map((row) => row.id).sort()).toEqual(parents.map((parent) => parent.id).sort());
+  });
+
+  it("createBulk writes each parent", async () => {
+    const parentsRepo = new BulkCRUDRepository(Parent, await setup());
+    const ids = await parentsRepo.createBulk([
+      Object.assign(new Parent(), { label: "a" }),
+      Object.assign(new Parent(), { label: "b" }),
+    ]);
+    const parents = await collectAsync(parentsRepo.read());
+    expect(parents).toHaveLength(2);
+    expect(ids.map((row) => row.id).sort()).toEqual(parents.map((parent) => parent.id).sort());
+  });
+
+  it("createBulk returns composite ids", async () => {
+    class Coded {
+      code = "";
+      code_extra = "";
+      label = "";
+    }
+    const codesRepo = new BulkCRUDRepository<Coded>(await setup(), {
+      type: Coded,
+      ids: ["code", "code_extra"],
+    });
+    const ids = await codesRepo.createBulk([
+      Object.assign(new Coded(), { code: "a", code_extra: "ab", label: "one" }),
+      Object.assign(new Coded(), { code: "b", code_extra: "ba", label: "two" }),
+    ]);
+    expect(ids).toEqual([
+      Object.assign(new Coded(), { code: "a", code_extra: "ab", label: "one" }),
+      Object.assign(new Coded(), { code: "b", code_extra: "ba", label: "two" }),
+    ]);
+  });
+
+  it("keeps the first write when a later bulk update throws", async () => {
+    const parentsRepo = new BulkCRUDRepository(Parent, await setup());
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "a" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "b" }));
+    expect(second.id).toBeGreaterThan(0);
+    let seen = 0;
+    parentsRepo.addMiddleware({
+      beforeCommand() {
+        seen += 1;
+        if (seen === 2) throw new DatasourceError("stop");
+      },
+      afterCommand() {},
+    });
+    await expect(parentsRepo.updateBulk([
+      Object.assign(new Parent(), { id: first.id, label: "changed" }),
+      Object.assign(new Parent(), { id: first.id, label: "later" }),
+    ])).rejects.toThrow(/stop/);
+    const stored = await collectAsync(parentsRepo.read());
+    expect(stored.find((parent) => parent.id === first.id)?.label).toBe("changed");
+  });
+
+  it("rolls back a bulk update when useTransaction is on", async () => {
+    const parentsRepo = new BulkCRUDRepository<Parent>(await setup(), {
+      type: Parent,
+      write: new DefaultWriteEnrichmentStrategy(undefined, undefined, undefined, true),
+    });
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "a" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "b" }));
+    expect(second.id).toBeGreaterThan(0);
+    let seen = 0;
+    parentsRepo.addMiddleware({
+      beforeCommand() {
+        seen += 1;
+        if (seen === 2) throw new DatasourceError("stop");
+      },
+      afterCommand() {},
+    });
+    await expect(parentsRepo.updateBulk([
+      Object.assign(new Parent(), { id: first.id, label: "changed" }),
+      Object.assign(new Parent(), { id: first.id, label: "later" }),
+    ])).rejects.toThrow(/stop/);
+    const stored = await collectAsync(parentsRepo.read());
+    expect(stored.find((parent) => parent.id === first.id)?.label).toBe("a");
+  });
+
+  it("update replace-syncs each parent", async () => {
+    const connection = await setup();
+    const parentsRepo = new BulkCRUDRepository(Parent, connection);
+    const childrenRepo = new BulkCRUDRepository(Child, connection);
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "one" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "two" }));
+    expect(second.id).toBeGreaterThan(0);
+    const kept = await childrenRepo.create(Object.assign(new Child(), { parent_id: first.id, label: "a" }));
+    expect(kept.id).toBeGreaterThan(0);
+    const dropped = await childrenRepo.create(Object.assign(new Child(), { parent_id: second.id, label: "b" }));
+    expect(dropped.id).toBeGreaterThan(0);
+    const response = await relate(parentsRepo, childrenRepo).updateBulk([
+      Object.assign(new Parent(), {
+        id: first.id,
+        label: "one",
+        children: [Object.assign(new Child(), { id: kept.id, label: "aa" })],
+      }),
+      Object.assign(new Parent(), {
+        id: second.id,
+        label: "two",
+        children: [Object.assign(new Child(), { label: "c" })],
+      }),
+    ]);
+    expect(response.rowsAffected).toBe(2);
+    const children = await collectAsync(childrenRepo.read());
+    expect(children).toHaveLength(2);
+    expect(children.find((child) => child.parent_id === first.id)?.label).toBe("aa");
+    expect(children.find((child) => child.parent_id === second.id)?.label).toBe("c");
+    expect(children.some((child) => child.label === "b")).toBe(false);
+  });
+
+  it("delete cascades each parent", async () => {
+    const connection = await setup();
+    const parentsRepo = new BulkCRUDRepository(Parent, connection);
+    const childrenRepo = new BulkCRUDRepository(Child, connection);
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "one" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "two" }));
+    expect(second.id).toBeGreaterThan(0);
+    const firstChild = await childrenRepo.create(Object.assign(new Child(), { parent_id: first.id, label: "a" }));
+    expect(firstChild.id).toBeGreaterThan(0);
+    const secondChild = await childrenRepo.create(Object.assign(new Child(), { parent_id: second.id, label: "b" }));
+    expect(secondChild.id).toBeGreaterThan(0);
+    const kept = await childrenRepo.create(Object.assign(new Child(), { label: "keep" }));
+    expect(kept.id).toBeGreaterThan(0);
+    const response = await relate(parentsRepo, childrenRepo).deleteBulk([
+      Object.assign(new Parent(), { id: first.id }),
+      Object.assign(new Parent(), { id: second.id }),
+    ]);
+    expect(response.rowsAffected).toBe(2);
+    expect(await collectAsync(parentsRepo.read())).toEqual([]);
+    expect((await collectAsync(childrenRepo.read())).map((child) => child.label)).toEqual(["keep"]);
+  });
+});

package/src/BulkCRUDRepository.ts

@@ -0,0 +1,84 @@
+import type { IConnection } from "./IConnection.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import type { Cells } from "./converters/Cell.ts";
+import { CRUDRepository } from "./CRUDRepository.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+import { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.ts";
+import type { Response } from "./Response.ts";
+import type { IWhere } from "./statements/IWhere.ts";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
+import { SingleCommandIBulkWriteStrategy } from "./SingleCommandIBulkWriteStrategy.ts";
+import { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.ts";
+
+const isBulkStrategy = <T extends object>(value: object): value is IBulkWriteStrategy<T> =>
+  "create" in value &&
+  "update" in value &&
+  "delete" in value &&
+  !("persist" in value) &&
+  !("createCommand" in value) &&
+  !("statements" in value);
+
+const transactionOf = <T extends object>(
+  options: IConnection | CRUDRepositoryOptions<T> | IBulkWriteStrategy<T> | undefined,
+): boolean =>
+  options !== undefined && "write" in options ? options.write?.useTransaction ?? false : false;
+
+const inTransaction = async <TResult>(
+  transactional: boolean,
+  connection: IConnection,
+  write: () => Promise<TResult>,
+): Promise<TResult> => {
+  if (!transactional) return write();
+  const work = new UnitOfWorkTransaction(connection);
+  await work.begin();
+  try {
+    const result = await write();
+    await work.commit();
+    return result;
+  } catch (error) {
+    await work.abort();
+    throw error;
+  }
+};
+
+export class BulkCRUDRepository<T extends object = Cells> extends CRUDRepository<T> {
+  private readonly strategy: IBulkWriteStrategy<T>;
+  private readonly transactional: boolean;
+
+  constructor(type: Constructable<T>, connection: IConnection, bulk?: IBulkWriteStrategy<T>);
+  constructor(connection: IConnection, options: CRUDRepositoryOptions<T>, bulk?: IBulkWriteStrategy<T>);
+  constructor(
+    typeOrConnection: Constructable<T> | IConnection,
+    connectionOrOptions?: IConnection | CRUDRepositoryOptions<T> | IBulkWriteStrategy<T>,
+    bulk?: IBulkWriteStrategy<T>,
+  ) {
+    const strategy = bulk ?? (isBulkStrategy<T>(connectionOrOptions ?? {}) ? connectionOrOptions : undefined);
+    const transactional = transactionOf(connectionOrOptions);
+    const parent = (
+      isBulkStrategy(connectionOrOptions ?? {}) ? undefined : connectionOrOptions
+    ) as IConnection & CRUDRepositoryOptions<T>;
+    super(typeOrConnection as Constructable<T> & IConnection, parent);
+    this.strategy = strategy ?? new SingleCommandIBulkWriteStrategy<T>();
+    this.transactional = transactional;
+    this.strategy.repo = this;
+    this.strategy.attach(
+      this.command(),
+      typeof typeOrConnection === "function"
+        ? createCRUDRepositoryOptions(typeOrConnection)
+        : parent,
+    );
+  }
+
+  createBulk = async (items: T[]): Promise<T[]> => {
+    await inTransaction(this.transactional || items.length > 0, this.command().connection, () =>
+      this.strategy.create(items),
+    );
+    return items;
+  };
+
+  updateBulk = (items: T[], byWhere?: IWhere): Promise<Response> =>
+    inTransaction(this.transactional, this.command().connection, () => this.strategy.update(items, byWhere));
+
+  deleteBulk = (items: T[], byWhere?: IWhere): Promise<Response> =>
+    inTransaction(this.transactional, this.command().connection, () => this.strategy.delete(items, byWhere));
+}

package/src/BulkCommand.ts

@@ -0,0 +1,6 @@
+import type { Parameter } from "./Parameter.ts";
+
+export interface BulkCommand {
+  text: string;
+  parameters: Parameter[];
+}

package/src/BulkWriteEnrichment.ts

@@ -0,0 +1,19 @@
+import type { CRUDRepository } from "./CRUDRepository.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+import { enrichmentsOf } from "./ReadonlyRepository.ts";
+import { RepositoryTree } from "./RepositoryTree.ts";
+import { RepositoryTreeNode } from "./RepositoryTreeNode.ts";
+import type { WriteMode } from "./WriteMode.ts";
+
+export const afterBulkWrite = async <T extends object>(
+  repo: CRUDRepository<T>,
+  options: CRUDRepositoryOptions<T>,
+  items: T[],
+  mode: WriteMode,
+): Promise<void> => {
+  if (items.length === 0 || !enrichmentsOf(repo)?.length) return;
+  const write = options.write ?? new DefaultWriteEnrichmentStrategy<T>();
+  const tree = new RepositoryTree(new RepositoryTreeNode(repo, ""));
+  await (write.persistBulk ?? write.persist)(tree, items, mode);
+};

package/src/BulkWriteStrategy.test.ts

@@ -0,0 +1,293 @@
+import { describe, expect, it } from "vitest";
+import { DatasourceError } from "./DatasourceError.ts";
+import { BatchCommandIBulkWriteStrategy } from "./BatchCommandIBulkWriteStrategy.ts";
+import { BulkCRUDRepository } from "./BulkCRUDRepository.ts";
+import { MockCommand } from "./mocks/mock-command.ts";
+import { MockConnection } from "./mocks/mock-connection.ts";
+import { SingleCommandIBulkWriteStrategy } from "./SingleCommandIBulkWriteStrategy.ts";
+import { StoredProcedureBulkWriteStrategy } from "./StoredProcedureBulkWriteStrategy.ts";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
+
+class Parent {
+  id: number | null = null;
+  label = "";
+}
+
+class Scalar {
+  amount = 0;
+  blob: Uint8Array | null = null;
+  count = 0;
+  created: Date | null = null;
+  flag = false;
+  label: string | null = null;
+  price = 0;
+  token: string | null = null;
+}
+
+const open = <T extends object>(type: new () => T, strategy: IBulkWriteStrategy<T>) => {
+  const connection = new MockConnection(undefined, "memory");
+  const command = new MockCommand(connection);
+  connection.command = command;
+  const repo = new BulkCRUDRepository<T>(connection, { type, entity: "parents" }, strategy);
+  return { repo, command };
+};
+
+describe("bulk write strategies", () => {
+  it("single commands writes one statement per row", async () => {
+    const { repo, command } = open(Parent, new SingleCommandIBulkWriteStrategy<Parent>());
+    command.response = { result: 9, rowsAffected: 1 };
+    await repo.createBulk([
+      Object.assign(new Parent(), { label: "a" }),
+      Object.assign(new Parent(), { label: "b" }),
+    ]);
+    await repo.updateBulk([
+      Object.assign(new Parent(), { id: 1, label: "a" }),
+      Object.assign(new Parent(), { id: 2, label: "b" }),
+    ]);
+    await repo.deleteBulk([
+      Object.assign(new Parent(), { id: 1, label: "a" }),
+      Object.assign(new Parent(), { id: 2, label: "b" }),
+    ]);
+    expect(command.executeCalls).toHaveLength(6);
+    expect(command.executeCalls[0]?.text).toBe("INSERT INTO parents (label) VALUES ($label)");
+    expect(command.executeCalls[1]?.text).toBe("INSERT INTO parents (label) VALUES ($label)");
+    expect(command.executeCalls[2]?.text).toBe("UPDATE parents SET label = $label WHERE id = $id");
+    expect(command.executeCalls[3]?.text).toBe("UPDATE parents SET label = $label WHERE id = $id");
+    expect(command.executeCalls[4]?.text).toBe("DELETE FROM parents WHERE id = $id");
+    expect(command.executeCalls[5]?.text).toBe("DELETE FROM parents WHERE id = $id");
+  });
+
+  it("batch commands joins statements", async () => {
+    const { repo, command } = open(Parent, new BatchCommandIBulkWriteStrategy<Parent>());
+    await repo.createBulk([
+      Object.assign(new Parent(), { label: "a" }),
+      Object.assign(new Parent(), { label: "b" }),
+    ]);
+    expect(command.executeCalls).toHaveLength(1);
+    expect(command.executeCalls[0]?.text).toBe(
+      "INSERT INTO parents (label) VALUES ($label__0), ($label__1)",
+    );
+    expect(command.executeCalls[0]?.parameters?.[0]).toMatchObject({ name: "label__0", value: "a" });
+    expect(command.executeCalls[0]?.parameters?.[1]).toMatchObject({ name: "label__1", value: "b" });
+
+    await repo.updateBulk([
+      Object.assign(new Parent(), { id: 1, label: "a" }),
+      Object.assign(new Parent(), { id: 2, label: "b" }),
+    ]);
+    expect(command.executeCalls[1]?.text).toBe(
+      "UPDATE parents SET label = data.label FROM (SELECT $label__0 AS label, $id__0 AS id UNION ALL SELECT $label__1 AS label, $id__1 AS id) AS data WHERE parents.id = data.id",
+    );
+    expect(command.executeCalls[1]?.parameters?.map((parameter) => parameter.name)).toEqual([
+      "label__0",
+      "id__0",
+      "label__1",
+      "id__1",
+    ]);
+
+    await repo.deleteBulk([
+      Object.assign(new Parent(), { id: 1 }),
+      Object.assign(new Parent(), { id: 2 }),
+    ]);
+    expect(command.executeCalls[2]?.text).toBe(
+      "DELETE FROM parents WHERE id IN ($id__0, $id__1)",
+    );
+    expect(command.executeCalls[2]?.parameters?.map((parameter) => parameter.name)).toEqual(["id__0", "id__1"]);
+  });
+
+  it("leaves a shorter name inside a longer parameter", async () => {
+    class Coded {
+      id = 0;
+      code = "";
+      code_extra = "";
+    }
+    const { repo, command } = open(Coded, new BatchCommandIBulkWriteStrategy<Coded>());
+    await repo.createBulk([Object.assign(new Coded(), { code: "a", code_extra: "ab" })]);
+    expect(command.executeCalls[0]?.text).toContain("$code__0");
+    expect(command.executeCalls[0]?.text).toContain("$code_extra__0");
+  });
+
+  it("stored procedure commands sends one json call", async () => {
+    const { repo, command } = open(
+      Parent,
+      new StoredProcedureBulkWriteStrategy<Parent>("bulk_create_parent", "bulk_update_parent", "bulk_delete_parent"),
+    );
+    await repo.createBulk([
+      Object.assign(new Parent(), { label: "a" }),
+      Object.assign(new Parent(), { label: "b" }),
+    ]);
+    expect(command.executeCalls).toHaveLength(1);
+    expect(command.executeCalls[0]?.text).toBe("CALL bulk_create_parent($payload, $ids)");
+    expect(command.executeCalls[0]?.parameters?.[0]).toMatchObject({
+      name: "payload",
+      value: '[{"label":"a"},{"label":"b"}]',
+    });
+    expect(command.executeCalls[0]?.parameters?.[1]).toMatchObject({ name: "ids", direction: "inputOutput" });
+
+    await repo.updateBulk([
+      Object.assign(new Parent(), { id: 1, label: "a" }),
+      Object.assign(new Parent(), { id: 2, label: "b" }),
+    ]);
+    expect(command.executeCalls[1]?.text).toBe("CALL bulk_update_parent($payload)");
+    expect(command.executeCalls[1]?.parameters?.[0]?.value).toBe(
+      '[{"id":1,"label":"a"},{"id":2,"label":"b"}]',
+    );
+
+    await repo.deleteBulk([
+      Object.assign(new Parent(), { id: 1 }),
+      Object.assign(new Parent(), { id: 2 }),
+    ]);
+    expect(command.executeCalls[2]?.text).toBe("CALL bulk_delete_parent($payload)");
+    expect(command.executeCalls[2]?.parameters?.[0]?.value).toBe(
+      '[{"id":1,"label":""},{"id":2,"label":""}]',
+    );
+  });
+
+  it("payload encodes scalars", async () => {
+    const { repo, command } = open(
+      Scalar,
+      new StoredProcedureBulkWriteStrategy<Scalar>("create_scalar", "update_scalar", "delete_scalar"),
+    );
+    const created = new Date("2024-06-01T00:00:00.000Z");
+    await repo.createBulk([
+      Object.assign(new Scalar(), {
+        amount: 1.25,
+        blob: new Uint8Array([1, 2, 3]),
+        count: 2,
+        created,
+        flag: true,
+        price: 10.5,
+        token: "3f2504e0-4f89-11d3-9a0c-0305e82c3301",
+      }),
+    ]);
+    expect(command.executeCalls[0]?.parameters?.[0]?.value).toBe(
+      `[{"amount":1.25,"blob":"AQID","count":2,"created":"${created.toISOString().replace(/\.(\d{3})Z$/, ".$10000Z")}","flag":true,"label":null,"price":10.5,"token":"3f2504e0-4f89-11d3-9a0c-0305e82c3301"}]`,
+    );
+  });
+
+  it("payload encodes the remaining scalars", async () => {
+    class Odd {
+      flag = false;
+      huge = 0;
+      note = "";
+      rank = 0n;
+      amy = 2;
+      zed = 1;
+    }
+    const { repo, command } = open(
+      Odd,
+      new StoredProcedureBulkWriteStrategy<Odd>("create_odd", "update_odd", "delete_odd"),
+    );
+    await repo.createBulk([
+      Object.assign(new Odd(), { flag: false, note: "a\u0001b", rank: 4n }),
+    ]);
+    expect(command.executeCalls[0]?.parameters?.[0]?.value).toContain('"flag":false');
+    expect(command.executeCalls[0]?.parameters?.[0]?.value).toContain('"rank":4');
+    expect(command.executeCalls[0]?.parameters?.[0]?.value).toContain("\\u0001");
+    await expect(
+      repo.createBulk([Object.assign(new Odd(), { huge: Number.POSITIVE_INFINITY })]),
+    ).rejects.toThrow(DatasourceError);
+    await expect(
+      repo.createBulk([Object.assign(new Odd(), { note: { bad: true } as never })]),
+    ).rejects.toThrow(DatasourceError);
+  });
+
+  class Child {
+    id: number | null = null;
+    parent_id: number | null = null;
+    label = "";
+  }
+
+  class Family {
+    id: number | null = null;
+    label = "";
+    children: Child[] = [];
+  }
+
+  const family = (
+    parents: IBulkWriteStrategy<Family>,
+    children: IBulkWriteStrategy<Child> = new BatchCommandIBulkWriteStrategy<Child>(),
+  ) => {
+    const connection = new MockConnection(undefined, "memory");
+    const command = new MockCommand(connection);
+    connection.command = command;
+    const childrenRepo = new BulkCRUDRepository<Child>(connection, { type: Child, entity: "children" }, children);
+    const parentsRepo = new BulkCRUDRepository<Family>(connection, { type: Family, entity: "parents" }, parents);
+    parentsRepo.addEnriched(
+      { destinationProperty: "children", sourceProperty: "id", relatedKey: "parent_id", type: "list" },
+      childrenRepo,
+    );
+    return { parentsRepo, command };
+  };
+
+  it("batch persists children in one command", async () => {
+    const { parentsRepo, command } = family(new BatchCommandIBulkWriteStrategy<Family>());
+    await parentsRepo.createBulk([
+      Object.assign(new Family(), { id: 1, label: "a", children: [Object.assign(new Child(), { id: 10, label: "x" })] }),
+      Object.assign(new Family(), { id: 2, label: "b", children: [Object.assign(new Child(), { id: 11, label: "y" })] }),
+    ]);
+    expect(command.executeCalls).toHaveLength(2);
+    expect(command.executeCalls[0]?.text).toContain("INSERT INTO parents");
+    expect(command.executeCalls[1]?.text).toContain("INSERT INTO children");
+    expect(command.executeCalls[1]?.text).toContain("label__0");
+    expect(command.executeCalls[1]?.text).toContain("label__1");
+  });
+
+  it("stored procedure persists children in one call", async () => {
+    const { parentsRepo, command } = family(
+      new StoredProcedureBulkWriteStrategy<Family>("bulk_create_parent", "bulk_update_parent", "bulk_delete_parent"),
+      new StoredProcedureBulkWriteStrategy<Child>("bulk_create_child", "bulk_update_child", "bulk_delete_child"),
+    );
+    await parentsRepo.createBulk([
+      Object.assign(new Family(), { id: 1, label: "a", children: [Object.assign(new Child(), { id: 10, label: "x" })] }),
+      Object.assign(new Family(), { id: 2, label: "b", children: [Object.assign(new Child(), { id: 11, label: "y" })] }),
+    ]);
+    expect(command.executeCalls).toHaveLength(2);
+    expect(command.executeCalls[0]?.text).toBe("CALL bulk_create_parent($payload)");
+    expect(command.executeCalls[1]?.text).toBe("CALL bulk_create_child($payload)");
+  });
+
+  it("stored procedure create writes generated ids onto items", async () => {
+    const { repo, command } = open(
+      Parent,
+      new StoredProcedureBulkWriteStrategy<Parent>("bulk_create_parent", "bulk_update_parent", "bulk_delete_parent"),
+    );
+    command.response = {
+      result: null,
+      rowsAffected: 2,
+      parameters: [
+        { name: "payload", value: "[]" },
+        { name: "ids", value: "[7,8]", direction: "inputOutput" },
+      ],
+    };
+    const items = [Object.assign(new Parent(), { label: "a" }), Object.assign(new Parent(), { label: "b" })];
+    await repo.createBulk(items);
+    expect(items[0]?.id).toBe(7);
+    expect(items[1]?.id).toBe(8);
+  });
+
+  it("batch create requires a parent id when children are present", async () => {
+    const { parentsRepo } = family(new BatchCommandIBulkWriteStrategy<Family>());
+    await expect(
+      parentsRepo.createBulk([
+        Object.assign(new Family(), { label: "a", children: [Object.assign(new Child(), { label: "x" })] }),
+      ]),
+    ).rejects.toThrow(/id/);
+  });
+
+  it("empty list does not execute", async () => {
+    for (const strategy of [
+      new SingleCommandIBulkWriteStrategy<Parent>(),
+      new BatchCommandIBulkWriteStrategy<Parent>(),
+      new StoredProcedureBulkWriteStrategy<Parent>("create_parent", "update_parent", "delete_parent"),
+    ]) {
+      const { repo, command } = open(Parent, strategy);
+      const created = await repo.createBulk([]);
+      const updated = await repo.updateBulk([]);
+      const deleted = await repo.deleteBulk([]);
+      expect(command.executeCalls).toEqual([]);
+      expect(created).toEqual([]);
+      expect(updated.rowsAffected).toBe(0);
+      expect(deleted.rowsAffected).toBe(0);
+    }
+  });
+});