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

package/dist/index.js

@@ -177,15 +177,8 @@ var entities = [
 ];
 // 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 z13 } from "zod";
-var ApplyDraftMutationSchema = mutationSchemaGenerator5("applyDraft", z13.object({ ref: DraftRefSchema }).strict());
-
-// src/operations/applyDraft.ts
-var applyDraft = writeOperation(ApplyDraftMutationSchema, undefined, (txn) => {
-  const { ref } = txn.payload;
+var applyDraft = writeOperation("applyDraft", DraftRefSchema, (txn) => {
+  const ref = txn.payload;
   const versionRef = txn.createRef("PostVersion");
   return QueryChain(Query(() => txn.applyChangeSet(ref)), Query(() => txn.patchEntity(ref, {
     data: { appliedAt: txn.timestamp }
@@ -198,46 +191,28 @@ var applyDraft = writeOperation(ApplyDraftMutationSchema, undefined, (txn) => {
 
 // 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 z14 } from "zod";
-var CreateBlockImageMutationSchema = mutationSchemaGenerator6("createBlockImage", z14.object({ postRef: PostRefSchema }).strict(), undefined, true);
-
-// src/operations/createBlockImage.ts
-var createBlockImage = writeOperation2(CreateBlockImageMutationSchema, BlockImageSchema, (txn) => {
+import { z as z13 } from "zod";
+var createBlockImage = writeOperation2("createBlockImage", z13.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("BlockImage");
   const { postRef } = txn.payload;
   return Query2(() => txn.createEntity(ref, { parents: { post: postRef } }));
-}, { changeSetOnly: true });
+}, { changeSetOnly: true, outputSchema: BlockImageSchema });
 
 // src/operations/createBlockParagraph.ts
 import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
-
-// src/schemas/CreateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator7 } from "roc-db";
-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) => {
+import { z as z14 } from "zod";
+var createBlockParagrah = writeOperation3("createBlockParagraph", z14.object({ parentRef: z14.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
   const ref = txn.createRef("BlockParagraph");
   const { parentRef } = txn.payload;
   return QueryChain2(Query3(() => txn.readEntity(parentRef, true)), Query3((parent) => txn.patchEntity(parentRef, {
     children: { blocks: [...parent.children.blocks, ref] }
   })), Query3(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query3((block, updatedParent) => ({ block, updatedParent })));
-}, { changeSetOnly: true });
+}, { changeSetOnly: true, outputSchema: BlockParagraphSchema });
 
 // src/operations/createBlockRow.ts
 import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOperation4 } from "roc-db";
-
-// src/schemas/CreateBlockRowMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator8 } from "roc-db";
-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) => {
+import { z as z15 } from "zod";
+var createBlockRow = writeOperation4("createBlockRow", z15.object({ parentRef: z15.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
   return QueryChain3(Query4(() => txn.readEntity(parentRef)), Query4((parent) => {
@@ -248,33 +223,22 @@ var createBlockRow = writeOperation4(CreateBlockRowMutationSchema, BlockParagrap
     children: { blocks: [] },
     parents: { parent: parentRef }
   })), Query4((block, updatedParent) => ({ block, updatedParent })));
-}, { changeSetOnly: true });
+}, { changeSetOnly: true, outputSchema: BlockParagraphSchema });
 
 // src/operations/createBlockTitle.ts
 import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
-
-// src/schemas/CreateBlockTitleMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator9 } from "roc-db";
-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) => {
+import { z as z16 } from "zod";
+var PayloadSchema = z16.object({ parentRef: z16.union([PostRefSchema, BlockRowRefSchema]) }).strict();
+var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn) => {
   const ref = txn.createRef("BlockTitle");
   const { postRef } = txn.payload;
   return Query5(() => txn.createEntity(ref, { parents: { post: postRef } }));
-}, { changeSetOnly: true });
+}, { changeSetOnly: true, outputSchema: BlockTitleSchema });
 
 // src/operations/createDraft.ts
 import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
-
-// src/schemas/CreateDraftMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator10 } from "roc-db";
-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) => {
+import { z as z17 } from "zod";
+var createDraft = writeOperation6("createDraft", z17.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("Draft");
   const { postRef } = txn.payload;
   return Query6(() => txn.createEntity(ref, {
@@ -282,11 +246,17 @@ var createDraft = writeOperation6(CreateDraftMutationSchema, DraftSchema, (txn)
       post: postRef
     }
   }));
-});
+}, { outputSchema: DraftSchema });
 
 // src/operations/createPost.ts
 import { Query as Query7, writeOperation as writeOperation7 } from "roc-db";
