@roc-db/test-utils 0.2.0-pre.32 → 0.2.0-pre.34

package/dist/index.js

@@ -114,7 +114,7 @@ var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z8.object(
   ref: PostRefSchema,
   title: z8.string().optional(),
   tags: z8.array(z8.string()).optional().default([]),
-  authorRef: UserRefSchema.optional().optional()
+  authorRef: UserRefSchema.optional()
 }));
 // src/schemas/UpdatePostTitleMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator4 } from "roc-db";
@@ -141,7 +141,7 @@ var applyDraft = writeOperation(ApplyDraftMutationSchema, undefined, (txn) => {
   const { ref } = txn.payload;
   const versionRef = txn.createRef("PostVersion");
   return QueryChain(Query(() => txn.applyChangeSet(ref)), Query(() => txn.patchEntity(ref, {
-    data: { appliedAt: txn.mutation.timestamp }
+    data: { appliedAt: txn.timestamp }
   })), Query((draft) => txn.childRefsOf(draft.parents.post, true)), Query((childRefs, draft) => txn.batchReadEntities([draft.parents.post, ...childRefs])), Query((childEntities) => txn.createEntity(versionRef, {
     data: {
       snapshot: childEntities
@@ -289,12 +289,31 @@ var deletePost = writeOperation9(DeletePostMutationSchema, undefined, (txn) => {
   return Query9(() => txn.deleteEntity(ref, true));
 });
 
-// src/operations/readEntity.ts
-import { NotFoundError, Query as Query10, QueryChain as QueryChain5, readOperation } from "roc-db";
+// src/operations/moveBlocks.ts
+import { Query as Query10, QueryChain as QueryChain5, writeOperation as writeOperation10 } from "roc-db";
+
+// src/schemas/MoveBlocksMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator13 } from "roc-db";
 import { z as z17 } from "zod";
-var readEntity = readOperation("readEntity", z17.string(), z17.union([PostSchema, BlockImageSchema, BlockParagraphSchema]), (txn) => {
+var MoveBlocksMutationSchema = mutationSchemaGenerator13("moveBlocks", z17.object({
+  refs: z17.array(z17.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z17.number().min(0)
+}).strict(), undefined, true);
+
+// src/operations/moveBlocks.ts
+var moveBlocks = writeOperation10(MoveBlocksMutationSchema, undefined, (txn) => {
+  const { refs } = txn.payload;
+  return QueryChain5(Query10(() => txn.batchReadEntities(refs)), Query10((items) => {
+    return "todo";
+  }));
+});
+
+// src/operations/readEntity.ts
+import { NotFoundError, Query as Query11, QueryChain as QueryChain6, readOperation } from "roc-db";
+import { z as z18 } from "zod";
+var readEntity = readOperation("readEntity", z18.string(), z18.union([PostSchema, BlockImageSchema, BlockParagraphSchema]), (txn) => {
   const ref = txn.payload;
-  return QueryChain5(Query10(() => txn.readEntity(ref)), Query10((entity) => {
+  return QueryChain6(Query11(() => txn.readEntity(ref)), Query11((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
@@ -303,36 +322,94 @@ var readEntity = readOperation("readEntity", z17.string(), z17.union([PostSchema
 });
 
 // src/operations/readPost.ts
-import { Query as Query11, readOperation as readOperation2 } from "roc-db";
+import { Query as Query12, readOperation as readOperation2 } from "roc-db";
 var readPost = readOperation2("readPost", PostRefSchema, PostSchema, (txn) => {
   const ref = txn.payload;
-  return Query11(() => txn.readEntity(ref, true));
+  return Query12(() => txn.readEntity(ref, true));
 });
 
+// src/operations/testTransactionalEdits.ts
+import { Query as Query13, QueryChain as QueryChain7, writeOperation as writeOperation11 } from "roc-db";
+
+// src/schemas/TestTransactionalEditsMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator14 } from "roc-db";
+import { z as z19 } from "zod";
+var TestTransactionalEditsMutationSchema = mutationSchemaGenerator14("testTransactionalEdits", z19.object({
+  name: z19.string().optional(),
+  post1ref: PostRefSchema.optional(),
+  post2ref: PostRefSchema.optional()
+}).strict());
+
+// src/operations/testTransactionalEdits.ts
+import { expect } from "bun:test";
+var TestCreatePatchDeleteInSameTransaction = (txn, name) => {
+  const postRef = txn.createRef("Post");
+  QueryChain7(Query13(() => txn.createEntity(postRef, { data: { name } })), Query13(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query13((post) => {
+    expect(post.data.name).toBe(name);
+    expect(post.data.foo).toBe("bar");
+  }), Query13(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query13((post) => {
+    expect(post.data.name).toBe(name);
+    expect(post.data.foo).toBeUndefined();
+    expect(post.data.bar).toBe("foo");
+    expect(txn.log).toHaveLength(1);
+    expect(txn.log.get(postRef)[0]).toBe("create");
+  }), Query13((post) => txn.deleteEntity(postRef)), Query13((res) => {
+    expect(res).toBe(1);
+    expect(txn.log).toHaveLength(0);
+  }));
+};
+var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
+  return QueryChain7(Query13(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query13((post) => {
+    expect(post.data.foo).toBe("bar");
+  }), Query13(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query13((post) => {
+    expect(post.data.foo).toBeUndefined();
+    expect(post.data.bar).toBe("foo");
+    expect(txn.log).toHaveLength(1);
+    expect(txn.log.get(ref)[0]).toBe("update");
+  }), Query13((post) => txn.deleteEntity(ref)), Query13((res) => {
+    expect(res).toBe(1);
+    expect(txn.log).toHaveLength(1);
+    expect(txn.log.get(ref)[0]).toBe("delete");
+  }));
+};
+var TestCreateOnExistingRef = (txn) => {
+  const ref = txn.createRef("Post");
+  return QueryChain7(Query13(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query13(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+};
+var testTransactionalEdits = writeOperation11(TestTransactionalEditsMutationSchema, PostSchema, (txn) => {
+  const { name, post1ref, post2ref } = txn.payload;
+  if (name)
+    return TestCreatePatchDeleteInSameTransaction(txn, name);
+  if (post1ref)
+    return TestUpdateAndDeleteInSameTransaction(txn, post1ref);
+  if (post2ref)
+    return TestCreateOnExistingRef(txn);
+}, {});
+
 // src/operations/updateBlockParagraph.ts
-import { Query as Query12, writeOperation as writeOperation10 } from "roc-db";
+import { Query as Query14, writeOperation as writeOperation12 } from "roc-db";
 
 // src/schemas/UpdateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator13 } from "roc-db";
-import { z as z18 } from "zod";
-var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator13("updateBlockParagraph", z18.object({
+import { mutationSchemaGenerator as mutationSchemaGenerator15 } from "roc-db";
+import { z as z20 } from "zod";
+var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator15("updateBlockParagraph", z20.object({
   ref: BlockParagraphRefSchema,
-  content: z18.string()
+  content: z20.string()
 }));
 
 // src/operations/updateBlockParagraph.ts
-var updateBlockParagraph = writeOperation10(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
+var updateBlockParagraph = writeOperation12(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
   const { ref, content } = txn.payload;
-  return Query12(() => txn.patchEntity(ref, {
+  return Query14(() => txn.patchEntity(ref, {
     data: { content }
   }));
 });
 
 // src/operations/updatePost.ts
-import { Query as Query13, writeOperation as writeOperation11 } from "roc-db";
-var updatePost = writeOperation11(UpdatePostMutationSchema, PostSchema, (txn) => {
+import { Query as Query15, writeOperation as writeOperation13 } from "roc-db";
+var updatePost = writeOperation13(UpdatePostMutationSchema, PostSchema, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query13(() => txn.updateEntity(ref, {
+  return Query15(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -340,24 +417,24 @@ var updatePost = writeOperation11(UpdatePostMutationSchema, PostSchema, (txn) =>
 });
 
 // src/operations/updatePostDescription.ts
-import { Query as Query14, writeOperation as writeOperation12 } from "roc-db";
+import { Query as Query16, writeOperation as writeOperation14 } from "roc-db";
 
 // src/schemas/UpdatePostDescriptionMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator14 } from "roc-db";
-import { z as z19 } from "zod";
-var UpdatePostDescriptionMutationSchema = mutationSchemaGenerator14("updatePostDescription", z19.object({ ref: PostRefSchema, description: z19.string() }));
+import { mutationSchemaGenerator as mutationSchemaGenerator16 } from "roc-db";
+import { z as z21 } from "zod";
+var UpdatePostDescriptionMutationSchema = mutationSchemaGenerator16("updatePostDescription", z21.object({ ref: PostRefSchema, description: z21.string() }));
 
 // src/operations/updatePostDescription.ts
-var updatePostDescription = writeOperation12(UpdatePostDescriptionMutationSchema, PostSchema, (txn) => {
+var updatePostDescription = writeOperation14(UpdatePostDescriptionMutationSchema, PostSchema, (txn) => {
   const { ref, description } = txn.payload;
-  return Query14(() => txn.patchEntity(ref, { data: { description } }));
+  return Query16(() => txn.patchEntity(ref, { data: { description } }));
 }, { debounce: 10, changeSetOnly: true });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query15, writeOperation as writeOperation13 } from "roc-db";
-var updatePostTitle = writeOperation13(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
+import { Query as Query17, writeOperation as writeOperation15 } from "roc-db";
+var updatePostTitle = writeOperation15(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
   const { ref, title } = txn.payload;
-  return Query15(() => txn.patchEntity(ref, { data: { title } }));
+  return Query17(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10 });
 
 // src/operations/index.ts
@@ -371,199 +448,261 @@ var operations = [
   createPost,
   deleteBlock,
   deletePost,
+  moveBlocks,
   readEntity,
   readPost,
+  testTransactionalEdits,
   updateBlockParagraph,
   updatePost,
   updatePostDescription,
   updatePostTitle
 ];
 // src/testAdapterImplementation.ts
-import { beforeAll, describe, expect, test } from "bun:test";
+import { beforeAll, describe, expect as expect2, test } from "bun:test";
 import { BadRequestError, NotFoundError as NotFoundError2 } from "roc-db";
-var prepareChangeSetTest = async (adapter) => {
-  const [post] = await adapter.createPost({
+var prepareChangeSetTest = async (adapter, adapter2) => {
+  const [post, createPostMutation] = await adapter.createPost({
     title: "Title 1",
     slug: "title-1",
     tags: ["Foo", "Bar"]
   });
-  const [draft] = await adapter.createDraft({
+  expect2(createPostMutation.log).toStrictEqual([[post.ref, "create"]]);
+  const [draft, createDraftMutation] = await adapter.createDraft({
     postRef: post.ref
   });
+  expect2(createDraftMutation.log).toStrictEqual([[draft.ref, "create"]]);
   const changeSetAdapter = adapter.changeSet(draft.ref);
-  const [{ block: blockParagraph1 }] = await changeSetAdapter.createBlockParagraph({
+  const [
+    { block: blockParagraph1, updatedParent: updatedPost },
+    createBlockParagraphMutation
+  ] = await changeSetAdapter.createBlockParagraph({
     parentRef: post.ref
   });
-  const [{ block: blockRow, updatedParent }] = await changeSetAdapter.createBlockRow({
+  expect2(updatedPost.children.blocks).toStrictEqual([blockParagraph1.ref]);
+  expect2(updatedPost.children.blocks).toHaveLength(1);
+  expect2(createBlockParagraphMutation.log[0][2].children.blocks).toStrictEqual([]);
+  const readPost1 = await changeSetAdapter.readEntity(post.ref);
+  expect2(readPost1.children.blocks).toHaveLength(1);
+  const [{ block: blockRow, updatedParent: updatedPost2 }, mutation] = await changeSetAdapter.createBlockRow({
     parentRef: post.ref
   });
-  const [{ block: blockParagraph2 }] = await changeSetAdapter.createBlockParagraph({
+  expect2(updatedPost2.children.blocks).toHaveLength(2);
+  const readPost2 = await changeSetAdapter.readEntity(post.ref);
+  expect2(readPost2.children.blocks).toHaveLength(2);
+  const [{ block: blockParagraph2, updatedParent: updatedBlockRow }] = await changeSetAdapter.createBlockParagraph({
     parentRef: blockRow.ref
   });
+  const readPost3 = await changeSetAdapter.readEntity(post.ref);
+  expect2(readPost3.children.blocks).toHaveLength(2);
   return {
     postRef: post.ref,
     draftRef: draft.ref,
     changeSetAdapter,
     blockParagraph1,
     blockParagraph2,
-    blockRow,
-    post: updatedParent
+    blockRow: updatedBlockRow,
+    draft,
+    post: readPost3
   };
 };
-var testAdapterImplementation = (adapterConstructor, engineArgsAdapter1 = {}, engineArgsAdapter2 = {}) => {
-  return async () => {
-    const adapter1 = adapterConstructor({
-      operations,
-      entities,
-      session: { identityRef: "User/42" },
-      ...engineArgsAdapter1
-    });
-    const adapter2 = adapterConstructor({
+var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
+  let createAdapter = async () => {
+    return adapterConstructor({
       operations,
       entities,
       session: { identityRef: "User/42" },
-      ...engineArgsAdapter2
+      ...await generateArgs()
     });
-    describe("Post CRUD", async () => {
-      let postRef;
-      let post;
-      let createPostMutation;
-      beforeAll(async () => {
-        const createPostRes = await adapter1.createPost({
-          title: "Title 1",
-          slug: "title-1",
-          tags: ["Foo", "Bar"]
-        });
-        post = createPostRes[0];
-        postRef = createPostRes[0].ref;
-        createPostMutation = createPostRes[1];
-      });
-      test("create (createEntity function)", async () => {
-        expect(post).toMatchZodSchema(PostSchema);
-        expect(post.data.title).toBe("Title 1");
-        expect(post.data.tags).toStrictEqual(["Foo", "Bar"]);
-        expect(createPostMutation).toMatchZodSchema(CreatePostMutationSchema);
-      });
-      test("read (readEntity function)", async () => {
-        const readPostRes = await adapter1.readPost(postRef);
-        expect(readPostRes.data.title).toStrictEqual("Title 1");
-        expect(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
-        expect(readPostRes).toMatchZodSchema(PostSchema);
-      });
-      test("read not found (readEntity function)", async () => {
-        expect(() => adapter1.readPost("Post/999")).toThrow(NotFoundError2);
-      });
-      test("update (updateEntity function)", async () => {
-        const [post2] = await adapter1.updatePost({
-          ref: postRef,
-          title: "Title 2",
-          tags: ["Foo"]
-        });
-        expect(post2.data.tags).toStrictEqual(["Foo"]);
-        expect(post2.data.title).toBe("Title 2");
-        expect(post2).toMatchZodSchema(PostSchema);
-      });
-      test("updateTitle (patchEntity function + debounce)", async () => {
-        const [update1, mutation1] = await adapter1.updatePostTitle({
-          ref: postRef,
-          title: "Title 3"
-        });
-        expect(update1).toMatchZodSchema(PostSchema);
-        expect(mutation1).toMatchZodSchema(UpdatePostTitleMutationSchema);
-        const [update2, mutation2] = await adapter1.updatePostTitle({
-          ref: postRef,
-          title: "Title 4"
-        });
-        expect(update2).toMatchZodSchema(PostSchema);
-        expect(mutation2).toMatchZodSchema(UpdatePostTitleMutationSchema);
-        expect(mutation1.ref).toBe(mutation2.ref);
-        expect(mutation2.timestamp >= mutation1.timestamp).toBeTrue();
+  };
+  let adapter1, adapter2;
+  beforeAll(async () => {
+    adapter1 = await createAdapter();
+    adapter2 = await createAdapter();
+  });
+  describe("Post CRUD", () => {
+    let postRef;
+    let post;
+    let createPostMutation;
+    beforeAll(async () => {
+      const createPostRes = await adapter1.createPost({
+        title: "Title 1",
+        slug: "title-1",
+        tags: ["Foo", "Bar"]
       });
-      test("updatePostDescription without changeSetAdapter fails with BadRequestError", async () => {
-        expect(() => adapter1.updatePostDescription({
-          ref: postRef,
-          description: "Description 1"
-        })).toThrow(BadRequestError);
+      post = createPostRes[0];
+      postRef = createPostRes[0].ref;
+      createPostMutation = createPostRes[1];
+    });
+    test("create (createEntity function)", async () => {
+      expect2(post).toMatchZodSchema(PostSchema);
+      expect2(post.data.title).toBe("Title 1");
+      expect2(post.data.tags).toStrictEqual(["Foo", "Bar"]);
+      expect2(createPostMutation).toMatchZodSchema(CreatePostMutationSchema);
+    });
+    test("read (readEntity function)", async () => {
+      const readPostRes = await adapter1.readPost(postRef);
+      expect2(readPostRes.data.title).toStrictEqual("Title 1");
+      expect2(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
+      expect2(readPostRes).toMatchZodSchema(PostSchema);
+    });
+    test("read not found (readEntity function)", async () => {
+      expect2(() => adapter1.readPost("Post/999")).toThrow(NotFoundError2);
+    });
+    test.todo("update (updateEntity function)", async () => {
+      const [post2] = await adapter1.updatePost({
+        ref: postRef,
+        title: "Title 2",
+        tags: ["Foo"]
       });
-      test("delete (deleteEntity function)", async () => {
-        const [count, mutation] = await adapter1.deletePost(postRef);
-        expect(count).toBe(1);
-        expect(mutation.log).toStrictEqual([[postRef, "delete", null]]);
+      expect2(post2.data.tags).toStrictEqual(["Foo"]);
+      expect2(post2.data.title).toBe("Title 2");
+      expect2(post2).toMatchZodSchema(PostSchema);
+    });
+    test("updateTitle (patchEntity function + debounce)", async () => {
+      const [update1, mutation1] = await adapter1.updatePostTitle({
+        ref: postRef,
+        title: "Title 3"
       });
-      test("sync mutation", async () => {
-        const res = await adapter2.syncOptimisticMutation(createPostMutation);
-        expect(res[0]).toStrictEqual(post);
-        expect(res[1]).toStrictEqual(createPostMutation);
-        expect(() => adapter2.syncOptimisticMutation(createPostMutation)).toThrowError(BadRequestError);
+      expect2(update1).toMatchZodSchema(PostSchema);
+      expect2(mutation1).toMatchZodSchema(UpdatePostTitleMutationSchema);
+      const [update2, mutation2] = await adapter1.updatePostTitle({
+        ref: postRef,
+        title: "Title 4"
       });
+      expect2(update2).toMatchZodSchema(PostSchema);
+      expect2(mutation2).toMatchZodSchema(UpdatePostTitleMutationSchema);
+      expect2(mutation1.ref).toBe(mutation2.ref);
+      expect2(mutation2.timestamp >= mutation1.timestamp).toBeTrue();
+    });
+    test("updatePostDescription without changeSetAdapter fails with BadRequestError", async () => {
+      expect2(() => adapter1.updatePostDescription({
+        ref: postRef,
+        description: "Description 1"
+      })).toThrow(BadRequestError);
     });
-    describe("changeSet", async () => {
-      let postRef, draftRef, changeSetAdapter, blockParagraph1, post, blockRow, blockParagraph2;
-      beforeAll(async () => {
-        ({
-          postRef,
-          draftRef,
-          changeSetAdapter,
-          blockParagraph1,
-          post,
-          blockRow,
-          blockParagraph2
-        } = await prepareChangeSetTest(adapter1));
+    test("delete (deleteEntity function)", async () => {
+      const currentPost = await adapter1.readPost(postRef);
+      expect2(currentPost.ref).toBe(postRef);
+      const [count, mutation] = await adapter1.deletePost(postRef);
+      expect2(count).toBe(1);
+      expect2(mutation.log).toStrictEqual([
+        [postRef, "delete", currentPost]
+      ]);
+      expect2(() => adapter1.readPost(postRef)).toThrow(NotFoundError2);
+    });
+    test("sync mutation", async () => {
+      const res = await adapter2.syncOptimisticMutation(createPostMutation);
+      expect2(res[0]).toStrictEqual(post);
+      expect2(res[1]).toStrictEqual(createPostMutation);
+      expect2(() => adapter2.syncOptimisticMutation(createPostMutation)).toThrowError(BadRequestError);
+    });
+    test("create, patch and delete the same item within the same transaction", async () => {
+      const [post1] = await adapter1.createPost({ title: "Post 1" });
+      const [post2] = await adapter1.createPost({ title: "Post 1" });
+      const [currentPost, mutation] = await adapter1.testTransactionalEdits({
+        name: "Test"
       });
-      test("create (createEntity function w/changeSetRef)", async () => {
-        expect(blockParagraph1).toMatchZodSchema(BlockParagraphSchema);
-        expect(post).toMatchZodSchema(PostSchema);
+      expect2(mutation.log).toHaveLength(0);
+      const [, mutation2] = await adapter1.testTransactionalEdits({
+        post1ref: post1.ref
       });
-      test("read (readEntity function w/changeSetRef)", async () => {
-        const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
-        expect(read).toMatchZodSchema(BlockParagraphSchema);
+      expect2(mutation2.log).toHaveLength(1);
+      expect2(mutation2.log[0][1]).toBe("delete");
+      expect2(() => adapter1.testTransactionalEdits({
+        post2ref: post2.ref
+      })).toThrow(BadRequestError);
+    });
+  });
+  describe("changeSet", () => {
+    let postRef, draftRef, changeSetAdapter, blockParagraph1, post, blockRow, blockParagraph2, draft;
+    beforeAll(async () => {
+      ({
+        postRef,
+        draftRef,
+        changeSetAdapter,
+        blockParagraph1,
+        post,
+        blockRow,
+        blockParagraph2,
+        draft
+      } = await prepareChangeSetTest(adapter1, adapter2));
+    });
+    test("create (createEntity function w/changeSetRef)", async () => {
+      expect2(blockParagraph1).toMatchZodSchema(BlockParagraphSchema);
+      expect2(post).toMatchZodSchema(PostSchema);
+    });
+    test("read (readEntity function w/changeSetRef)", async () => {
+      const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
+      expect2(read).toMatchZodSchema(BlockParagraphSchema);
+    });
+    test("update (patchEntity function w/changeSetRef)", async () => {
+      const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
+        ref: blockParagraph1.ref,
+        content: "Hello, world!"
       });
-      test("update (patchEntity function w/changeSetRef)", async () => {
-        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
-          ref: blockParagraph1.ref,
-          content: "Hello, world!"
-        });
-        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+      expect2(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+    });
+    test("move (batchReadEntities function)", async () => {
+      const res = await changeSetAdapter.moveBlocks({
+        refs: [blockParagraph1.ref],
+        targetPosition: 1
       });
-      test("delete (with cascade delete)", async () => {
-        const [count, mutation] = await changeSetAdapter.deletePost(postRef);
-        expect(count).toBe(4);
-        expect(mutation.log).toStrictEqual([
-          [blockParagraph1.ref, "delete", draftRef],
-          [blockParagraph2.ref, "delete", draftRef],
-          [blockRow.ref, "delete", draftRef],
-          [postRef, "delete", draftRef]
-        ]);
-        await expect(() => changeSetAdapter.readEntity(blockParagraph1.ref)).toThrow(NotFoundError2);
-        await expect(() => changeSetAdapter.updateBlockParagraph({
-          ref: blockParagraph1.ref,
-          content: "Foo"
-        })).toThrow(NotFoundError2);
+    });
+    test("delete (with cascade delete)", async () => {
+      const postUpdated = await changeSetAdapter.readEntity(postRef);
+      const blockParagraph1Update = await changeSetAdapter.readEntity(blockParagraph1.ref);
+      const blockRowUpdated = await changeSetAdapter.readEntity(blockRow.ref);
+      const [count, mutation] = await changeSetAdapter.deletePost(postRef);
+      expect2(count).toBe(4);
+      expect2(mutation.log).toStrictEqual([
+        [blockParagraph1.ref, "delete", blockParagraph1Update],
+        [blockParagraph2.ref, "delete", blockParagraph2],
+        [blockRow.ref, "delete", blockRowUpdated],
+        [postRef, "delete", postUpdated]
+      ]);
+      await expect2(() => changeSetAdapter.readEntity(blockParagraph1.ref)).toThrow(NotFoundError2);
+      await expect2(() => changeSetAdapter.updateBlockParagraph({
+        ref: blockParagraph1.ref,
+        content: "Foo"
+      })).toThrow(NotFoundError2);
+    });
+    test("pageMutations", async () => {
+      const res = await changeSetAdapter.pageMutations({
+        changeSetRef: draftRef
       });
-      test("pageMutations", async () => {
-        const res = await changeSetAdapter.pageMutations({
-          changeSetRef: draftRef
-        });
-        expect(res.length).toBeGreaterThan(0);
-        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
+      expect2(res.length).toBeGreaterThan(0);
+      expect2(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
+    });
+    test("pageMutations run again", async () => {
+      const res = await changeSetAdapter.pageMutations({
+        changeSetRef: draftRef
       });
-      test("pageMutations run again", async () => {
-        const res = await changeSetAdapter.pageMutations({
-          changeSetRef: draftRef
-        });
-        expect(res.length).toBeGreaterThan(0);
-        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
+      expect2(res.length).toBeGreaterThan(0);
+      expect2(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
+    });
+    test("applyDraft", async () => {
+      const { draftRef: draftRef2 } = await prepareChangeSetTest(adapter1);
+      const [version, mutation] = await adapter1.applyDraft({
+        ref: draftRef2
       });
-      describe("create and apply draft", () => {
-        test("applyDraft", async () => {
-          const { draftRef: draftRef2 } = await prepareChangeSetTest(adapter1);
-          const [version, mutation] = await adapter1.applyDraft({
-            ref: draftRef2
-          });
-        });
+    });
+    test("init adapter2", async () => {
+      const adapterA = await createAdapter();
+      const adapterB = await createAdapter();
+      const { draftRef: draftRef2 } = await prepareChangeSetTest(adapterA, adapterB);
+      const mutations = await adapterA.pageMutations({
+        changeSetRef: draftRef2
       });
+      const allMutationsAdapter1 = await adapterA.pageMutations({});
+      const allMutationsAdapter2 = await adapterB.pageMutations({});
+      expect2(allMutationsAdapter1).not.toBeEmpty();
+      expect2(allMutationsAdapter2).toBeEmpty();
+      const res = await adapterB.loadOptimisticMutations(allMutationsAdapter1);
+      const allMutationsAdapter2after = await adapterB.pageMutations({});
+      expect2(allMutationsAdapter2after.length).toBe(allMutationsAdapter1.length);
+      const res2 = await adapterB.loadOptimisticMutations(allMutationsAdapter1);
     });
-  };
+  });
 };
 // src/inMemoryAdapter.ts
 import { createInMemoryAdapter } from "@roc-db/in-memory";

package/dist/types/operations/applyDraft.d.ts

@@ -5,7 +5,7 @@ export declare const applyDraft: import("roc-db").WriteOperation<"applyDraft", {
     payload: {
         ref: `Draft/${string}`;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
     identityRef: string;
     name: "applyDraft";

package/dist/types/operations/createBlockImage.d.ts

@@ -5,7 +5,7 @@ export declare const createBlockImage: import("roc-db").WriteOperation<"createBl
     payload: {
         postRef: `Post/${string}`;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
     identityRef: string;
     name: "createBlockImage";

package/dist/types/operations/createBlockParagraph.d.ts

@@ -5,7 +5,7 @@ export declare const createBlockParagrah: import("roc-db").WriteOperation<"creat
     payload: {
         parentRef: `Post/${string}` | `BlockRow/${string}`;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
     identityRef: string;
     name: "createBlockParagraph";

package/dist/types/operations/createBlockRow.d.ts

@@ -5,7 +5,7 @@ export declare const createBlockRow: import("roc-db").WriteOperation<"createBloc
     payload: {
         parentRef: `Post/${string}` | `BlockRow/${string}`;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
     identityRef: string;
     name: "createBlockRow";

package/dist/types/operations/createBlockTitle.d.ts

@@ -5,7 +5,7 @@ export declare const createBlockTitle: import("roc-db").WriteOperation<"createBl
     payload: {
         parentRef: `Post/${string}` | `BlockRow/${string}`;
     };
-    log: [never, string, null][];
+    log: any[];
     debounceCount: number;
     identityRef: string;
     name: "createBlockTitle";