@roc-db/test-utils 0.1.0-pre.2

package/dist/index.js

@@ -0,0 +1,456 @@
+// src/schemas/BlockImageSchema.ts
+import { entitySchemaGenerator } from "roc-db";
+import { z } from "zod";
+
+// src/schemas/BlockImageRefSchema.ts
+import { refSchemaGenerator } from "roc-db";
+var BlockImageRefSchema = refSchemaGenerator("BlockImage");
+
+// src/schemas/PostRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator2 } from "roc-db";
+var PostRefSchema = refSchemaGenerator2("Post");
+
+// src/schemas/BlockImageSchema.ts
+var BlockImageSchema = entitySchemaGenerator("BlockImage", {
+  ref: BlockImageRefSchema,
+  data: z.object({
+    url: z.string().url()
+  }),
+  parents: z.object({
+    post: PostRefSchema
+  })
+});
+
+// src/schemas/BlockParagraphSchema.ts
+import { entitySchemaGenerator as entitySchemaGenerator2 } from "roc-db";
+import { z as z2 } from "zod";
+
+// src/schemas/BlockParagraphRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator3 } from "roc-db";
+var BlockParagraphRefSchema = refSchemaGenerator3("BlockParagraph");
+
+// src/schemas/BlockParagraphSchema.ts
+var BlockParagraphSchema = entitySchemaGenerator2("BlockParagraph", {
+  ref: BlockParagraphRefSchema,
+  data: z2.object({
+    content: z2.string().optional()
+  }),
+  parents: z2.object({
+    parent: PostRefSchema
+  })
+});
+
+// src/schemas/BlockTitleSchema.ts
+import { entitySchemaGenerator as entitySchemaGenerator3 } from "roc-db";
+import { z as z3 } from "zod";
+
+// src/schemas/BlockTitleRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator4 } from "roc-db";
+var BlockTitleRefSchema = refSchemaGenerator4("BlockTitle");
+
+// src/schemas/BlockTitleSchema.ts
+var BlockTitleSchema = entitySchemaGenerator3("BlockTitle", {
+  ref: BlockTitleRefSchema,
+  data: z3.object({
+    content: z3.string()
+  }),
+  parents: z3.object({
+    post: PostRefSchema
+  })
+});
+
+// src/schemas/DraftSchema.ts
+import { entitySchemaGenerator as entitySchemaGenerator4 } from "roc-db";
+import { z as z4 } from "zod";
+
+// src/schemas/DraftRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
+var DraftRefSchema = refSchemaGenerator5("Draft");
+
+// src/schemas/DraftSchema.ts
+var DraftSchema = entitySchemaGenerator4("Draft", {
+  ref: DraftRefSchema,
+  data: z4.object({
+    postRef: PostRefSchema
+  })
+});
+
+// src/schemas/PostSchema.ts
+import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
+import { z as z5 } from "zod";
+
+// src/schemas/UserRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
+var UserRefSchema = refSchemaGenerator6("User");
+
+// src/schemas/PostSchema.ts
+var PostSchema = entitySchemaGenerator5("Post", {
+  ref: PostRefSchema,
+  data: z5.object({
+    title: z5.string(),
+    text: z5.string().optional(),
+    tags: z5.array(z5.string()),
+    slug: z5.string().optional()
+  }),
+  parents: z5.object({ author: UserRefSchema.optional() }),
+  children: z5.object({ blocks: z5.array(z5.string()) })
+});
+// 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([])
+}).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() }));
+// src/schemas/UpdatePostMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator3 } from "roc-db";
+import { z as z8 } from "zod";
+var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z8.object({
+  ref: PostRefSchema,
+  title: z8.string().optional(),
+  tags: z8.array(z8.string()).optional().default([]),
+  authorRef: UserRefSchema.optional().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() }));
+// src/schemas/index.ts
+var entities = [
+  BlockImageSchema,
+  BlockParagraphSchema,
+  BlockTitleSchema,
+  DraftSchema,
+  PostSchema
+];
+// src/operations/createBlockImage.ts
+import { Query, writeOperation } from "roc-db";
+
+// src/schemas/CreateBlockImageMutationSchema.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);
+
+// src/operations/createBlockImage.ts
+var createBlockImage = writeOperation(CreateBlockImageMutationSchema, BlockImageSchema, (txn) => {
+  const ref = txn.createRef("BlockImage");
+  const { postRef } = txn.payload;
+  return Query(() => txn.createEntity(ref, { parents: { post: postRef } }));
+}, { changeSetOnly: true });
+
+// src/operations/createBlockParagraph.ts
+import { Query as Query2, QueryChain, writeOperation as writeOperation2 } from "roc-db";
+
+// src/schemas/CreateBlockParagraphMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator6 } from "roc-db";
+import { z as z11 } 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);
+
+// src/operations/createBlockParagraph.ts
+var createBlockParagrah = writeOperation2(CreateBlockParagraphMutationSchema, BlockParagraphSchema, (txn) => {
+  const ref = txn.createRef("BlockParagraph");
+  const { parentRef } = txn.payload;
+  return QueryChain(Query2(() => txn.readEntity(parentRef, true)), Query2((parent) => txn.patchEntity(parentRef, {
+    children: { blocks: [...parent.children.blocks, ref] }
+  })), Query2(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query2((block, updatedParent) => ({ block, updatedParent })));
+}, { changeSetOnly: true });
+
+// src/operations/createBlockRow.ts
+import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } 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);
+
+// src/operations/createBlockRow.ts
+var createBlockRow = writeOperation3(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 txn.patchEntity(parentRef, {
+      children: { blocks: [...parent.children.blocks, ref] }
+    });
+  }), Query3(() => txn.createEntity(ref, {
+    children: { blocks: [] },
+    parents: { parent: parentRef }
+  })), Query3((block, updatedParent) => ({ block, updatedParent })));
+}, { changeSetOnly: true });
+
+// src/operations/createBlockTitle.ts
+import { Query as Query4, writeOperation as writeOperation4 } 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);
+
+// src/operations/createBlockTitle.ts
+var createBlockTitle = writeOperation4(CreateBlockTitleMutationSchema, BlockTitleSchema, (txn) => {
+  const ref = txn.createRef("BlockTitle");
+  const { postRef } = txn.payload;
+  return Query4(() => txn.createEntity(ref, { parents: { post: postRef } }));
+}, { changeSetOnly: true });
+
+// src/operations/createDraft.ts
+import { Query as Query5, writeOperation as writeOperation5 } 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());
+
+// src/operations/createDraft.ts
+var createDraft = writeOperation5(CreateDraftMutationSchema, DraftSchema, (txn) => {
+  const ref = txn.createRef("Draft");
+  const { postRef } = txn.payload;
+  return Query5(() => txn.createEntity(ref, {
+    parents: {
+      post: postRef
+    }
+  }));
+});
+
+// src/operations/createPost.ts
+import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
+var createPost = writeOperation6(CreatePostMutationSchema, PostSchema, (txn) => {
+  const ref = txn.createRef("Post");
+  const { title, slug, tags } = txn.payload;
+  return Query6(() => txn.createEntity(ref, {
+    data: { title, tags, slug },
+    children: { blocks: [] }
+  }));
+});
+
+// src/operations/deleteBlock.ts
+import { Query as Query7, QueryChain as QueryChain3, writeOperation as writeOperation7 } from "roc-db";
+
+// src/schemas/DeleteBlockMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator10 } from "roc-db";
+import { z as z15 } from "zod";
+var DeleteBlockMutationSchema = mutationSchemaGenerator10("deleteBlock", z15.union([BlockParagraphRefSchema, BlockImageRefSchema]));
+
+// src/operations/deleteBlock.ts
+var deleteBlock = writeOperation7(DeleteBlockMutationSchema, PostSchema, (txn) => {
+  const blockRef = txn.payload;
+  return QueryChain3(Query7(() => txn.readEntity(blockRef, true)), Query7((block) => txn.readEntity(block.parents.post, true)), Query7((post) => {
+    return txn.patchEntity(post.ref, {
+      data: {
+        blockRefs: post.data.blockRefs.filter((ref) => ref !== blockRef)
+      }
+    });
+  }), Query7(() => txn.deleteEntity(blockRef)), Query7((_, updatedPost) => {
+    return updatedPost;
+  }));
+}, { changeSetOnly: true });
+
+// src/operations/deletePost.ts
+import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
+
+// src/schemas/DeletePostMutationSchema.ts
+import { mutationSchemaGenerator as mutationSchemaGenerator11 } from "roc-db";
+var DeletePostMutationSchema = mutationSchemaGenerator11("deletePost", PostRefSchema);
+
+// src/operations/deletePost.ts
+var deletePost = writeOperation8(DeletePostMutationSchema, undefined, (txn) => {
+  const ref = txn.payload;
+  return Query8(() => 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) => {
+  const ref = txn.payload;
+  return QueryChain4(Query9(() => txn.readEntity(ref)), Query9((entity) => {
+    if (!entity) {
+      throw new NotFoundError(ref);
+    }
+    return entity;
+  }));
+});
+
+// src/operations/readPost.ts
+import { Query as Query10, readOperation as readOperation2 } from "roc-db";
+var readPost = readOperation2("readPost", PostRefSchema, PostSchema, (txn) => {
+  const ref = txn.payload;
+  return Query10(() => txn.readEntity(ref));
+});
+
+// src/operations/updateBlockParagraph.ts
+import { Query as Query11, writeOperation as writeOperation9 } 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({
+  ref: BlockParagraphRefSchema,
+  content: z17.string()
+}));
+
+// src/operations/updateBlockParagraph.ts
+var updateBlockParagraph = writeOperation9(UpdateBlockParagraphMutationSchema, BlockParagraphRefSchema, (txn) => {
+  const { ref, content } = txn.payload;
+  return Query11(() => 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) => {
+  const { ref, authorRef, ...data } = txn.payload;
+  return Query12(() => txn.updateEntity(ref, {
+    data,
+    parents: { author: authorRef },
+    children: { blocks: [] }
+  }));
+});
+
+// src/operations/updatePostTitle.ts
+import { Query as Query13, writeOperation as writeOperation11 } from "roc-db";
+var updatePostTitle = writeOperation11(UpdatePostTitleMutationSchema, PostSchema, (txn) => {
+  const { ref, title } = txn.payload;
+  return Query13(() => txn.patchEntity(ref, { data: { title } }));
+}, { debounce: 10 });
+
+// src/operations/index.ts
+var operations = [
+  createBlockImage,
+  createBlockTitle,
+  createBlockParagrah,
+  createBlockRow,
+  createDraft,
+  createPost,
+  deleteBlock,
+  deletePost,
+  readEntity,
+  readPost,
+  updateBlockParagraph,
+  updatePost,
+  updatePostTitle
+];
+// src/testAdapterImplementation.ts
+import { beforeAll, describe, expect, test } from "bun:test";
+import { NotFoundError as NotFoundError2 } from "roc-db";
+var prepareChangeSetTest = async (adapter) => {
+  const [post] = await adapter.createPost({
+    title: "Title 1",
+    slug: "title-1",
+    tags: ["Foo", "Bar"]
+  });
+  const [draft] = await adapter.createDraft({
+    postRef: post.ref
+  });
+  const changeSetAdapter = adapter.changeSet(draft.ref);
+  const [{ block: blockParagraph1 }] = await changeSetAdapter.createBlockParagraph({
+    parentRef: post.ref
+  });
+  const [{ block: blockRow, updatedParent }] = await changeSetAdapter.createBlockRow({
+    parentRef: post.ref
+  });
+  const [{ block: blockParagraph2 }] = await changeSetAdapter.createBlockParagraph({
+    parentRef: blockRow.ref
+  });
+  return {
+    postRef: post.ref,
+    draftRef: draft.ref,
+    changeSetAdapter,
+    blockParagraph1,
+    blockParagraph2,
+    blockRow,
+    post: updatedParent
+  };
+};
+var testAdapterImplementation = (adapterConstructor, engineArgsAdapter1 = {}, engineArgsAdapter2 = {}) => {
+  return async () => {
+    const adapter1 = adapterConstructor({ operations, entities, ...engineArgsAdapter1 });
+    const adapter2 = adapterConstructor({ operations, entities, ...engineArgsAdapter2 });
+    describe("changeSet", async () => {
+      let postRef, draftRef, changeSetAdapter, block, post, blockRow, blockParagraph2;
+      beforeAll(async () => {
+        const res = await prepareChangeSetTest(adapter1);
+        postRef = res.postRef;
+        draftRef = res.draftRef;
+        changeSetAdapter = res.changeSetAdapter;
+        block = res.blockParagraph1;
+        blockRow = res.blockRow;
+        blockParagraph2 = res.blockParagraph2;
+        post = res.post;
+      });
+      test("create (createEntity function w/changeSetRef)", async () => {
+        expect(block).toMatchZodSchema(BlockParagraphSchema);
+        expect(post).toMatchZodSchema(PostSchema);
+      });
+      test("read (readEntity function w/changeSetRef)", async () => {
+        const read = await changeSetAdapter.readEntity(block.ref);
+        expect(read).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],
+          [blockParagraph2.ref, "delete", draftRef],
+          [postRef, "delete", draftRef]
+        ]);
+      });
+      test("update (patchEntity function w/changeSetRef)", async () => {
+        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
+          ref: block.ref,
+          content: "Hello, world!"
+        });
+        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+      });
+      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);
+      });
+    });
+  };
+};
+// src/inMemoryAdapter.ts
+import { createInMemoryAdapter } from "@roc-db/in-memory";
+var inMemoryAdapter = createInMemoryAdapter({
+  operations,
+  entities
+});
+export {
+  testAdapterImplementation,
+  operations,
+  inMemoryAdapter,
+  entities,
+  UserRefSchema,
+  UpdatePostTitleMutationSchema,
+  UpdatePostMutationSchema,
+  PostSchema,
+  PostRefSchema,
+  DraftSchema,
+  DraftRefSchema,
+  CreateUserMutationSchema,
+  CreatePostMutationSchema,
+  BlockTitleSchema,
+  BlockParagraphSchema,
+  BlockImageSchema
+};