-var createPost = writeOperation7(CreatePostMutationSchema, PostSchema, (txn) => {
+import { z as z18 } from "zod";
+var PayloadSchema2 = z18.object({
+  title: z18.string(),
+  slug: z18.string().optional(),
+  tags: z18.array(z18.string()).default([])
+}).strict();
+var createPost = writeOperation7("createPost", PayloadSchema2, (txn) => {
   const ref = txn.createRef("Post");
   const { title, slug, tags } = txn.payload;
   return Query7(() => txn.createEntity(ref, {
@@ -297,17 +267,7 @@ var createPost = writeOperation7(CreatePostMutationSchema, PostSchema, (txn) =>
 
 // src/operations/deleteBlocks.ts
 import { Query as Query8, QueryChain as QueryChain4, writeOperation as writeOperation8 } from "roc-db";
-
-// src/schemas/DeleteBlocksMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator11 } from "roc-db";
 import { z as z19 } from "zod";
-var DeleteBlocksMutationSchema = mutationSchemaGenerator11("deleteBlocks", z19.array(z19.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);
@@ -319,50 +279,37 @@ var DeleteBlockQuery = (txn, blockRef) => {
     });
   }), Query8(() => txn.deleteEntity(blockRef)));
 };
-var deleteBlocks = writeOperation8(DeleteBlocksMutationSchema, PostSchema, (txn) => {
+var deleteBlocks = writeOperation8("deleteBlocks", z19.array(z19.union([
+  BlockParagraphRefSchema,
+  BlockImageRefSchema,
+  BlockRowRefSchema
+])), (txn) => {
   const refs = txn.payload;
   return QueryChain4(...refs.map((ref) => DeleteBlockQuery(txn, ref)));
-}, { changeSetOnly: true });
+}, { changeSetOnly: true, outputSchema: PostSchema });
 
 // 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) => {
+var deleteDraft = writeOperation9("deleteDraft", DraftRefSchema, (txn) => {
   const ref = txn.payload;
   return QueryChain5(Query9(() => txn.deleteEntity(ref, true)), Query9(() => txn.deleteChangeSet(ref)));
 });
 
 // src/operations/deletePost.ts
 import { Query as Query10, writeOperation as writeOperation10 } from "roc-db";
-
-// src/schemas/DeletePostMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator13 } from "roc-db";
-var DeletePostMutationSchema = mutationSchemaGenerator13("deletePost", PostRefSchema);
-
-// src/operations/deletePost.ts
-var deletePost = writeOperation10(DeletePostMutationSchema, undefined, (txn) => {
+var deletePost = writeOperation10("deletePost", PostRefSchema, (txn) => {
   const ref = txn.payload;
   return Query10(() => txn.deleteEntity(ref, true));
 });
 
 // src/operations/moveBlocks.ts
 import { Query as Query11, QueryChain as QueryChain6, writeOperation as writeOperation11 } from "roc-db";
-
-// src/schemas/MoveBlocksMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator14 } from "roc-db";
 import { z as z20 } from "zod";
-var MoveBlocksMutationSchema = mutationSchemaGenerator14("moveBlocks", z20.object({
+var PayloadSchema3 = z20.object({
   refs: z20.array(z20.union([BlockParagraphRefSchema, BlockRowRefSchema])),
   targetPosition: z20.number().min(0)
-}).strict(), undefined, true);
-
-// src/operations/moveBlocks.ts
-var moveBlocks = writeOperation11(MoveBlocksMutationSchema, undefined, (txn) => {
+}).strict();
+var moveBlocks = writeOperation11("moveBlocks", PayloadSchema3, (txn) => {
   const { refs } = txn.payload;
   return QueryChain6(Query11(() => txn.batchReadEntities(refs)), Query11((items) => {
     return "todo";
@@ -372,7 +319,7 @@ var moveBlocks = writeOperation11(MoveBlocksMutationSchema, undefined, (txn) =>
 // src/operations/readEntity.ts
 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) => {
+var readEntity = readOperation("readEntity", z21.string(), (txn) => {
   const ref = txn.payload;
   return QueryChain7(Query12(() => txn.readEntity(ref)), Query12((entity) => {
     if (!entity) {
@@ -380,12 +327,18 @@ var readEntity = readOperation("readEntity", z21.string(), z21.union([PostSchema
     }
     return entity;
   }));
+}, {
+  outputSchema: z21.union([
+    PostSchema,
+    BlockImageSchema,
+    BlockParagraphSchema
+  ])
 });
 
 // src/operations/readMutation.ts
 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) => {
+var readMutation = readOperation2("readMutation", z22.string(), (txn) => {
   const ref = txn.payload;
   return QueryChain8(Query13(() => txn.readMutation(ref)), Query13((entity) => {
     if (!entity) {
@@ -397,25 +350,15 @@ var readMutation = readOperation2("readMutation", z22.string(), z22.any(), (txn)
 
 // src/operations/readPost.ts
 import { Query as Query14, readOperation as readOperation3 } from "roc-db";
-var readPost = readOperation3("readPost", PostRefSchema, PostSchema, (txn) => {
+var readPost = readOperation3("readPost", PostRefSchema, (txn) => {
   const ref = txn.payload;
   return Query14(() => txn.readEntity(ref, true));
-});
+}, { outputSchema: PostSchema });
 
 // src/operations/testTransactionalEdits.ts
+import { expect } from "bun:test";
 import { Query as Query15, QueryChain as QueryChain9, writeOperation as writeOperation12 } from "roc-db";
-
-// src/schemas/TestTransactionalEditsMutationSchema.ts
-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());
-
-// src/operations/testTransactionalEdits.ts
-import { expect } from "bun:test";
 var TestCreatePatchDeleteInSameTransaction = (txn, name) => {
   const postRef = txn.createRef("Post");
   QueryChain9(Query15(() => txn.createEntity(postRef, { data: { name } })), Query15(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query15((post) => {
@@ -450,7 +393,12 @@ var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
   return QueryChain9(Query15(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query15(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var testTransactionalEdits = writeOperation12(TestTransactionalEditsMutationSchema, PostSchema, (txn) => {
+var PayloadSchema4 = z23.object({
+  name: z23.string().optional(),
+  post1ref: PostRefSchema.optional(),
+  post2ref: PostRefSchema.optional()
+}).strict();
+var testTransactionalEdits = writeOperation12("testTransactionalEdits", PayloadSchema4, (txn) => {
   const { name, post1ref, post2ref } = txn.payload;
   if (name)
     return TestCreatePatchDeleteInSameTransaction(txn, name);
@@ -462,54 +410,50 @@ var testTransactionalEdits = writeOperation12(TestTransactionalEditsMutationSche
 
 // src/operations/updateBlockParagraph.ts
 import { Query as Query16, writeOperation as writeOperation13 } from "roc-db";
-
-// src/schemas/UpdateBlockParagraphMutationSchema.ts
-import { mutationSchemaGenerator as mutationSchemaGenerator16 } from "roc-db";
 import { z as z24 } from "zod";
-var UpdateBlockParagraphMutationSchema = mutationSchemaGenerator16("updateBlockParagraph", z24.object({
+var updateBlockParagraph = writeOperation13("updateBlockParagraph", z24.object({
   ref: BlockParagraphRefSchema,
   content: z24.string()
-}));
-
-// src/operations/updateBlockParagraph.ts
-var updateBlockParagraph = writeOperation13(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
+}), (txn) => {
   const { ref, content } = txn.payload;
   return Query16(() => txn.patchEntity(ref, {
     data: { content }
   }));
-});
+}, { outputSchema: BlockParagraphSchema });
 
 // src/operations/updatePost.ts
 import { Query as Query17, writeOperation as writeOperation14 } from "roc-db";
-var updatePost = writeOperation14(UpdatePostMutationSchema, PostSchema, (txn) => {
+import { z as z25 } from "zod";
+var PayloadSchema5 = z25.object({
+  ref: PostRefSchema,
+  title: z25.string().optional(),
+  tags: z25.array(z25.string()).optional().default([]),
+  authorRef: UserRefSchema.optional()
+});
+var updatePost = writeOperation14("updatePost", PayloadSchema5, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
   return Query17(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
   }));
-});
+}, { outputSchema: PostSchema });
 
 // src/operations/updatePostDescription.ts
 import { Query as Query18, writeOperation as writeOperation15 } from "roc-db";
-
-// src/schemas/UpdatePostDescriptionMutationSchema.ts
-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 = writeOperation15(UpdatePostDescriptionMutationSchema, PostSchema, (txn) => {
+import { z as z26 } from "zod";
+var updatePostDescription = writeOperation15("updatePostDescription", z26.object({ ref: PostRefSchema, description: z26.string() }), (txn) => {
   const { ref, description } = txn.payload;
   return Query18(() => txn.patchEntity(ref, { data: { description } }));
-}, { debounce: 10, changeSetOnly: true });
+}, { debounce: 10, changeSetOnly: true, outputSchema: PostSchema });
 
 // src/operations/updatePostTitle.ts
 import { Query as Query19, writeOperation as writeOperation16 } from "roc-db";
-var updatePostTitle = writeOperation16(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
+import { z as z27 } from "zod";
+var updatePostTitle = writeOperation16("updatePostTitle", z27.object({ ref: PostRefSchema, title: z27.string() }), (txn) => {
   const { ref, title } = txn.payload;
   return Query19(() => txn.patchEntity(ref, { data: { title } }));
-}, { debounce: 10 });
+}, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/index.ts
 var operations = [
@@ -796,9 +740,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
     });
     test("applyDraft", async () => {
       const { draftRef: draftRef2 } = await prepareChangeSetTest(adapter1);
-      const [version, mutation] = await adapter1.applyDraft({
-        ref: draftRef2
-      });
+      const [version, mutation] = await adapter1.applyDraft(draftRef2);
     });
     test("deleteDraft", async () => {
       const { draftRef: draftRef2 } = await prepareChangeSetTest(adapter1);

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

@@ -1,5 +1 @@
-export declare const applyDraft: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, any>;
+export declare const applyDraft: import("roc-db").WriteOperation<"applyDraft", import("zod").ZodType<`Draft/${string}`, import("zod").ZodTypeDef, `Draft/${string}`>>;

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

@@ -1,24 +1,8 @@
-export declare const createBlockImage: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, {
-    ref: `BlockImage/${string}`;
-    data: {
-        url: string;
-    };
-    parents: {
-        post: `Post/${string}`;
-    };
-    entity: "BlockImage";
-    created: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    updated: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    children: {};
-    ancestors: {};
-}>;
+import { z } from "zod";
+export declare const createBlockImage: import("roc-db").WriteOperation<"createBlockImage", z.ZodObject<{
+    postRef: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+}, "strict", z.ZodTypeAny, {
+    postRef: `Post/${string}`;
+}, {
+    postRef: `Post/${string}`;
+}>>;

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

@@ -1,24 +1,8 @@
-export declare const createBlockParagrah: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, {
-    ref: `BlockParagraph/${string}`;
-    data: {
-        content?: string | undefined;
-    };
-    parents: {
-        parent: `Post/${string}`;
-    };
-    entity: "BlockParagraph";
-    created: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    updated: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    children: {};
-    ancestors: {};
-}>;
+import { z } from "zod";
+export declare const createBlockParagrah: import("roc-db").WriteOperation<"createBlockParagraph", z.ZodObject<{
+    parentRef: z.ZodUnion<[z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;
+}, "strict", z.ZodTypeAny, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}>>;

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

@@ -1,24 +1,8 @@
-export declare const createBlockRow: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, {
-    ref: `BlockParagraph/${string}`;
-    data: {
-        content?: string | undefined;
-    };
-    parents: {
-        parent: `Post/${string}`;
-    };
-    entity: "BlockParagraph";
-    created: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    updated: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    children: {};
-    ancestors: {};
-}>;
+import { z } from "zod";
+export declare const createBlockRow: import("roc-db").WriteOperation<"createBlockRow", z.ZodObject<{
+    parentRef: z.ZodUnion<[z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;
+}, "strict", z.ZodTypeAny, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}>>;

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

@@ -1,24 +1,8 @@
-export declare const createBlockTitle: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, {
-    ref: `BlockTitle/${string}`;
-    data: {
-        content: string;
-    };
-    parents: {
-        post: `Post/${string}`;
-    };
-    entity: "BlockTitle";
-    created: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    updated: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    children: {};
-    ancestors: {};
-}>;
+import { z } from "zod";
+export declare const createBlockTitle: import("roc-db").WriteOperation<"createBlockTitle", z.ZodObject<{
+    parentRef: z.ZodUnion<[z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;
+}, "strict", z.ZodTypeAny, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}>>;

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

@@ -1,22 +1,8 @@
-export declare const createDraft: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, {
-    ref: `Draft/${string}`;
-    data: {
-        postRef: `Post/${string}`;
-    };
-    parents: {};
-    entity: "Draft";
-    created: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    updated: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    children: {};
-    ancestors: {};
-}>;
+import { z } from "zod";
+export declare const createDraft: import("roc-db").WriteOperation<"createDraft", z.ZodObject<{
+    postRef: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+}, "strict", z.ZodTypeAny, {
+    postRef: `Post/${string}`;
+}, {
+    postRef: `Post/${string}`;
+}>>;

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

@@ -1,29 +1,14 @@
-export declare const createPost: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, {
-    ref: `Post/${string}`;
-    data: {
-        title: string;
-        tags: string[];
-        text?: string | undefined;
-        slug?: string | undefined;
-    };
-    parents: {
-        author?: `User/${string}` | undefined;
-    };
-    entity: "Post";
-    created: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    updated: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    children: {
-        blocks: string[];
-    };
-    ancestors: {};
-}>;
+import { z } from "zod";
+export declare const createPost: import("roc-db").WriteOperation<"createPost", z.ZodObject<{
+    title: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    tags: string[];
+    slug?: string | undefined;
+}, {
+    title: string;
+    tags?: string[] | undefined;
+    slug?: string | undefined;
+}>>;

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

@@ -1,29 +1,2 @@
-export declare const deleteBlocks: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, {
-    ref: `Post/${string}`;
-    data: {
-        title: string;
-        tags: string[];
-        text?: string | undefined;
-        slug?: string | undefined;
-    };
-    parents: {
-        author?: `User/${string}` | undefined;
-    };
-    entity: "Post";
-    created: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    updated: {
-        mutationRef: `Mutation/${string}`;
-        timestamp: string;
-    };
-    children: {
-        blocks: string[];
-    };
-    ancestors: {};
-}>;
+import { z } from "zod";
+export declare const deleteBlocks: import("roc-db").WriteOperation<"deleteBlocks", z.ZodArray<z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockImage/${string}`, z.ZodTypeDef, `BlockImage/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>, "many">>;

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

@@ -1,5 +1 @@
-export declare const deleteDraft: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, any>;
+export declare const deleteDraft: import("roc-db").WriteOperation<"deleteDraft", import("zod").ZodType<`Draft/${string}`, import("zod").ZodTypeDef, `Draft/${string}`>>;

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

@@ -1,5 +1 @@
-export declare const deletePost: import("roc-db").WriteOperation<string, {
-    debounceCount: number;
-    name: string;
-    payload?: any;
-}, any, any>;
+export declare const deletePost: import("roc-db").WriteOperation<"deletePost", import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>>;