@roc-db/test-utils 0.2.0-pre.2 → 0.2.0-pre.21

package/dist/index.js

@@ -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.mutation.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,57 @@ 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";
+import { Query as Query8, QueryChain as QueryChain4, writeOperation as writeOperation8 } 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]));
+import { mutationSchemaGenerator as mutationSchemaGenerator11 } from "roc-db";
+import { z as z16 } from "zod";
+var DeleteBlockMutationSchema = mutationSchemaGenerator11("deleteBlock", z16.union([BlockParagraphRefSchema, BlockImageRefSchema]));
 
 // src/operations/deleteBlock.ts
-var deleteBlock = writeOperation7(DeleteBlockMutationSchema, PostSchema, (txn) => {
+var deleteBlock = writeOperation8(DeleteBlockMutationSchema, PostSchema, (txn) => {
   const blockRef = txn.payload;
-  return QueryChain3(Query7(() => txn.readEntity(blockRef, true)), Query7((block) => txn.readEntity(block.parents.post, true)), Query7((post) => {
+  return QueryChain4(Query8(() => txn.readEntity(blockRef, true)), Query8((block) => txn.readEntity(block.parents.post, true)), Query8((post) => {
     return txn.patchEntity(post.ref, {
       data: {
         blockRefs: post.data.blockRefs.filter((ref) => ref !== blockRef)
       }
     });
-  }), Query7(() => txn.deleteEntity(blockRef)), Query7((_, updatedPost) => {
+  }), Query8(() => txn.deleteEntity(blockRef)), Query8((_, updatedPost) => {
     return updatedPost;
   }));
 }, { 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/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 Query10, QueryChain as QueryChain5, readOperation } from "roc-db";
+import { z as z17 } from "zod";
+var readEntity = readOperation("readEntity", z17.string(), z17.union([PostSchema, BlockImageSchema, BlockParagraphSchema]), (txn) => {
   const ref = txn.payload;
-  return QueryChain4(Query9(() => txn.readEntity(ref)), Query9((entity) => {
+  return QueryChain5(Query10(() => txn.readEntity(ref)), Query10((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
@@ -283,36 +303,36 @@ 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 Query11, readOperation as readOperation2 } from "roc-db";
 var readPost = readOperation2("readPost", PostRefSchema, PostSchema, (txn) => {
   const ref = txn.payload;
-  return Query10(() => txn.readEntity(ref));
+  return Query11(() => txn.readEntity(ref));
 });
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query11, writeOperation as writeOperation9 } from "roc-db";
+import { Query as Query12, writeOperation as writeOperation10 } 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 mutationSchemaGenerator13 } from "roc-db";
+import { z as z18 } from "zod";
+var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator13("updateBlockParagraph", z18.object({
   ref: BlockParagraphRefSchema,
-  content: z17.string()
+  content: z18.string()
 }));
 
 // src/operations/updateBlockParagraph.ts
-var updateBlockParagraph = writeOperation9(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
+var updateBlockParagraph = writeOperation10(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
   const { ref, content } = txn.payload;
-  return Query11(() => txn.patchEntity(ref, {
+  return Query12(() => 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 Query13, writeOperation as writeOperation11 } from "roc-db";
+var updatePost = writeOperation11(UpdatePostMutationSchema, PostSchema, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query12(() => txn.updateEntity(ref, {
+  return Query13(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -320,14 +340,15 @@ var updatePost = writeOperation10(UpdatePostMutationSchema, PostSchema, (txn) =>
 });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query13, writeOperation as writeOperation11 } from "roc-db";
-var updatePostTitle = writeOperation11(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
+import { Query as Query14, writeOperation as writeOperation12 } from "roc-db";
+var updatePostTitle = writeOperation12(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
   const { ref, title } = txn.payload;
-  return Query13(() => txn.patchEntity(ref, { data: { title } }));
+  return Query14(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10 });
 
 // src/operations/index.ts
 var operations = [
+  applyDraft,
   createBlockImage,
   createBlockTitle,
   createBlockParagrah,
@@ -344,7 +365,7 @@ var operations = [
 ];
 // src/testAdapterImplementation.ts
 import { beforeAll, describe, expect, test } from "bun:test";
-import { NotFoundError as NotFoundError2 } from "roc-db";
+import { BadRequestError, NotFoundError as NotFoundError2 } from "roc-db";
 var prepareChangeSetTest = async (adapter) => {
   const [post] = await adapter.createPost({
     title: "Title 1",
@@ -376,56 +397,143 @@ var prepareChangeSetTest = async (adapter) => {
 };
 var testAdapterImplementation = (adapterConstructor, engineArgsAdapter1 = {}, engineArgsAdapter2 = {}) => {
   return async () => {
-    const adapter1 = adapterConstructor({ operations, entities, ...engineArgsAdapter1 });
-    const adapter2 = adapterConstructor({ operations, entities, ...engineArgsAdapter2 });
+    const adapter1 = adapterConstructor({
+      operations,
+      entities,
+      session: { identityRef: "User/42" },
+      ...engineArgsAdapter1
+    });
+    const adapter2 = adapterConstructor({
+      operations,
+      entities,
+      session: { identityRef: "User/42" },
+      ...engineArgsAdapter2
+    });
+    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"]);
+      });
+      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("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 updatePostTitleRes1 = await adapter1.updatePostTitle({
+          ref: postRef,
+          title: "Title 3"
+        });
+        expect(updatePostTitleRes1[0]).toMatchZodSchema(PostSchema);
+        const updatePostTitleRes2 = await adapter1.updatePostTitle({
+          ref: postRef,
+          title: "Title 4"
+        });
+        expect(updatePostTitleRes2[0]).toMatchZodSchema(PostSchema);
+        expect(updatePostTitleRes2[1].ref).toBe(updatePostTitleRes1[1].ref);
+        expect(updatePostTitleRes2[1].timestamp >= updatePostTitleRes1[1].timestamp).toBeTrue();
+      });
+      test("delete (deleteEntity function)", async () => {
+        const [count, mutation] = await adapter1.deletePost(postRef);
+        expect(count).toBe(1);
+        expect(mutation.log).toStrictEqual([[postRef, "delete", null]]);
+      });
+      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);
+      });
+    });
     describe("changeSet", async () => {
-      let postRef, draftRef, changeSetAdapter, block, post, blockRow, blockParagraph2;
+      let postRef, draftRef, changeSetAdapter, blockParagraph1, 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;
+        ({
+          postRef,
+          draftRef,
+          changeSetAdapter,
+          blockParagraph1,
+          post,
+          blockRow,
+          blockParagraph2
+        } = await prepareChangeSetTest(adapter1));
       });
       test("create (createEntity function w/changeSetRef)", async () => {
-        expect(block).toMatchZodSchema(BlockParagraphSchema);
+        expect(blockParagraph1).toMatchZodSchema(BlockParagraphSchema);
         expect(post).toMatchZodSchema(PostSchema);
       });
       test("read (readEntity function w/changeSetRef)", async () => {
-        const read = await changeSetAdapter.readEntity(block.ref);
+        const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
         expect(read).toMatchZodSchema(BlockParagraphSchema);
       });
+      test("update (patchEntity function w/changeSetRef)", async () => {
+        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
+          ref: blockParagraph1.ref,
+          content: "Hello, world!"
+        });
+        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+      });
       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],
+          [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("update (patchEntity function w/changeSetRef)", async () => {
-        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
-          ref: block.ref,
-          content: "Hello, world!"
+      test("pageMutations", async () => {
+        const res = await changeSetAdapter.pageMutations({
+          changeSetRef: draftRef
         });
-        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+        expect(res.length).toBeGreaterThan(0);
+        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
       });
-      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);
+      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();
+      });
+      describe("create and apply draft", () => {
+        test("applyDraft", async () => {
+          const { draftRef: draftRef2 } = await prepareChangeSetTest(adapter1);
+          const [version, mutation] = await adapter1.applyDraft({
+            ref: draftRef2
+          });
+        });
       });
     });
   };
@@ -434,7 +542,10 @@ var testAdapterImplementation = (adapterConstructor, engineArgsAdapter1 = {}, en
 import { createInMemoryAdapter } from "@roc-db/in-memory";
 var inMemoryAdapter = createInMemoryAdapter({
   operations,
-  entities
+  entities,
+  session: {
+    identityRef: "User/42"
+  }
 });
 export {
   testAdapterImplementation,

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./schemas";
-export * from "./operations";
+export { operations } from "./operations";
 export { testAdapterImplementation } from "./testAdapterImplementation";
 export { inMemoryAdapter } from "./inMemoryAdapter";

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

@@ -0,0 +1,13 @@
+export declare const applyDraft: import("roc-db").WriteOperation<"applyDraft", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Draft/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "applyDraft";
+}, {
+    ref: `Draft/${string}`;
+}, any>;

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

@@ -1,4 +1,16 @@
-export declare const operations: readonly [import("roc-db").WriteOperation<"createBlockImage", {
+export declare const operations: readonly [import("roc-db").WriteOperation<"applyDraft", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Draft/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "applyDraft";
+}, {
+    ref: `Draft/${string}`;
+}, any>, import("roc-db").WriteOperation<"createBlockImage", {
     ref: `Mutation/${string}`;
     timestamp: string;
     changeSetRef: null;

package/dist/types/schemas/ApplyDraftMutationSchema.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const ApplyDraftMutationSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+    timestamp: z.ZodString;
+    changeSetRef: z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodAny;
+    log: z.ZodArray<z.ZodTuple<[z.ZodType<never, z.ZodTypeDef, never>, z.ZodString, z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>], null>, "many">;
+    debounceCount: z.ZodNumber;
+}, {
+    name: z.ZodLiteral<"applyDraft">;
+    changeSetRef: z.ZodType<never, z.ZodTypeDef, never> | z.ZodNullable<z.ZodType<never, z.ZodTypeDef, never>>;
+    payload: z.ZodObject<{
+        ref: z.ZodType<`Draft/${string}`, z.ZodTypeDef, `Draft/${string}`>;
+    }, "strict", z.ZodTypeAny, {
+        ref: `Draft/${string}`;
+    }, {
+        ref: `Draft/${string}`;
+    }>;
+    log: z.ZodType<[never, string, null][], z.ZodTypeDef, [never, string, null][]>;
+}>, "strict", z.ZodTypeAny, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Draft/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "applyDraft";
+}, {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        ref: `Draft/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "applyDraft";
+}>;

package/dist/types/schemas/BlockParagraphSchema.d.ts

@@ -30,3 +30,4 @@ export declare const BlockParagraphSchema: z.ZodObject<z.objectUtil.extendShape<
 }, {
     [x: string]: any;
 }>;
+export type BlockParagraph = z.infer<typeof BlockParagraphSchema>;

package/dist/types/schemas/BlockRefSchema.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const BlockRefSchema: z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;

package/dist/types/schemas/BlockRowSchema.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const BlockRowSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<never, z.ZodTypeDef, never>;
+    entity: z.ZodString;
+    created: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    updated: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    data: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    ancestors: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, z.ZodRawShape>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+export type BlockRow = z.infer<typeof BlockRowSchema>;

package/dist/types/schemas/PostSchema.d.ts

@@ -30,3 +30,4 @@ export declare const PostSchema: z.ZodObject<z.objectUtil.extendShape<{
 }, {
     [x: string]: any;
 }>;
+export type Post = z.infer<typeof PostSchema>;

package/package.json

@@ -1,30 +1,23 @@
 {
     "name": "@roc-db/test-utils",
-    "version": "0.2.0-pre.2",
+    "version": "0.2.0-pre.21",
     "type": "module",
     "exports": {
-        ".": "./src/index.ts",
-        "./setup": "./src/setup/index.ts"
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/types/index.d.ts"
+        },
+        "./setup": {
+            "import": "./dist/setup/index.js",
+            "types": "./dist/types/setup/index.d.ts"
+        }
     },
     "files": [
         "dist"
     ],
     "sideEffects": false,
-    "scripts": {
-        "build": "NODE_ENV=production bun run scripts/build.ts",
-        "build:types": "rm -rf dist/types && bun run tsc --noCheck",
-        "test": "echo"
-    },
-    "devDependencies": {
-        "@faker-js/faker": "9.6.0",
-        "@types/bun": "1.2.5",
-        "@types/sanitize-html": "2.13.0",
-        "bun": "1.2.5",
-        "expect-type": "1.2.0",
-        "roc-db": "0.2.0-pre.2"
-    },
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.2",
+        "roc-db": "0.2.0-pre.21",
         "zod": "3.24.2"
     },
     "keywords": [],