@roc-db/test-utils 0.2.0-pre.45 → 0.2.0-pre.46

package/dist/index.js

@@ -40,101 +40,148 @@ var BlockParagraphSchema = entitySchemaGenerator2("BlockParagraph", {
   })
 });
 
-// src/schemas/BlockTitleSchema.ts
+// src/schemas/BlockRowSchema.ts
 import { entitySchemaGenerator as entitySchemaGenerator3 } from "roc-db";
+import { z as z4 } from "zod";
+
+// src/schemas/BlockRowRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator4 } from "roc-db";
+var BlockRowRefSchema = refSchemaGenerator4("BlockRow");
+
+// src/schemas/BlockRefSchema.ts
 import { z as z3 } from "zod";
+var BlockRefSchema = z3.union([
+  BlockParagraphRefSchema,
+  BlockRowRefSchema
+]);
+
+// src/schemas/BlockRowSchema.ts
+var BlockRowSchema = entitySchemaGenerator3("BlockRow", {
+  ref: BlockRowRefSchema,
+  children: z4.object({
+    blocks: z4.array(BlockRefSchema)
+  }),
+  parents: z4.object({
+    post: PostRefSchema,
+    block: BlockRefSchema
+  })
+});
+
+// src/schemas/BlockTitleSchema.ts
+import { entitySchemaGenerator as entitySchemaGenerator4 } from "roc-db";
+import { z as z5 } from "zod";
 
 // src/schemas/BlockTitleRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator4 } from "roc-db";
-var BlockTitleRefSchema = refSchemaGenerator4("BlockTitle");
+import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
+var BlockTitleRefSchema = refSchemaGenerator5("BlockTitle");
 
 // src/schemas/BlockTitleSchema.ts
