@roc-db/test-utils 0.2.0-pre.4 → 0.2.0-pre.41

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";
@@ -128,95 +128,115 @@ var entities = [
   DraftSchema,
   PostSchema
 ];
-// src/operations/createBlockImage.ts
-import { Query, writeOperation } from "roc-db";
+// src/operations/applyDraft.ts
+import { Query, QueryChain, writeOperation } from "roc-db";
 
-// src/schemas/CreateBlockImageMutationSchema.ts
+// src/schemas/ApplyDraftMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator5 } from "roc-db";
 import { z as z10 } from "zod";
-var CreateBlockImageMutationSchema = mutationSchemaGenerator5("createBlockImage", z10.object({ postRef: PostRefSchema }).strict(), undefined, true);
+var ApplyDraftMutationSchema = mutationSchemaGenerator5("applyDraft", z10.object({ ref: DraftRefSchema }).strict());
+
+// src/operations/applyDraft.ts
+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.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
+    }
+  })));
+});
 
 // src/operations/createBlockImage.ts
-var createBlockImage = writeOperation(CreateBlockImageMutationSchema, BlockImageSchema, (txn) => {
+import { Query as Query2, writeOperation as writeOperation2 } from "roc-db";
+
+// src/schemas/CreateBlockImageMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator6 } from "roc-db";
+import { z as z11 } from "zod";
+var CreateBlockImageMutationSchema = mutationSchemaGenerator6("createBlockImage", z11.object({ postRef: PostRefSchema }).strict(), undefined, true);
+
+// src/operations/createBlockImage.ts
+var createBlockImage = writeOperation2(CreateBlockImageMutationSchema, BlockImageSchema, (txn) => {
   const ref = txn.createRef("BlockImage");
   const { postRef } = txn.payload;
-  return Query(() => txn.createEntity(ref, { parents: { post: postRef } }));
+  return Query2(() => txn.createEntity(ref, { parents: { post: postRef } }));
 }, { changeSetOnly: true });
 
 // src/operations/createBlockParagraph.ts
-import { Query as Query2, QueryChain, writeOperation as writeOperation2 } from "roc-db";
+import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
 
 // src/schemas/CreateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator6 } from "roc-db";
-import { z as z11 } from "zod";
+import { mutationSchemaGenerator as mutationSchemaGenerator7 } from "roc-db";
+import { z as z12 } from "zod";
 
 // src/schemas/BlockRowRefSchema.ts
 import { refSchemaGenerator as refSchemaGenerator7 } from "roc-db";
 var BlockRowRefSchema = refSchemaGenerator7("BlockRow");
 
 // src/schemas/CreateBlockParagraphMutationSchema.ts
-var CreateBlockParagraphMutationSchema = mutationSchemaGenerator6("createBlockParagraph", z11.object({ parentRef: z11.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
+var CreateBlockParagraphMutationSchema = mutationSchemaGenerator7("createBlockParagraph", z12.object({ parentRef: z12.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
 
 // src/operations/createBlockParagraph.ts
-var createBlockParagrah = writeOperation2(CreateBlockParagraphMutationSchema, BlockParagraphSchema, (txn) => {
+var createBlockParagrah = writeOperation3(CreateBlockParagraphMutationSchema, BlockParagraphSchema, (txn) => {
   const ref = txn.createRef("BlockParagraph");
   const { parentRef } = txn.payload;
-  return QueryChain(Query2(() => txn.readEntity(parentRef, true)), Query2((parent) => txn.patchEntity(parentRef, {
+  return QueryChain2(Query3(() => txn.readEntity(parentRef, true)), Query3((parent) => txn.patchEntity(parentRef, {
     children: { blocks: [...parent.children.blocks, ref] }
-  })), Query2(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query2((block, updatedParent) => ({ block, updatedParent })));
+  })), Query3(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query3((block, updatedParent) => ({ block, updatedParent })));
 }, { changeSetOnly: true });
 
 // src/operations/createBlockRow.ts
-import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
+import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOperation4 } from "roc-db";
 
 // src/schemas/CreateBlockRowMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator7 } from "roc-db";
-import { z as z12 } from "zod";
-var CreateBlockRowMutationSchema = mutationSchemaGenerator7("createBlockRow", z12.object({ parentRef: z12.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
+import { mutationSchemaGenerator as mutationSchemaGenerator8 } from "roc-db";
+import { z as z13 } from "zod";
+var CreateBlockRowMutationSchema = mutationSchemaGenerator8("createBlockRow", z13.object({ parentRef: z13.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
 
 // src/operations/createBlockRow.ts
-var createBlockRow = writeOperation3(CreateBlockRowMutationSchema, BlockParagraphSchema, (txn) => {
+var createBlockRow = writeOperation4(CreateBlockRowMutationSchema, BlockParagraphSchema, (txn) => {
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
-  return QueryChain2(Query3(() => txn.readEntity(parentRef)), Query3((parent) => {
-    console.log("asdfasfd", parent);
+  return QueryChain3(Query4(() => txn.readEntity(parentRef)), Query4((parent) => {
     return txn.patchEntity(parentRef, {
       children: { blocks: [...parent.children.blocks, ref] }
     });
-  }), Query3(() => txn.createEntity(ref, {
+  }), Query4(() => txn.createEntity(ref, {
     children: { blocks: [] },
     parents: { parent: parentRef }
-  })), Query3((block, updatedParent) => ({ block, updatedParent })));
+  })), Query4((block, updatedParent) => ({ block, updatedParent })));
 }, { changeSetOnly: true });
 
 // src/operations/createBlockTitle.ts
-import { Query as Query4, writeOperation as writeOperation4 } from "roc-db";
+import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
 
 // src/schemas/CreateBlockTitleMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator8 } from "roc-db";
-import { z as z13 } from "zod";
-var CreateBlockTitleMutationSchema = mutationSchemaGenerator8("createBlockTitle", z13.object({ parentRef: z13.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
+import { mutationSchemaGenerator as mutationSchemaGenerator9 } from "roc-db";
+import { z as z14 } from "zod";
+var CreateBlockTitleMutationSchema = mutationSchemaGenerator9("createBlockTitle", z14.object({ parentRef: z14.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
 
 // src/operations/createBlockTitle.ts
-var createBlockTitle = writeOperation4(CreateBlockTitleMutationSchema, BlockTitleSchema, (txn) => {
+var createBlockTitle = writeOperation5(CreateBlockTitleMutationSchema, BlockTitleSchema, (txn) => {
   const ref = txn.createRef("BlockTitle");
   const { postRef } = txn.payload;
-  return Query4(() => txn.createEntity(ref, { parents: { post: postRef } }));
+  return Query5(() => txn.createEntity(ref, { parents: { post: postRef } }));
 }, { changeSetOnly: true });
 
 // src/operations/createDraft.ts
-import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
+import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
 
 // src/schemas/CreateDraftMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator9 } from "roc-db";
-import { z as z14 } from "zod";
-var CreateDraftMutationSchema = mutationSchemaGenerator9("createDraft", z14.object({ postRef: PostRefSchema }).strict());
+import { mutationSchemaGenerator as mutationSchemaGenerator10 } from "roc-db";
+import { z as z15 } from "zod";
+var CreateDraftMutationSchema = mutationSchemaGenerator10("createDraft", z15.object({ postRef: PostRefSchema }).strict());
 
 // src/operations/createDraft.ts
-var createDraft = writeOperation5(CreateDraftMutationSchema, DraftSchema, (txn) => {
+var createDraft = writeOperation6(CreateDraftMutationSchema, DraftSchema, (txn) => {
   const ref = txn.createRef("Draft");
   const { postRef } = txn.payload;
-  return Query5(() => txn.createEntity(ref, {
+  return Query6(() => txn.createEntity(ref, {
     parents: {
       post: postRef
     }
@@ -224,57 +244,83 @@ var createDraft = writeOperation5(CreateDraftMutationSchema, DraftSchema, (txn)
 });
 
 // src/operations/createPost.ts
-import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
-var createPost = writeOperation6(CreatePostMutationSchema, PostSchema, (txn) => {
+import { Query as Query7, writeOperation as writeOperation7 } from "roc-db";
+var createPost = writeOperation7(CreatePostMutationSchema, PostSchema, (txn) => {
   const ref = txn.createRef("Post");
   const { title, slug, tags } = txn.payload;
-  return Query6(() => txn.createEntity(ref, {
+  return Query7(() => txn.createEntity(ref, {
     data: { title, tags, slug },
     children: { blocks: [] }
   }));
 });
 
-// src/operations/deleteBlock.ts
-import { Query as Query7, QueryChain as QueryChain3, writeOperation as writeOperation7 } from "roc-db";
-
-// src/schemas/DeleteBlockMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator10 } from "roc-db";
-import { z as z15 } from "zod";
-var DeleteBlockMutationSchema = mutationSchemaGenerator10("deleteBlock", z15.union([BlockParagraphRefSchema, BlockImageRefSchema]));
+// src/operations/deleteBlocks.ts
+import { Query as Query8, QueryChain as QueryChain4, writeOperation as writeOperation8 } from "roc-db";
 
-// src/operations/deleteBlock.ts
-var deleteBlock = writeOperation7(DeleteBlockMutationSchema, PostSchema, (txn) => {
-  const blockRef = txn.payload;
-  return QueryChain3(Query7(() => txn.readEntity(blockRef, true)), Query7((block) => txn.readEntity(block.parents.post, true)), Query7((post) => {
+// src/schemas/DeleteBlocksMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator11 } from "roc-db";
+import { z as z16 } from "zod";
+var DeleteBlocksMutationSchema = mutationSchemaGenerator11("deleteBlocks", z16.array(z16.union([
+  BlockParagraphRefSchema,
+  BlockImageRefSchema,
+  BlockRowRefSchema
+])));
+
+// src/operations/deleteBlocks.ts
+var DeleteBlockQuery = (txn, blockRef) => {
+  return QueryChain4(Query8(() => txn.readEntity(blockRef)), Query8((block) => {
+    return txn.readEntity(block.parents.parent, true);
+  }), Query8((post) => {
     return txn.patchEntity(post.ref, {
-      data: {
-        blockRefs: post.data.blockRefs.filter((ref) => ref !== blockRef)
+      children: {
+        blocks: post.children.blocks.filter((ref) => ref !== blockRef)
       }
     });
-  }), Query7(() => txn.deleteEntity(blockRef)), Query7((_, updatedPost) => {
-    return updatedPost;
-  }));
+  }), Query8(() => txn.deleteEntity(blockRef)));
+};
+var deleteBlocks = writeOperation8(DeleteBlocksMutationSchema, PostSchema, (txn) => {
+  const refs = txn.payload;
+  return QueryChain4(...refs.map((ref) => DeleteBlockQuery(txn, ref)));
 }, { changeSetOnly: true });
 
 // src/operations/deletePost.ts
-import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
+import { Query as Query9, writeOperation as writeOperation9 } from "roc-db";
 
 // src/schemas/DeletePostMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator11 } from "roc-db";
-var DeletePostMutationSchema = mutationSchemaGenerator11("deletePost", PostRefSchema);
+import { mutationSchemaGenerator as mutationSchemaGenerator12 } from "roc-db";
+var DeletePostMutationSchema = mutationSchemaGenerator12("deletePost", PostRefSchema);
 
 // src/operations/deletePost.ts
-var deletePost = writeOperation8(DeletePostMutationSchema, undefined, (txn) => {
+var deletePost = writeOperation9(DeletePostMutationSchema, undefined, (txn) => {
   const ref = txn.payload;
-  return Query8(() => txn.deleteEntity(ref, true));
+  return Query9(() => txn.deleteEntity(ref, true));
+});
+
+// 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 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 Query9, QueryChain as QueryChain4, readOperation } from "roc-db";
-import { z as z16 } from "zod";
-var readEntity = readOperation("readEntity", z16.string(), z16.union([PostSchema, BlockImageSchema, BlockParagraphSchema]), (txn) => {
+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 QueryChain4(Query9(() => txn.readEntity(ref)), Query9((entity) => {
+  return QueryChain6(Query11(() => txn.readEntity(ref)), Query11((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
@@ -283,158 +329,448 @@ var readEntity = readOperation("readEntity", z16.string(), z16.union([PostSchema
 });
 
 // src/operations/readPost.ts
-import { Query as Query10, 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 Query10(() => txn.readEntity(ref));
+  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 Query11, writeOperation as writeOperation9 } from "roc-db";
+import { Query as Query14, writeOperation as writeOperation12 } from "roc-db";
 
 // src/schemas/UpdateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator12 } from "roc-db";
-import { z as z17 } from "zod";
-var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator12("updateBlockParagraph", z17.object({
+import { mutationSchemaGenerator as mutationSchemaGenerator15 } from "roc-db";
+import { z as z20 } from "zod";
+var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator15("updateBlockParagraph", z20.object({
   ref: BlockParagraphRefSchema,
-  content: z17.string()
+  content: z20.string()
 }));
 
 // src/operations/updateBlockParagraph.ts
-var updateBlockParagraph = writeOperation9(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
+var updateBlockParagraph = writeOperation12(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
   const { ref, content } = txn.payload;
-  return Query11(() => txn.patchEntity(ref, {
+  return Query14(() => txn.patchEntity(ref, {
     data: { content }
   }));
 });
 
 // src/operations/updatePost.ts
-import { Query as Query12, writeOperation as writeOperation10 } from "roc-db";
-var updatePost = writeOperation10(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 Query12(() => txn.updateEntity(ref, {
+  return Query15(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
   }));
 });
 
+// src/operations/updatePostDescription.ts
+import { Query as Query16, writeOperation as writeOperation14 } from "roc-db";
+
+// src/schemas/UpdatePostDescriptionMutationSchema.ts
+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 = writeOperation14(UpdatePostDescriptionMutationSchema, PostSchema, (txn) => {
+  const { ref, description } = txn.payload;
+  return Query16(() => txn.patchEntity(ref, { data: { description } }));
+}, { debounce: 10, changeSetOnly: true });
+
 // src/operations/updatePostTitle.ts
-import { Query as Query13, writeOperation as writeOperation11 } from "roc-db";
-var updatePostTitle = writeOperation11(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 Query13(() => txn.patchEntity(ref, { data: { title } }));
+  return Query17(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10 });
 
 // src/operations/index.ts
 var operations = [
+  applyDraft,
   createBlockImage,
   createBlockTitle,
   createBlockParagrah,
   createBlockRow,
   createDraft,
   createPost,
-  deleteBlock,
+  deleteBlocks,
   deletePost,
+  moveBlocks,
   readEntity,
   readPost,
+  testTransactionalEdits,
   updateBlockParagraph,
   updatePost,
+  updatePostDescription,
   updatePostTitle
 ];
 // src/testAdapterImplementation.ts
-import { beforeAll, describe, expect, test } from "bun:test";
-import { NotFoundError as NotFoundError2 } from "roc-db";
-var prepareChangeSetTest = async (adapter) => {
-  const [post] = await adapter.createPost({
+import { beforeAll, describe, expect as expect2, test } from "bun:test";
+import { BadRequestError, NotFoundError as NotFoundError2, Snowflake } from "roc-db";
+var snowflake = new Snowflake(10, 10);
+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, ...engineArgsAdapter1 });
-    const adapter2 = adapterConstructor({ operations, entities, ...engineArgsAdapter2 });
-    describe("changeSet", async () => {
-      let postRef, draftRef, changeSetAdapter, block, post, blockRow, blockParagraph2;
-      beforeAll(async () => {
-        const res = await prepareChangeSetTest(adapter1);
-        postRef = res.postRef;
-        draftRef = res.draftRef;
-        changeSetAdapter = res.changeSetAdapter;
-        block = res.blockParagraph1;
-        blockRow = res.blockRow;
-        blockParagraph2 = res.blockParagraph2;
-        post = res.post;
+var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
+  let createAdapter = async ({ optimistic = false } = {}) => {
+    return adapterConstructor({
+      operations,
+      entities,
+      session: { identityRef: "User/42" },
+      snowflake,
+      optimistic,
+      ...await generateArgs()
+    });
+  };
+  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("create (createEntity function w/changeSetRef)", async () => {
-        expect(block).toMatchZodSchema(BlockParagraphSchema);
-        expect(post).toMatchZodSchema(PostSchema);
+      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("read (readEntity function w/changeSetRef)", async () => {
-        const read = await changeSetAdapter.readEntity(block.ref);
-        expect(read).toMatchZodSchema(BlockParagraphSchema);
+      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("delete (with cascade delete)", async () => {
-        const [count, mutation] = await changeSetAdapter.deletePost(postRef);
-        expect(count).toBe(4);
-        expect(mutation.log).toStrictEqual([
-          [block.ref, "delete", draftRef],
-          [blockRow.ref, "delete", draftRef],
-          [blockParagraph2.ref, "delete", draftRef],
-          [postRef, "delete", draftRef]
-        ]);
+      expect2(update1).toMatchZodSchema(PostSchema);
+      expect2(mutation1).toMatchZodSchema(UpdatePostTitleMutationSchema);
+      const [update2, mutation2] = await adapter1.updatePostTitle({
+        ref: postRef,
+        title: "Title 4"
       });
-      test("update (patchEntity function w/changeSetRef)", async () => {
-        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
-          ref: block.ref,
-          content: "Hello, world!"
-        });
-        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+      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);
+    });
+    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 [{ persistedAt, ...mutation }] = await adapter2.persistOptimisticMutations([createPostMutation]);
+      expect2(mutation).toStrictEqual(createPostMutation);
+    });
+    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.skip("delete (deleteEntity function w/changeSetRef)", async () => {
-        const [updatedBlock, deleteMutation] = await changeSetAdapter.deleteBlock(block.ref);
-        expect(deleteMutation.log).toStrictEqual([
-          [postRef, "update", draftRef],
-          [block.ref, "delete", draftRef]
-        ]);
-        expect(() => changeSetAdapter.readEntity(block.ref)).toThrow(NotFoundError2);
-        expect(() => changeSetAdapter.updateBlockParagraph({
-          ref: block.ref,
-          content: "Foo"
-        })).toThrow(NotFoundError2);
+      expect2(mutation.log).toHaveLength(0);
+      const [, mutation2] = await adapter1.testTransactionalEdits({
+        post1ref: post1.ref
       });
+      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!"
+      });
+      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 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
+      });
+      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
+      });
+      expect2(res.length).toBeGreaterThan(0);
+      expect2(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
+    });
+    test("invalid changeSetRef throws error", async () => {
+      const changeSetAdapter2 = adapter1.changeSet("Draft/123");
+      expect2(() => changeSetAdapter2.createPost({ title: "Title 1" })).toThrow(BadRequestError);
+    });
+    test("deleteBlocks (patch running 2 times removing on array element every time)", async () => {
+      const [post2, createPostMutation] = await adapter1.createPost({
+        title: "Title 1",
+        slug: "title-1",
+        tags: ["Foo", "Bar"]
+      });
+      const [draft2, createDraftMutation] = await adapter1.createDraft({
+        postRef: post2.ref
+      });
+      const changeSetAdapter2 = adapter1.changeSet(draft2.ref);
+      const [{ block: blockParagraph12 }, createBlockParagraph1Mutation] = await changeSetAdapter2.createBlockParagraph({
+        parentRef: post2.ref
+      });
+      const [{ block: blockParagraph22 }, createBlockParagraph2Mutation] = await changeSetAdapter2.createBlockParagraph({
+        parentRef: post2.ref
+      });
+      const readPost2 = await changeSetAdapter2.readEntity(post2.ref);
+      expect2(readPost2.children.blocks).toEqual([
+        blockParagraph12.ref,
+        blockParagraph22.ref
+      ]);
+      const [, deleteMutation] = await changeSetAdapter2.deleteBlocks([
+        blockParagraph12.ref,
+        blockParagraph22.ref
+      ]);
+      expect2(deleteMutation.log[0][2].children.blocks).toEqual([
+        blockParagraph12.ref,
+        blockParagraph22.ref
+      ]);
+      expect2(deleteMutation.log[0][2].updated.mutationRef).toBe(createBlockParagraph2Mutation.ref);
+      const readPost22 = await changeSetAdapter2.readEntity(post2.ref);
+      expect2(readPost22.updated.mutationRef).toEqual(deleteMutation.ref);
+    });
+    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({ optimistic: true });
+      const adapterB = await createAdapter({ optimistic: true });
+      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.loadMutations(allMutationsAdapter1);
+      const allMutationsAdapter2after = await adapterB.pageMutations({});
+      expect2(allMutationsAdapter2after.length).toBe(allMutationsAdapter1.length);
+      const res2 = await adapterB.loadMutations(allMutationsAdapter1);
+    });
+    test("persistOptimisticMutations", async () => {
+      const persistedAdapter = await createAdapter({ optimistic: false });
+      const optimisticAdapter = await createAdapter({ optimistic: true });
+      expect2(persistedAdapter.persistOptimisticMutations).toBeDefined();
+      expect2(optimisticAdapter.loadMutations).toBeDefined();
+      const [, createPostMutation] = await optimisticAdapter.createPost({
+        title: "Foo",
+        tags: []
+      });
+      const [persistCratePostMutation] = await persistedAdapter.persistOptimisticMutations([
+        createPostMutation
+      ]);
+      expect2(persistCratePostMutation.persistedAt >= createPostMutation.timestamp).toBeTrue();
+    });
+  });
 };
 // src/inMemoryAdapter.ts
 import { createInMemoryAdapter } from "@roc-db/in-memory";
 var inMemoryAdapter = createInMemoryAdapter({
   operations,
-  entities
+  entities,
+  session: {
+    identityRef: "User/42"
+  }
 });
 export {
   testAdapterImplementation,