package/dist/setup/index.js

@@ -0,0 +1,7 @@
+// src/setup/index.ts
+import { expect } from "bun:test";
+var toMatchZodSchema = (received, schema) => {
+  const res = schema.safeParse(received);
+  return { pass: res.success, message: () => res.error?.message };
+};
+expect.extend({ toMatchZodSchema });

package/dist/types/inMemoryAdapter.d.ts

@@ -0,0 +1 @@
+export declare const inMemoryAdapter: any;

package/dist/types/index.d.ts

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

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

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

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

@@ -0,0 +1,15 @@
+export declare const createBlockParagrah: import("roc-db").WriteOperation<"createBlockParagraph", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        parentRef: `Post/${string}` | `BlockRow/${string}`;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createBlockParagraph";
+}, {
+    parentRef: `Post/${string}` | `BlockRow/${string}`;
+}, {
+    [x: string]: any;
+}>;

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+export declare const createPost: import("roc-db").WriteOperation<"createPost", {
+    ref: `Mutation/${string}`;
+    timestamp: string;
+    changeSetRef: null;
+    payload: {
+        title: string;
+        tags: string[];
+        slug?: string | undefined;
+    };
+    log: [never, string, null][];
+    debounceCount: number;
+    name: "createPost";
+}, {
+    title: string;
+    tags: string[];
+    slug?: string | undefined;
+}, {
+    [x: string]: any;
+}>;

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

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

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

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