@roc-db/test-utils 0.2.0-pre.71 → 0.2.0-pre.72

package/dist/index.js

@@ -86,137 +86,149 @@ var DraftSchema = entitySchemaGenerator4("Draft", {
   })
 });
 
-// src/schemas/PostSchema.ts
+// src/schemas/ImageSchema.ts
 import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
 import { z as z6 } from "zod";
+var ImageSchema = entitySchemaGenerator5("Image", {
+  data: z6.object({
+    title: z6.string(),
+    text: z6.string().optional(),
+    tags: z6.array(z6.string()),
+    slug: z6.string().optional()
+  })
+});
+
+// src/schemas/PostSchema.ts
+import { entitySchemaGenerator as entitySchemaGenerator6 } from "roc-db";
+import { z as z7 } from "zod";
 
 // src/schemas/UserRefSchema.ts
 import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
 var UserRefSchema = refSchemaGenerator5("User");
 
 // src/schemas/PostSchema.ts
-var PostSchema = entitySchemaGenerator5("Post", {
+var PostSchema = entitySchemaGenerator6("Post", {
   ref: PostRefSchema,
-  data: z6.object({
-    title: z6.string(),
-    text: z6.string().optional(),
-    tags: z6.array(z6.string()),
-    slug: z6.string().optional()
+  data: z7.object({
+    title: z7.string(),
+    text: z7.string().optional(),
+    tags: z7.array(z7.string()),
+    slug: z7.string().optional()
   }),
-  parents: z6.object({ author: UserRefSchema.optional() }),
-  children: z6.object({ blocks: z6.array(z6.string()) })
+  parents: z7.object({ author: UserRefSchema.optional() }),
+  children: z7.object({ blocks: z7.array(z7.string()) })
 });
 // src/schemas/CreatePostMutationSchema.ts
 import { mutationSchemaGenerator } from "roc-db";
-import { z as z7 } from "zod";
-var CreatePostMutationSchema = mutationSchemaGenerator("createPost", z7.object({
-  title: z7.string(),
-  slug: z7.string().optional(),
-  tags: z7.array(z7.string()).default([])
+import { z as z8 } from "zod";
+var CreatePostMutationSchema = mutationSchemaGenerator("createPost", z8.object({
+  title: z8.string(),
+  slug: z8.string().optional(),
+  tags: z8.array(z8.string()).default([])
 }).strict());
 // src/schemas/CreateUserMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator2 } from "roc-db";
-import { z as z8 } from "zod";
-var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z8.object({ email: z8.string() }));
+import { z as z9 } from "zod";
+var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z9.object({ email: z9.string() }));
 // src/schemas/UpdatePostMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator3 } from "roc-db";
-import { z as z9 } from "zod";
-var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z9.object({
+import { z as z10 } from "zod";
+var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z10.object({
   ref: PostRefSchema,
-  title: z9.string().optional(),
-  tags: z9.array(z9.string()).optional().default([]),
+  title: z10.string().optional(),
+  tags: z10.array(z10.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 }));
 // src/schemas/UpdatePostTitleMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator4 } from "roc-db";
-import { z as z10 } from "zod";
-var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z10.object({ ref: PostRefSchema, title: z10.string() }));
+import { z as z11 } from "zod";
+var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z11.object({ ref: PostRefSchema, title: z11.string() }));
 // src/entities/BlockImageEntity.ts
 import { Entity as Entity2 } from "roc-db";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var BlockImageEntity = new Entity2("BlockImage", {
-  data: z11.object({
-    url: z11.string().url()
+  data: z12.object({
+    url: z12.string().url()
   }),
-  parents: z11.object({
+  parents: z12.object({
     parent: PostRefSchema
   })
 });
 
 // src/entities/BlockParagraph.ts
 import { Entity as Entity4 } from "roc-db";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/entities/PostEntity.ts
 import { Entity as Entity3 } from "roc-db";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var PostEntity = new Entity3("Post", {
-  data: z12.object({
-    title: z12.string(),
-    text: z12.string().optional(),
-    tags: z12.array(z12.string()),
-    slug: z12.string().optional()
+  data: z13.object({
+    title: z13.string(),
+    text: z13.string().optional(),
+    tags: z13.array(z13.string()),
+    slug: z13.string().optional()
   }),
-  parents: z12.object({ author: UserRefSchema.optional() }),
-  children: z12.object({ blocks: z12.array(z12.string()) }),
+  parents: z13.object({ author: UserRefSchema.optional() }),
+  children: z13.object({ blocks: z13.array(z13.string()) }),
   indexedDataKeys: ["tags", "slug"],
   uniqueDataKeys: ["slug"]
 });
 
 // src/schemas/BlockRefSchema.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/schemas/BlockRowRefSchema.ts
 import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
 var BlockRowRefSchema = refSchemaGenerator6("BlockRow");
 
 // src/schemas/BlockRefSchema.ts
-var BlockRefSchema = z13.union([
+var BlockRefSchema = z14.union([
   BlockParagraphRefSchema,
   BlockRowRefSchema
 ]);
 
 // src/entities/BlockParagraph.ts
 var BlockParagraph = new Entity4("BlockParagraph", {
-  data: z14.object({
-    content: z14.string().optional()
+  data: z15.object({
+    content: z15.string().optional()
   }),
-  parents: z14.object({
-    parent: z14.union([PostEntity.refSchema, BlockRefSchema])
+  parents: z15.object({
+    parent: z15.union([PostEntity.refSchema, BlockRefSchema])
   })
 });
 
 // src/entities/BlockRow.ts
 import { Entity as Entity5 } from "roc-db";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var BlockRow = new Entity5("BlockRow", {
-  children: z15.object({
-    blocks: z15.array(BlockRefSchema)
+  children: z16.object({
+    blocks: z16.array(BlockRefSchema)
   }),
-  parents: z15.object({
-    parent: z15.union([PostEntity.refSchema, BlockRefSchema])
+  parents: z16.object({
+    parent: z16.union([PostEntity.refSchema, BlockRefSchema])
   })
 });
 
 // src/entities/PostVersion.ts
 import { Entity as Entity6 } from "roc-db";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var PostVersion = new Entity6("PostVersion", {
-  data: z16.object({
-    version: z16.number(),
-    snapshot: z16.array(z16.any())
+  data: z17.object({
+    version: z17.number(),
+    snapshot: z17.array(z17.any())
   }),
-  parents: z16.object({ post: PostRefSchema }),
+  parents: z17.object({ post: PostRefSchema }),
   indexedDataKeys: ["version"],
   uniqueDataKeys: ["slug"]
 });
 
 // src/entities/UserEntity.ts
 import { Entity as Entity7 } from "roc-db";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var UserEntity = new Entity7("User", {
-  data: z17.object({
-    email: z17.string().email()
+  data: z18.object({
+    email: z18.string().email()
   }),
   uniqueDataKeys: ["email"]
 });
@@ -251,8 +263,8 @@ var applyDraft = writeOperation("applyDraft", DraftRefSchema, (txn) => {
 
 // src/operations/createBlockImage.ts
 import { Query as Query2, writeOperation as writeOperation2 } from "roc-db";
-import { z as z18 } from "zod";
-var createBlockImage = writeOperation2("createBlockImage", z18.object({ parentRef: PostRefSchema, url: z18.string().url() }).strict(), (txn) => {
+import { z as z19 } from "zod";
+var createBlockImage = writeOperation2("createBlockImage", z19.object({ parentRef: PostRefSchema, url: z19.string().url() }).strict(), (txn) => {
   const ref = txn.createRef("BlockImage");
   const { parentRef, url } = txn.payload;
   return Query2(() => txn.createEntity(ref, {
@@ -263,8 +275,8 @@ var createBlockImage = writeOperation2("createBlockImage", z18.object({ parentRe
 
 // src/operations/createBlockParagraph.ts
 import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
-import { z as z19 } from "zod";
-var createBlockParagrah = writeOperation3("createBlockParagraph", z19.object({ parentRef: z19.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+import { z as z20 } from "zod";
+var createBlockParagrah = writeOperation3("createBlockParagraph", z20.object({ parentRef: z20.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, {
@@ -272,16 +284,16 @@ var createBlockParagrah = writeOperation3("createBlockParagraph", z19.object({ p
   })), Query3(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query3((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z19.object({
-    block: z19.any(),
-    updatedParent: z19.any()
+  outputSchema: z20.object({
+    block: z20.any(),
+    updatedParent: z20.any()
   })
 });
 
 // src/operations/createBlockRow.ts
 import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOperation4 } from "roc-db";
-import { z as z20 } from "zod";
-var createBlockRow = writeOperation4("createBlockRow", z20.object({ parentRef: z20.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+import { z as z21 } from "zod";
+var createBlockRow = writeOperation4("createBlockRow", z21.object({ parentRef: z21.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
   return QueryChain3(Query4(() => txn.readEntity(parentRef)), Query4((parent) => {
@@ -294,16 +306,16 @@ var createBlockRow = writeOperation4("createBlockRow", z20.object({ parentRef: z
   })), Query4((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z20.object({
-    block: z20.any(),
-    updatedParent: z20.any()
+  outputSchema: z21.object({
+    block: z21.any(),
+    updatedParent: z21.any()
   })
 });
 
 // src/operations/createBlockTitle.ts
 import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
-import { z as z21 } from "zod";
-var PayloadSchema = z21.object({ parentRef: z21.union([PostRefSchema, BlockRowRefSchema]) }).strict();
+import { z as z22 } from "zod";
+var PayloadSchema = z22.object({ parentRef: z22.union([PostRefSchema, BlockRowRefSchema]) }).strict();
 var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn) => {
   const ref = txn.createRef("BlockTitle");
   const { postRef } = txn.payload;
@@ -312,8 +324,8 @@ var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn)
 
 // src/operations/createDraft.ts
 import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
-import { z as z22 } from "zod";
-var createDraft = writeOperation6("createDraft", z22.object({ postRef: PostRefSchema }).strict(), (txn) => {
+import { z as z23 } from "zod";
+var createDraft = writeOperation6("createDraft", z23.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("Draft");
   const { postRef } = txn.payload;
   return Query6(() => txn.createEntity(ref, {
@@ -323,47 +335,63 @@ var createDraft = writeOperation6("createDraft", z22.object({ postRef: PostRefSc
   }));
 }, { outputSchema: DraftSchema });
 
-// src/operations/createPost.ts
+// src/operations/createImage.ts
 import { Query as Query7, writeOperation as writeOperation7 } from "roc-db";
-import { z as z23 } from "zod";
-var PayloadSchema2 = z23.object({
-  title: z23.string(),
-  slug: z23.string().optional(),
-  tags: z23.array(z23.string()).default([])
+import { z as z24 } from "zod";
+var PayloadSchema2 = z24.object({
+  title: z24.string(),
+  file: z24.string().optional()
+}).strict();
+var createImage = writeOperation7("createImage", PayloadSchema2, (txn) => {
+  const ref = txn.createRef("Image");
+  const { title, file } = txn.payload;
+  return Query7(() => txn.createEntity(ref, {
+    data: { title, file },
+    children: { blocks: [] }
+  }));
+});
+
+// src/operations/createPost.ts
+import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
+import { z as z25 } from "zod";
+var PayloadSchema3 = z25.object({
+  title: z25.string(),
+  slug: z25.string().optional(),
+  tags: z25.array(z25.string()).default([])
 }).strict();
-var createPost = writeOperation7("createPost", PayloadSchema2, (txn) => {
+var createPost = writeOperation8("createPost", PayloadSchema3, (txn) => {
   const ref = txn.createRef("Post");
   const { title, slug, tags } = txn.payload;
-  return Query7(() => txn.createEntity(ref, {
+  return Query8(() => txn.createEntity(ref, {
     data: { title, tags, slug },
     children: { blocks: [] }
   }));
 });
 
 // src/operations/createUser.ts
-import { Query as Query8, writeOperation as writeOperation8 } from "roc-db";
-import { z as z24 } from "zod";
-var createUser = writeOperation8("createUser", z24.object({ email: z24.string() }), (txn) => {
+import { Query as Query9, writeOperation as writeOperation9 } from "roc-db";
+import { z as z26 } from "zod";
+var createUser = writeOperation9("createUser", z26.object({ email: z26.string() }), (txn) => {
   const ref = txn.createRef("User");
   const { email } = txn.payload;
-  return Query8(() => txn.createEntity(ref, { data: { email } }));
+  return Query9(() => txn.createEntity(ref, { data: { email } }));
 });
 
 // src/operations/deleteBlocks.ts
-import { Query as Query9, QueryChain as QueryChain4, writeOperation as writeOperation9 } from "roc-db";
-import { z as z25 } from "zod";
+import { Query as Query10, QueryChain as QueryChain4, writeOperation as writeOperation10 } from "roc-db";
+import { z as z27 } from "zod";
 var DeleteBlockQuery = (txn, blockRef) => {
-  return QueryChain4(Query9(() => txn.readEntity(blockRef)), Query9((block) => {
+  return QueryChain4(Query10(() => txn.readEntity(blockRef)), Query10((block) => {
     return txn.readEntity(block.parents.parent, true);
-  }), Query9((post) => {
+  }), Query10((post) => {
     return txn.patchEntity(post.ref, {
       children: {
         blocks: post.children.blocks.filter((ref) => ref !== blockRef)
       }
     });
-  }), Query9(() => txn.deleteEntity(blockRef)));
+  }), Query10(() => txn.deleteEntity(blockRef)));
 };
-var deleteBlocks = writeOperation9("deleteBlocks", z25.array(z25.union([
+var deleteBlocks = writeOperation10("deleteBlocks", z27.array(z27.union([
   BlockParagraphRefSchema,
   BlockImageRefSchema,
   BlockRowRefSchema
@@ -373,42 +401,42 @@ var deleteBlocks = writeOperation9("deleteBlocks", z25.array(z25.union([
 }, { changeSetOnly: true });
 
 // src/operations/deleteDraft.ts
-import { Query as Query10, QueryChain as QueryChain5, writeOperation as writeOperation10 } from "roc-db";
-var deleteDraft = writeOperation10("deleteDraft", DraftRefSchema, (txn) => {
+import { Query as Query11, QueryChain as QueryChain5, writeOperation as writeOperation11 } from "roc-db";
+var deleteDraft = writeOperation11("deleteDraft", DraftRefSchema, (txn) => {
   const ref = txn.payload;
-  return QueryChain5(Query10(() => txn.deleteEntity(ref, true)), Query10(() => txn.deleteChangeSet(ref)));
+  return QueryChain5(Query11(() => txn.deleteEntity(ref, true)), Query11(() => txn.deleteChangeSet(ref)));
 });
 
 // src/operations/deletePost.ts
-import { Query as Query11, writeOperation as writeOperation11 } from "roc-db";
-var deletePost = writeOperation11("deletePost", PostRefSchema, (txn) => {
+import { Query as Query12, writeOperation as writeOperation12 } from "roc-db";
+var deletePost = writeOperation12("deletePost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query11(() => txn.deleteEntity(ref, true));
+  return Query12(() => txn.deleteEntity(ref, true));
 });
 
 // src/operations/moveBlocks.ts
-import { Query as Query12, QueryChain as QueryChain6, writeOperation as writeOperation12 } from "roc-db";
-import { z as z26 } from "zod";
-var PayloadSchema3 = z26.object({
-  refs: z26.array(z26.union([BlockParagraphRefSchema, BlockRowRefSchema])),
-  targetPosition: z26.number().min(0)
+import { Query as Query13, QueryChain as QueryChain6, writeOperation as writeOperation13 } from "roc-db";
+import { z as z28 } from "zod";
+var PayloadSchema4 = z28.object({
+  refs: z28.array(z28.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z28.number().min(0)
 }).strict();
-var moveBlocks = writeOperation12("moveBlocks", PayloadSchema3, (txn) => {
+var moveBlocks = writeOperation13("moveBlocks", PayloadSchema4, (txn) => {
   const { refs } = txn.payload;
-  return QueryChain6(Query12(() => txn.batchReadEntities(refs)), Query12((items) => {
+  return QueryChain6(Query13(() => txn.batchReadEntities(refs)), Query13((items) => {
     return "todo";
   }));
 });
 
 // src/operations/pageBlocks.ts
-import { Query as Query13, readOperation } from "roc-db";
-import { z as z27 } from "zod";
-var pageBlocks = readOperation("pageBlocks", z27.object({
-  size: z27.number().default(100),
-  parentRef: z27.string().optional()
+import { Query as Query14, readOperation } from "roc-db";
+import { z as z29 } from "zod";
+var pageBlocks = readOperation("pageBlocks", z29.object({
+  size: z29.number().default(100),
+  parentRef: z29.string().optional()
 }), (txn) => {
   const { size, parentRef } = txn.payload;
-  return Query13(() => txn.pageEntities({
+  return Query14(() => txn.pageEntities({
     entities: ["BlockImage", "BlockParagraph"],
     size,
     childrenOf: parentRef ? [parentRef] : []
@@ -416,50 +444,50 @@ var pageBlocks = readOperation("pageBlocks", z27.object({
 });
 
 // src/operations/pageEmptyEntitiesArray.ts
-import { Query as Query14, readOperation as readOperation2 } from "roc-db";
-import { z as z28 } from "zod";
-var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z28.object({ size: z28.number().default(100) }), (txn) => {
+import { Query as Query15, readOperation as readOperation2 } from "roc-db";
+import { z as z30 } from "zod";
+var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z30.object({ size: z30.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query14(() => txn.pageEntities({ entities: [], size }));
+  return Query15(() => txn.pageEntities({ entities: [], size }));
 });
 
 // src/operations/pagePosts.ts
-import { Query as Query15, readOperation as readOperation3 } from "roc-db";
-import { z as z29 } from "zod";
-var pagePosts = readOperation3("pagePosts", z29.object({ size: z29.number().default(100) }).default({}), (txn) => {
+import { Query as Query16, readOperation as readOperation3 } from "roc-db";
+import { z as z31 } from "zod";
+var pagePosts = readOperation3("pagePosts", z31.object({ size: z31.number().default(100) }).default({}), (txn) => {
   const { size } = txn.payload;
-  return Query15(() => txn.pageEntities({ entities: ["Post"], size }));
+  return Query16(() => txn.pageEntities({ entities: ["Post"], size }));
 });
 
 // src/operations/pageSplat.ts
-import { Query as Query16, readOperation as readOperation4 } from "roc-db";
-import { z as z30 } from "zod";
-var pageSplat = readOperation4("pageSplat", z30.object({ size: z30.number().default(100) }), (txn) => {
+import { Query as Query17, readOperation as readOperation4 } from "roc-db";
+import { z as z32 } from "zod";
+var pageSplat = readOperation4("pageSplat", z32.object({ size: z32.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query16(() => txn.pageEntities({ entities: "*", size }));
+  return Query17(() => txn.pageEntities({ entities: "*", size }));
 });
 
 // src/operations/pagePostsByTag.ts
-import { Query as Query17, readOperation as readOperation5 } from "roc-db";
-import { z as z31 } from "zod";
-var pagePostsByTag = readOperation5("pagePostsByTag", z31.string(), (txn) => {
+import { Query as Query18, readOperation as readOperation5 } from "roc-db";
+import { z as z33 } from "zod";
+var pagePostsByTag = readOperation5("pagePostsByTag", z33.string(), (txn) => {
   const tag = txn.payload;
-  return Query17(() => txn.pageEntitiesByIndex("Post", "tags", tag));
+  return Query18(() => txn.pageEntitiesByIndex("Post", "tags", tag));
 });
 
 // src/operations/readEntity.ts
-import { NotFoundError, Query as Query18, QueryChain as QueryChain7, readOperation as readOperation6 } from "roc-db";
-import { z as z32 } from "zod";
-var readEntity = readOperation6("readEntity", z32.string(), (txn) => {
+import { NotFoundError, Query as Query19, QueryChain as QueryChain7, readOperation as readOperation6 } from "roc-db";
+import { z as z34 } from "zod";
+var readEntity = readOperation6("readEntity", z34.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain7(Query18(() => txn.readEntity(ref)), Query18((entity) => {
+  return QueryChain7(Query19(() => txn.readEntity(ref)), Query19((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
     return entity;
   }));
 }, {
-  outputSchema: z32.union([
+  outputSchema: z34.union([
     PostSchema,
     BlockImageSchema,
     BlockParagraphSchema
@@ -467,11 +495,11 @@ var readEntity = readOperation6("readEntity", z32.string(), (txn) => {
 });
 
 // src/operations/readMutation.ts
-import { NotFoundError as NotFoundError2, Query as Query19, QueryChain as QueryChain8, readOperation as readOperation7 } from "roc-db";
-import { z as z33 } from "zod";
-var readMutation = readOperation7("readMutation", z33.string(), (txn) => {
+import { NotFoundError as NotFoundError2, Query as Query20, QueryChain as QueryChain8, readOperation as readOperation7 } from "roc-db";
+import { z as z35 } from "zod";
+var readMutation = readOperation7("readMutation", z35.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain8(Query19(() => txn.readMutation(ref)), Query19((entity) => {
+  return QueryChain8(Query20(() => txn.readMutation(ref)), Query20((entity) => {
     if (!entity) {
       throw new NotFoundError2(ref);
     }
@@ -480,52 +508,52 @@ var readMutation = readOperation7("readMutation", z33.string(), (txn) => {
 });
 
 // src/operations/readPost.ts
-import { Query as Query20, readOperation as readOperation8 } from "roc-db";
+import { Query as Query21, readOperation as readOperation8 } from "roc-db";
 var readPost = readOperation8("readPost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query20(() => txn.readEntity(ref, true));
+  return Query21(() => txn.readEntity(ref, true));
 }, { outputSchema: PostSchema });
 
 // src/operations/readPostBySlug.ts
-import { Query as Query21, readOperation as readOperation9 } from "roc-db";
-import { z as z34 } from "zod";
-var readPostBySlug = readOperation9("readPostBySlug", z34.string(), (txn) => {
+import { Query as Query22, readOperation as readOperation9 } from "roc-db";
+import { z as z36 } from "zod";
+var readPostBySlug = readOperation9("readPostBySlug", z36.string(), (txn) => {
   const slug = txn.payload;
-  return Query21(() => txn.readEntityByUniqueField("Post", "slug", slug));
+  return Query22(() => txn.readEntityByUniqueField("Post", "slug", slug));
 }, { outputSchema: PostSchema });
 
 // src/operations/testTransactionalEdits.ts
 import { expect } from "bun:test";
-import { Query as Query22, QueryChain as QueryChain9, writeOperation as writeOperation13 } from "roc-db";
-import { z as z35 } from "zod";
+import { Query as Query23, QueryChain as QueryChain9, writeOperation as writeOperation14 } from "roc-db";
+import { z as z37 } from "zod";
 var TestCreatePatchDeleteInSameTransaction = (txn, title) => {
   const postRef = txn.createRef("Post");
-  return QueryChain9(Query22(() => txn.createEntity(postRef, {
+  return QueryChain9(Query23(() => txn.createEntity(postRef, {
     data: { title, tags: [] },
     children: { blocks: [] }
-  })), Query22(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query22((post) => {
+  })), Query23(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query23((post) => {
     expect(post.data.title).toBe(title);
     expect(post.data.foo).toBe("bar");
-  }), Query22(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query22((post) => {
+  }), Query23(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query23((post) => {
     expect(post.data.title).toBe(title);
     expect(post.data.foo).toBeUndefined();
     expect(post.data.bar).toBe("foo");
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(postRef)[0]).toBe("create");
-  }), Query22((post) => txn.deleteEntity(postRef)), Query22((res) => {
+  }), Query23((post) => txn.deleteEntity(postRef)), Query23((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(0);
   }));
 };
 var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
-  return QueryChain9(Query22(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query22((post) => {
+  return QueryChain9(Query23(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query23((post) => {
     expect(post.data.foo).toBe("bar");
-  }), Query22(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query22((post) => {
+  }), Query23(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query23((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");
-  }), Query22((post) => txn.deleteEntity(ref)), Query22((res) => {
+  }), Query23((post) => txn.deleteEntity(ref)), Query23((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(ref)[0]).toBe("delete");
@@ -533,14 +561,14 @@ var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
 };
 var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
-  return QueryChain9(Query22(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query22(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+  return QueryChain9(Query23(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query23(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var PayloadSchema4 = z35.object({
-  name: z35.string().optional(),
+var PayloadSchema5 = z37.object({
+  name: z37.string().optional(),
   post1ref: PostRefSchema.optional(),
   post2ref: PostRefSchema.optional()
 }).strict();
-var testTransactionalEdits = writeOperation13("testTransactionalEdits", PayloadSchema4, (txn) => {
+var testTransactionalEdits = writeOperation14("testTransactionalEdits", PayloadSchema5, (txn) => {
   const { name, post1ref, post2ref } = txn.payload;
   if (name)
     return TestCreatePatchDeleteInSameTransaction(txn, name);
@@ -551,30 +579,30 @@ var testTransactionalEdits = writeOperation13("testTransactionalEdits", PayloadS
 }, {});
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query23, writeOperation as writeOperation14 } from "roc-db";
-import { z as z36 } from "zod";
-var updateBlockParagraph = writeOperation14("updateBlockParagraph", z36.object({
+import { Query as Query24, writeOperation as writeOperation15 } from "roc-db";
+import { z as z38 } from "zod";
+var updateBlockParagraph = writeOperation15("updateBlockParagraph", z38.object({
   ref: BlockParagraphRefSchema,
-  content: z36.string()
+  content: z38.string()
 }), (txn) => {
   const { ref, content } = txn.payload;
-  return Query23(() => txn.patchEntity(ref, {
+  return Query24(() => txn.patchEntity(ref, {
     data: { content }
   }));
 }, { outputSchema: BlockParagraphSchema });
 
 // src/operations/updatePost.ts
-import { Query as Query24, writeOperation as writeOperation15 } from "roc-db";
-import { z as z37 } from "zod";
-var PayloadSchema5 = z37.object({
+import { Query as Query25, writeOperation as writeOperation16 } from "roc-db";
+import { z as z39 } from "zod";
+var PayloadSchema6 = z39.object({
   ref: PostRefSchema,
-  title: z37.string().optional(),
-  tags: z37.array(z37.string()).optional().default([]),
+  title: z39.string().optional(),
+  tags: z39.array(z39.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 });
-var updatePost = writeOperation15("updatePost", PayloadSchema5, (txn) => {
+var updatePost = writeOperation16("updatePost", PayloadSchema6, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query24(() => txn.updateEntity(ref, {
+  return Query25(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -582,43 +610,43 @@ var updatePost = writeOperation15("updatePost", PayloadSchema5, (txn) => {
 }, { outputSchema: PostSchema });
 
 // src/operations/updatePostDescription.ts
-import { Query as Query25, writeOperation as writeOperation16 } from "roc-db";
-import { z as z38 } from "zod";
-var updatePostDescription = writeOperation16("updatePostDescription", z38.object({ ref: PostRefSchema, description: z38.string() }), (txn) => {
+import { Query as Query26, writeOperation as writeOperation17 } from "roc-db";
+import { z as z40 } from "zod";
+var updatePostDescription = writeOperation17("updatePostDescription", z40.object({ ref: PostRefSchema, description: z40.string() }), (txn) => {
   const { ref, description } = txn.payload;
-  return Query25(() => txn.patchEntity(ref, { data: { description } }));
+  return Query26(() => txn.patchEntity(ref, { data: { description } }));
 }, { debounce: 10, changeSetOnly: true, outputSchema: PostSchema });
 
 // src/operations/updatePostSlug.ts
-import { Query as Query26, writeOperation as writeOperation17 } from "roc-db";
-import { z as z39 } from "zod";
-var updatePostSlug = writeOperation17("updatePostSlug", z39.object({ ref: PostRefSchema, slug: z39.string() }), (txn) => {
+import { Query as Query27, writeOperation as writeOperation18 } from "roc-db";
+import { z as z41 } from "zod";
+var updatePostSlug = writeOperation18("updatePostSlug", z41.object({ ref: PostRefSchema, slug: z41.string() }), (txn) => {
   const { ref, slug } = txn.payload;
-  return Query26(() => txn.patchEntity(ref, { data: { slug } }));
+  return Query27(() => txn.patchEntity(ref, { data: { slug } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTags.ts
-import { Query as Query27, writeOperation as writeOperation18 } from "roc-db";
-import { z as z40 } from "zod";
-var updatePostTags = writeOperation18("updatePostTags", z40.object({ ref: PostRefSchema, tags: z40.array(z40.string()) }), (txn) => {
+import { Query as Query28, writeOperation as writeOperation19 } from "roc-db";
+import { z as z42 } from "zod";
+var updatePostTags = writeOperation19("updatePostTags", z42.object({ ref: PostRefSchema, tags: z42.array(z42.string()) }), (txn) => {
   const { ref, tags } = txn.payload;
-  return Query27(() => txn.patchEntity(ref, { data: { tags } }));
+  return Query28(() => txn.patchEntity(ref, { data: { tags } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query28, writeOperation as writeOperation19 } from "roc-db";
-import { z as z41 } from "zod";
-var updatePostTitle = writeOperation19("updatePostTitle", z41.object({ ref: PostRefSchema, title: z41.string() }), (txn) => {
+import { Query as Query29, writeOperation as writeOperation20 } from "roc-db";
+import { z as z43 } from "zod";
+var updatePostTitle = writeOperation20("updatePostTitle", z43.object({ ref: PostRefSchema, title: z43.string() }), (txn) => {
   const { ref, title } = txn.payload;
-  return Query28(() => txn.patchEntity(ref, { data: { title } }));
+  return Query29(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/crudBySlug.ts
-import { Query as Query29, QueryChain as QueryChain10, writeOperation as writeOperation20 } from "roc-db";
-import { z as z42 } from "zod";
-var crudBySlug = writeOperation20("crudBySlug", z42.object({ slug: z42.string(), newSlug: z42.string() }), (txn) => {
+import { Query as Query30, QueryChain as QueryChain10, writeOperation as writeOperation21 } from "roc-db";
+import { z as z44 } from "zod";
+var crudBySlug = writeOperation21("crudBySlug", z44.object({ slug: z44.string(), newSlug: z44.string() }), (txn) => {
   const { slug, newSlug } = txn.payload;
-  return QueryChain10(Query29(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query29((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query29(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query29((post) => txn.deleteEntity(post.ref)), Query29(() => {
+  return QueryChain10(Query30(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query30((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query30(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query30((post) => txn.deleteEntity(post.ref)), Query30(() => {
     return [
       txn.readEntityByUniqueField("Post", "slug", slug, false),
       txn.readEntityByUniqueField("Post", "slug", newSlug, false)
@@ -634,6 +662,7 @@ var operations = [
   createBlockParagrah,
   createBlockRow,
   createDraft,
+  createImage,
   createPost,
   createUser,
   crudBySlug,
@@ -1154,6 +1183,7 @@ export {
   UpdatePostMutationSchema,
   PostSchema,
   PostRefSchema,
+  ImageSchema,
   DraftSchema,
   DraftRefSchema,
   CreateUserMutationSchema,