-var BlockTitleSchema = entitySchemaGenerator3("BlockTitle", {
+var BlockTitleSchema = entitySchemaGenerator4("BlockTitle", {
   ref: BlockTitleRefSchema,
-  data: z3.object({
-    content: z3.string()
+  data: z5.object({
+    content: z5.string()
   }),
-  parents: z3.object({
+  parents: z5.object({
     post: PostRefSchema
   })
 });
 
 // src/schemas/DraftSchema.ts
-import { entitySchemaGenerator as entitySchemaGenerator4 } from "roc-db";
-import { z as z4 } from "zod";
+import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
+import { z as z6 } from "zod";
 
 // src/schemas/DraftRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
-var DraftRefSchema = refSchemaGenerator5("Draft");
+import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
+var DraftRefSchema = refSchemaGenerator6("Draft");
 
 // src/schemas/DraftSchema.ts
-var DraftSchema = entitySchemaGenerator4("Draft", {
+var DraftSchema = entitySchemaGenerator5("Draft", {
   ref: DraftRefSchema,
-  data: z4.object({
+  data: z6.object({
     postRef: PostRefSchema
   })
 });
 
 // src/schemas/PostSchema.ts
-import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
-import { z as z5 } from "zod";
+import { entitySchemaGenerator as entitySchemaGenerator6 } from "roc-db";
+import { z as z7 } from "zod";
 
 // src/schemas/UserRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
-var UserRefSchema = refSchemaGenerator6("User");
+import { refSchemaGenerator as refSchemaGenerator7 } from "roc-db";
+var UserRefSchema = refSchemaGenerator7("User");
 
 // src/schemas/PostSchema.ts
-var PostSchema = entitySchemaGenerator5("Post", {
+var PostSchema = entitySchemaGenerator6("Post", {
   ref: PostRefSchema,
-  data: z5.object({
-    title: z5.string(),
-    text: z5.string().optional(),
-    tags: z5.array(z5.string()),
-    slug: z5.string().optional()
+  data: z7.object({
+    title: z7.string(),
+    text: z7.string().optional(),
+    tags: z7.array(z7.string()),
+    slug: z7.string().optional()
   }),
-  parents: z5.object({ author: UserRefSchema.optional() }),
-  children: z5.object({ blocks: z5.array(z5.string()) })
+  parents: z7.object({ author: UserRefSchema.optional() }),
+  children: z7.object({ blocks: z7.array(z7.string()) })
+});
+
+// src/schemas/PostVersionSchema.ts
+import { entitySchemaGenerator as entitySchemaGenerator7 } from "roc-db";
+import { z as z8 } from "zod";
+
+// src/schemas/PostVersionRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator8 } from "roc-db";
+var PostVersionRefSchema = refSchemaGenerator8("PostVersion");
+
+// src/schemas/PostVersionSchema.ts
+var PostVersionSchema = entitySchemaGenerator7("PostVersion", {
+  ref: PostVersionRefSchema,
+  data: z8.object({
+    version: z8.number(),
+    snapshot: z8.array(z8.any())
+  }),
+  parents: z8.object({ post: PostRefSchema })
 });
 // src/schemas/CreatePostMutationSchema.ts
 import { mutationSchemaGenerator } from "roc-db";
-import { z as z6 } from "zod";
-var CreatePostMutationSchema = mutationSchemaGenerator("createPost", z6.object({
-  title: z6.string(),
-  slug: z6.string().optional(),
-  tags: z6.array(z6.string()).default([])
+import { z as z9 } from "zod";
+var CreatePostMutationSchema = mutationSchemaGenerator("createPost", z9.object({
+  title: z9.string(),
+  slug: z9.string().optional(),
+  tags: z9.array(z9.string()).default([])
 }).strict());
 // src/schemas/CreateUserMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator2 } from "roc-db";
-import { z as z7 } from "zod";
-var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z7.object({ email: z7.string() }));
+import { z as z10 } from "zod";
+var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z10.object({ email: z10.string() }));
 // src/schemas/UpdatePostMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator3 } from "roc-db";
-import { z as z8 } from "zod";
-var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z8.object({
+import { z as z11 } from "zod";
+var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z11.object({
   ref: PostRefSchema,
-  title: z8.string().optional(),
-  tags: z8.array(z8.string()).optional().default([]),
+  title: z11.string().optional(),
+  tags: z11.array(z11.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 }));
 // src/schemas/UpdatePostTitleMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator4 } from "roc-db";
-import { z as z9 } from "zod";
-var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z9.object({ ref: PostRefSchema, title: z9.string() }));
+import { z as z12 } from "zod";
+var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z12.object({ ref: PostRefSchema, title: z12.string() }));
 // src/schemas/index.ts
 var entities = [
+  BlockRowSchema,
   BlockImageSchema,
   BlockParagraphSchema,
   BlockTitleSchema,
   DraftSchema,
-  PostSchema
+  PostSchema,
+  PostVersionSchema
 ];
 // src/operations/applyDraft.ts
 import { Query, QueryChain, writeOperation } from "roc-db";
 
 // src/schemas/ApplyDraftMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator5 } from "roc-db";
-import { z as z10 } from "zod";
-var ApplyDraftMutationSchema = mutationSchemaGenerator5("applyDraft", z10.object({ ref: DraftRefSchema }).strict());
+import { z as z13 } from "zod";
+var ApplyDraftMutationSchema = mutationSchemaGenerator5("applyDraft", z13.object({ ref: DraftRefSchema }).strict());
 
 // src/operations/applyDraft.ts
 var applyDraft = writeOperation(ApplyDraftMutationSchema, undefined, (txn) => {
@@ -154,8 +201,8 @@ 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);
+import { z as z14 } from "zod";
+var CreateBlockImageMutationSchema = mutationSchemaGenerator6("createBlockImage", z14.object({ postRef: PostRefSchema }).strict(), undefined, true);
 
 // src/operations/createBlockImage.ts
 var createBlockImage = writeOperation2(CreateBlockImageMutationSchema, BlockImageSchema, (txn) => {
@@ -169,14 +216,8 @@ import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOper
 
 // src/schemas/CreateBlockParagraphMutationSchema.ts
 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 = mutationSchemaGenerator7("createBlockParagraph", z12.object({ parentRef: z12.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
+import { z as z15 } from "zod";
+var CreateBlockParagraphMutationSchema = mutationSchemaGenerator7("createBlockParagraph", z15.object({ parentRef: z15.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
 
 // src/operations/createBlockParagraph.ts
 var createBlockParagrah = writeOperation3(CreateBlockParagraphMutationSchema, BlockParagraphSchema, (txn) => {
@@ -192,8 +233,8 @@ import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOper
 
 // src/schemas/CreateBlockRowMutationSchema.ts
 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);
+import { z as z16 } from "zod";
+var CreateBlockRowMutationSchema = mutationSchemaGenerator8("createBlockRow", z16.object({ parentRef: z16.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
 
 // src/operations/createBlockRow.ts
 var createBlockRow = writeOperation4(CreateBlockRowMutationSchema, BlockParagraphSchema, (txn) => {
@@ -214,8 +255,8 @@ import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
 
 // src/schemas/CreateBlockTitleMutationSchema.ts
 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);
+import { z as z17 } from "zod";
+var CreateBlockTitleMutationSchema = mutationSchemaGenerator9("createBlockTitle", z17.object({ parentRef: z17.union([PostRefSchema, BlockRowRefSchema]) }).strict(), undefined, true);
 
 // src/operations/createBlockTitle.ts
 var createBlockTitle = writeOperation5(CreateBlockTitleMutationSchema, BlockTitleSchema, (txn) => {
@@ -229,8 +270,8 @@ import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
 
 // src/schemas/CreateDraftMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator10 } from "roc-db";
-import { z as z15 } from "zod";
-var CreateDraftMutationSchema = mutationSchemaGenerator10("createDraft", z15.object({ postRef: PostRefSchema }).strict());
+import { z as z18 } from "zod";
+var CreateDraftMutationSchema = mutationSchemaGenerator10("createDraft", z18.object({ postRef: PostRefSchema }).strict());
 
 // src/operations/createDraft.ts
 var createDraft = writeOperation6(CreateDraftMutationSchema, DraftSchema, (txn) => {
@@ -259,8 +300,8 @@ import { Query as Query8, QueryChain as QueryChain4, writeOperation as writeOper
 
 // 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([
+import { z as z19 } from "zod";
+var DeleteBlocksMutationSchema = mutationSchemaGenerator11("deleteBlocks", z19.array(z19.union([
   BlockParagraphRefSchema,
   BlockImageRefSchema,
   BlockRowRefSchema
@@ -283,44 +324,57 @@ var deleteBlocks = writeOperation8(DeleteBlocksMutationSchema, PostSchema, (txn)
   return QueryChain4(...refs.map((ref) => DeleteBlockQuery(txn, ref)));
 }, { changeSetOnly: true });
 
+// src/operations/deleteDraft.ts
+import { Query as Query9, QueryChain as QueryChain5, writeOperation as writeOperation9 } from "roc-db";
+
+// src/schemas/DeleteDraftMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator12 } from "roc-db";
+var DeleteDraftMutationSchema = mutationSchemaGenerator12("deleteDraft", DraftRefSchema);
+
+// src/operations/deleteDraft.ts
+var deleteDraft = writeOperation9(DeleteDraftMutationSchema, undefined, (txn) => {
+  const ref = txn.payload;
+  return QueryChain5(Query9(() => txn.deleteEntity(ref, true)), Query9(() => txn.deleteChangeSet(ref)));
+});
+
 // src/operations/deletePost.ts
-import { Query as Query9, writeOperation as writeOperation9 } from "roc-db";
+import { Query as Query10, writeOperation as writeOperation10 } from "roc-db";
 
 // src/schemas/DeletePostMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator12 } from "roc-db";
-var DeletePostMutationSchema = mutationSchemaGenerator12("deletePost", PostRefSchema);
+import { mutationSchemaGenerator as mutationSchemaGenerator13 } from "roc-db";
+var DeletePostMutationSchema = mutationSchemaGenerator13("deletePost", PostRefSchema);
 
 // src/operations/deletePost.ts
-var deletePost = writeOperation9(DeletePostMutationSchema, undefined, (txn) => {
+var deletePost = writeOperation10(DeletePostMutationSchema, undefined, (txn) => {
   const ref = txn.payload;
-  return Query9(() => txn.deleteEntity(ref, true));
+  return Query10(() => txn.deleteEntity(ref, true));
 });
 
 // src/operations/moveBlocks.ts
-import { Query as Query10, QueryChain as QueryChain5, writeOperation as writeOperation10 } from "roc-db";
+import { Query as Query11, QueryChain as QueryChain6, writeOperation as writeOperation11 } 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)
+import { mutationSchemaGenerator as mutationSchemaGenerator14 } from "roc-db";
+import { z as z20 } from "zod";
+var MoveBlocksMutationSchema = mutationSchemaGenerator14("moveBlocks", z20.object({
+  refs: z20.array(z20.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z20.number().min(0)
 }).strict(), undefined, true);
 
 // src/operations/moveBlocks.ts
-var moveBlocks = writeOperation10(MoveBlocksMutationSchema, undefined, (txn) => {
+var moveBlocks = writeOperation11(MoveBlocksMutationSchema, undefined, (txn) => {
   const { refs } = txn.payload;
-  return QueryChain5(Query10(() => txn.batchReadEntities(refs)), Query10((items) => {
+  return QueryChain6(Query11(() => txn.batchReadEntities(refs)), Query11((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) => {
+import { NotFoundError, Query as Query12, QueryChain as QueryChain7, readOperation } from "roc-db";
+import { z as z21 } from "zod";
+var readEntity = readOperation("readEntity", z21.string(), z21.union([PostSchema, BlockImageSchema, BlockParagraphSchema]), (txn) => {
   const ref = txn.payload;
-  return QueryChain6(Query11(() => txn.readEntity(ref)), Query11((entity) => {
+  return QueryChain7(Query12(() => txn.readEntity(ref)), Query12((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
@@ -329,11 +383,11 @@ var readEntity = readOperation("readEntity", z18.string(), z18.union([PostSchema
 });
 
 // src/operations/readMutation.ts
-import { NotFoundError as NotFoundError2, Query as Query12, QueryChain as QueryChain7, readOperation as readOperation2 } from "roc-db";
-import { z as z19 } from "zod";
-var readMutation = readOperation2("readMutation", z19.string(), z19.any(), (txn) => {
+import { NotFoundError as NotFoundError2, Query as Query13, QueryChain as QueryChain8, readOperation as readOperation2 } from "roc-db";
+import { z as z22 } from "zod";
+var readMutation = readOperation2("readMutation", z22.string(), z22.any(), (txn) => {
   const ref = txn.payload;
-  return QueryChain7(Query12(() => txn.readMutation(ref)), Query12((entity) => {
+  return QueryChain8(Query13(() => txn.readMutation(ref)), Query13((entity) => {
     if (!entity) {
       throw new NotFoundError2(ref);
     }
@@ -342,20 +396,20 @@ var readMutation = readOperation2("readMutation", z19.string(), z19.any(), (txn)
 });
 
 // src/operations/readPost.ts
-import { Query as Query13, readOperation as readOperation3 } from "roc-db";
+import { Query as Query14, readOperation as readOperation3 } from "roc-db";
 var readPost = readOperation3("readPost", PostRefSchema, PostSchema, (txn) => {
   const ref = txn.payload;
-  return Query13(() => txn.readEntity(ref, true));
+  return Query14(() => txn.readEntity(ref, true));
 });
 
 // src/operations/testTransactionalEdits.ts
-import { Query as Query14, QueryChain as QueryChain8, writeOperation as writeOperation11 } from "roc-db";
+import { Query as Query15, QueryChain as QueryChain9, writeOperation as writeOperation12 } from "roc-db";
 
 // src/schemas/TestTransactionalEditsMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator14 } from "roc-db";
-import { z as z20 } from "zod";
-var TestTransactionalEditsMutationSchema = mutationSchemaGenerator14("testTransactionalEdits", z20.object({
-  name: z20.string().optional(),
+import { mutationSchemaGenerator as mutationSchemaGenerator15 } from "roc-db";
+import { z as z23 } from "zod";
+var TestTransactionalEditsMutationSchema = mutationSchemaGenerator15("testTransactionalEdits", z23.object({
+  name: z23.string().optional(),
   post1ref: PostRefSchema.optional(),
   post2ref: PostRefSchema.optional()
 }).strict());
@@ -364,29 +418,29 @@ var TestTransactionalEditsMutationSchema = mutationSchemaGenerator14("testTransa
 import { expect } from "bun:test";
 var TestCreatePatchDeleteInSameTransaction = (txn, name) => {
   const postRef = txn.createRef("Post");
-  QueryChain8(Query14(() => txn.createEntity(postRef, { data: { name } })), Query14(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query14((post) => {
+  QueryChain9(Query15(() => txn.createEntity(postRef, { data: { name } })), Query15(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query15((post) => {
     expect(post.data.name).toBe(name);
     expect(post.data.foo).toBe("bar");
-  }), Query14(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query14((post) => {
+  }), Query15(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query15((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");
-  }), Query14((post) => txn.deleteEntity(postRef)), Query14((res) => {
+  }), Query15((post) => txn.deleteEntity(postRef)), Query15((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(0);
   }));
 };
 var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
-  return QueryChain8(Query14(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query14((post) => {
+  return QueryChain9(Query15(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query15((post) => {
     expect(post.data.foo).toBe("bar");
-  }), Query14(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query14((post) => {
+  }), Query15(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query15((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");
-  }), Query14((post) => txn.deleteEntity(ref)), Query14((res) => {
+  }), Query15((post) => txn.deleteEntity(ref)), Query15((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(ref)[0]).toBe("delete");
@@ -394,9 +448,9 @@ var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
 };
 var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
-  return QueryChain8(Query14(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query14(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+  return QueryChain9(Query15(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query15(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var testTransactionalEdits = writeOperation11(TestTransactionalEditsMutationSchema, PostSchema, (txn) => {
+var testTransactionalEdits = writeOperation12(TestTransactionalEditsMutationSchema, PostSchema, (txn) => {
   const { name, post1ref, post2ref } = txn.payload;
   if (name)
     return TestCreatePatchDeleteInSameTransaction(txn, name);
@@ -407,29 +461,29 @@ var testTransactionalEdits = writeOperation11(TestTransactionalEditsMutationSche
 }, {});
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query15, writeOperation as writeOperation12 } from "roc-db";
+import { Query as Query16, writeOperation as writeOperation13 } from "roc-db";
 
 // src/schemas/UpdateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator15 } from "roc-db";
-import { z as z21 } from "zod";
-var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator15("updateBlockParagraph", z21.object({
+import { mutationSchemaGenerator as mutationSchemaGenerator16 } from "roc-db";
+import { z as z24 } from "zod";
+var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator16("updateBlockParagraph", z24.object({
   ref: BlockParagraphRefSchema,
-  content: z21.string()
+  content: z24.string()
 }));
 
 // src/operations/updateBlockParagraph.ts
-var updateBlockParagraph = writeOperation12(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
+var updateBlockParagraph = writeOperation13(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
   const { ref, content } = txn.payload;
-  return Query15(() => txn.patchEntity(ref, {
+  return Query16(() => txn.patchEntity(ref, {
     data: { content }
   }));
 });
 
 // src/operations/updatePost.ts
-import { Query as Query16, writeOperation as writeOperation13 } from "roc-db";
-var updatePost = writeOperation13(UpdatePostMutationSchema, PostSchema, (txn) => {
+import { Query as Query17, writeOperation as writeOperation14 } from "roc-db";
+var updatePost = writeOperation14(UpdatePostMutationSchema, PostSchema, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query16(() => txn.updateEntity(ref, {
+  return Query17(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -437,24 +491,24 @@ var updatePost = writeOperation13(UpdatePostMutationSchema, PostSchema, (txn) =>
 });
 
 // src/operations/updatePostDescription.ts
-import { Query as Query17, writeOperation as writeOperation14 } from "roc-db";
+import { Query as Query18, writeOperation as writeOperation15 } from "roc-db";
 
 // src/schemas/UpdatePostDescriptionMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator16 } from "roc-db";
-import { z as z22 } from "zod";
-var UpdatePostDescriptionMutationSchema = mutationSchemaGenerator16("updatePostDescription", z22.object({ ref: PostRefSchema, description: z22.string() }));
+import { mutationSchemaGenerator as mutationSchemaGenerator17 } from "roc-db";
+import { z as z25 } from "zod";
+var UpdatePostDescriptionMutationSchema = mutationSchemaGenerator17("updatePostDescription", z25.object({ ref: PostRefSchema, description: z25.string() }));
 
 // src/operations/updatePostDescription.ts
-var updatePostDescription = writeOperation14(UpdatePostDescriptionMutationSchema, PostSchema, (txn) => {
+var updatePostDescription = writeOperation15(UpdatePostDescriptionMutationSchema, PostSchema, (txn) => {
   const { ref, description } = txn.payload;
-  return Query17(() => txn.patchEntity(ref, { data: { description } }));
+  return Query18(() => txn.patchEntity(ref, { data: { description } }));
 }, { debounce: 10, changeSetOnly: true });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query18, writeOperation as writeOperation15 } from "roc-db";
-var updatePostTitle = writeOperation15(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
+import { Query as Query19, writeOperation as writeOperation16 } from "roc-db";
+var updatePostTitle = writeOperation16(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
   const { ref, title } = txn.payload;
-  return Query18(() => txn.patchEntity(ref, { data: { title } }));
+  return Query19(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10 });
 
 // src/operations/index.ts
@@ -467,6 +521,7 @@ var operations = [
   createDraft,
   createPost,
   deleteBlocks,
+  deleteDraft,
   deletePost,
   moveBlocks,
   readEntity,
@@ -745,6 +800,18 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
         ref: draftRef2
       });
     });
+    test("deleteDraft", async () => {
+      const { draftRef: draftRef2 } = await prepareChangeSetTest(adapter1);
+      const mutationsBefore = await adapter1.pageMutations({
+        changeSetRef: draftRef2
+      });
+      const [, mutation] = await adapter1.deleteDraft(draftRef2);
+      expect2(mutation.log).toHaveLength(mutationsBefore.length + 1);
+      const mutationsAfter = await adapter1.pageMutations({
+        changeSetRef: draftRef2
+      });
+      expect2(mutationsAfter).toHaveLength(0);
+    });
     test("init adapter2", async () => {
       const adapterA = await createAdapter({ optimistic: true });
       const adapterB = await createAdapter({ optimistic: true });

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

@@ -10,7 +10,7 @@ export declare const createBlockImage: import("roc-db").WriteOperation<string, {
     parents: {
         post: `Post/${string}`;
     };
-    entity: string;
+    entity: "BlockImage";
     created: {
         mutationRef: `Mutation/${string}`;
         timestamp: string;

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

@@ -10,7 +10,7 @@ export declare const createBlockParagrah: import("roc-db").WriteOperation<string
     parents: {
         parent: `Post/${string}`;
     };
-    entity: string;
+    entity: "BlockParagraph";
     created: {
         mutationRef: `Mutation/${string}`;
         timestamp: string;

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

@@ -10,7 +10,7 @@ export declare const createBlockRow: import("roc-db").WriteOperation<string, {
     parents: {
         parent: `Post/${string}`;
     };
-    entity: string;
+    entity: "BlockParagraph";
     created: {
         mutationRef: `Mutation/${string}`;
         timestamp: string;

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

@@ -10,7 +10,7 @@ export declare const createBlockTitle: import("roc-db").WriteOperation<string, {
     parents: {
         post: `Post/${string}`;
     };
-    entity: string;
+    entity: "BlockTitle";
     created: {
         mutationRef: `Mutation/${string}`;
         timestamp: string;

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

@@ -8,7 +8,7 @@ export declare const createDraft: import("roc-db").WriteOperation<string, {
         postRef: `Post/${string}`;
     };
     parents: {};
-    entity: string;
+    entity: "Draft";
     created: {
         mutationRef: `Mutation/${string}`;
         timestamp: string;

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

@@ -13,7 +13,7 @@ export declare const createPost: import("roc-db").WriteOperation<string, {
     parents: {
         author?: `User/${string}` | undefined;
     };
-    entity: string;
+    entity: "Post";
     created: {
         mutationRef: `Mutation/${string}`;
         timestamp: string;

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

@@ -13,7 +13,7 @@ export declare const deleteBlocks: import("roc-db").WriteOperation<string, {
     parents: {
         author?: `User/${string}` | undefined;
     };
-    entity: string;
+    entity: "Post";
     created: {
         mutationRef: `Mutation/${string}`;
         timestamp: string;

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

@@ -0,0 +1,5 @@
+export declare const deleteDraft: import("roc-db").WriteOperation<string, {
+    debounceCount: number;
+    name: string;
+    payload?: any;
+}, any, any>;