@roc-db/test-utils 0.2.0-pre.12 → 0.2.0-pre.14

package/dist/index.js

@@ -128,94 +128,108 @@ var entities = [
   DraftSchema,
   PostSchema
 ];
-// src/operations/createBlockImage.ts
+// src/operations/applyDraft.ts
 import { Query, 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;
+  return Query(() => txn.applyChangeSet(ref));
+});
+
+// src/operations/createBlockImage.ts
+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 = writeOperation(CreateBlockImageMutationSchema, BlockImageSchema, (txn) => {
+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, 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 QueryChain(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 QueryChain2, 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) => {
+  return QueryChain2(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
     }
@@ -223,57 +237,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 QueryChain3, 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 QueryChain3(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 QueryChain4, 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 QueryChain4(Query10(() => txn.readEntity(ref)), Query10((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
@@ -282,36 +296,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: [] }
@@ -319,14 +333,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,

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/test-utils",
-    "version": "0.2.0-pre.12",
+    "version": "0.2.0-pre.14",
     "type": "module",
     "exports": {
         ".": {
@@ -17,7 +17,7 @@
     ],
     "sideEffects": false,
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.12",
+        "roc-db": "0.2.0-pre.14",
         "zod": "3.24.2"
     },
     "keywords": [],