@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/ArrayReader.ts

@@ -1,32 +0,0 @@
-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

@@ -1,228 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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>;
-};

package/src/BulkCRUDRepository.test.ts

@@ -1,183 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

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

package/src/BulkWriteEnrichment.ts

@@ -1,19 +0,0 @@
-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);
-};