@roc-db/test-utils 0.2.0-pre.53 → 0.2.0-pre.54

package/dist/index.js

@@ -131,81 +131,105 @@ var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z9.object(
 import { mutationSchemaGenerator as mutationSchemaGenerator4 } from "roc-db";
 import { z as z10 } from "zod";
 var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z10.object({ ref: PostRefSchema, title: z10.string() }));
-// src/entities/BlockParagraph.ts
-import { Entity as Entity3 } from "roc-db";
-import { z as z13 } from "zod";
-
-// src/entities/PostEntity.ts
+// src/entities/BlockImageEntity.ts
 import { Entity as Entity2 } from "roc-db";
 import { z as z11 } from "zod";
-var PostEntity = new Entity2("Post", {
+var BlockImageEntity = new Entity2("BlockImage", {
   data: z11.object({
-    title: z11.string(),
-    text: z11.string().optional(),
-    tags: z11.array(z11.string()),
-    slug: z11.string().optional()
+    url: z11.string().url()
+  }),
+  parents: z11.object({
+    parent: PostRefSchema
+  })
+});
+
+// src/entities/BlockParagraph.ts
+import { Entity as Entity4 } from "roc-db";
+import { z as z14 } from "zod";
+
+// src/entities/PostEntity.ts
+import { Entity as Entity3 } from "roc-db";
+import { z as z12 } 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()
   }),
-  parents: z11.object({ author: UserRefSchema.optional() }),
-  children: z11.object({ blocks: z11.array(z11.string()) }),
+  parents: z12.object({ author: UserRefSchema.optional() }),
+  children: z12.object({ blocks: z12.array(z12.string()) }),
   indexedDataKeys: ["tags", "slug"],
   uniqueDataKeys: ["slug"]
 });
 
 // src/schemas/BlockRefSchema.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/schemas/BlockRowRefSchema.ts
 import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
 var BlockRowRefSchema = refSchemaGenerator6("BlockRow");
 
 // src/schemas/BlockRefSchema.ts
-var BlockRefSchema = z12.union([
+var BlockRefSchema = z13.union([
   BlockParagraphRefSchema,
   BlockRowRefSchema
 ]);
 
 // src/entities/BlockParagraph.ts
-var BlockParagraph = new Entity3("BlockParagraph", {
-  data: z13.object({
-    content: z13.string().optional()
+var BlockParagraph = new Entity4("BlockParagraph", {
+  data: z14.object({
+    content: z14.string().optional()
   }),
-  parents: z13.object({
-    parent: z13.union([PostEntity.refSchema, BlockRefSchema])
+  parents: z14.object({
+    parent: z14.union([PostEntity.refSchema, BlockRefSchema])
   })
 });
 
 // src/entities/BlockRow.ts
-import { Entity as Entity4 } from "roc-db";
-import { z as z14 } from "zod";
-var BlockRow = new Entity4("BlockRow", {
-  children: z14.object({
-    blocks: z14.array(BlockRefSchema)
+import { Entity as Entity5 } from "roc-db";
+import { z as z15 } from "zod";
+var BlockRow = new Entity5("BlockRow", {
+  children: z15.object({
+    blocks: z15.array(BlockRefSchema)
   }),
-  parents: z14.object({
-    parent: z14.union([PostEntity.refSchema, BlockRefSchema])
+  parents: z15.object({
+    parent: z15.union([PostEntity.refSchema, BlockRefSchema])
   })
 });
 
 // src/entities/PostVersion.ts
-import { Entity as Entity5 } from "roc-db";
-import { z as z15 } from "zod";
-var PostVersion = new Entity5("PostVersion", {
-  data: z15.object({
-    version: z15.number(),
-    snapshot: z15.array(z15.any())
+import { Entity as Entity6 } from "roc-db";
+import { z as z16 } from "zod";
+var PostVersion = new Entity6("PostVersion", {
+  data: z16.object({
+    version: z16.number(),
+    snapshot: z16.array(z16.any())
   }),
-  parents: z15.object({ post: PostRefSchema }),
+  parents: z16.object({ post: PostRefSchema }),
   indexedDataKeys: ["version"],
   uniqueDataKeys: ["slug"]
 });
 
+// src/entities/UserEntity.ts
+import { Entity as Entity7 } from "roc-db";
+import { z as z17 } from "zod";
+var UserEntity = new Entity7("User", {
+  data: z17.object({
+    email: z17.string().email()
+  }),
+  uniqueDataKeys: ["email"]
+});
+
 // src/entities/index.ts
 var entities = [
+  BlockImageEntity,
   BlockParagraph,
   BlockRow,
   Draft,
   PostEntity,
-  PostVersion
+  PostVersion,
+  UserEntity
 ];
 // src/operations/applyDraft.ts
 import { Query, QueryChain, writeOperation } from "roc-db";
@@ -227,17 +251,20 @@ var applyDraft = writeOperation("applyDraft", DraftRefSchema, (txn) => {
 
 // src/operations/createBlockImage.ts
 import { Query as Query2, writeOperation as writeOperation2 } from "roc-db";
-import { z as z16 } from "zod";
-var createBlockImage = writeOperation2("createBlockImage", z16.object({ postRef: PostRefSchema }).strict(), (txn) => {
+import { z as z18 } from "zod";
+var createBlockImage = writeOperation2("createBlockImage", z18.object({ parentRef: PostRefSchema, url: z18.string().url() }).strict(), (txn) => {
   const ref = txn.createRef("BlockImage");
-  const { postRef } = txn.payload;
-  return Query2(() => txn.createEntity(ref, { parents: { post: postRef } }));
-}, { changeSetOnly: true, outputSchema: BlockImageSchema });
+  const { parentRef, url } = txn.payload;
+  return Query2(() => txn.createEntity(ref, {
+    data: { url },
+    parents: { parent: parentRef }
+  }));
+}, { changeSetOnly: true });
 
 // src/operations/createBlockParagraph.ts
 import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
-import { z as z17 } from "zod";
-var createBlockParagrah = writeOperation3("createBlockParagraph", z17.object({ parentRef: z17.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+import { z as z19 } from "zod";
+var createBlockParagrah = writeOperation3("createBlockParagraph", z19.object({ parentRef: z19.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, {
@@ -245,16 +272,16 @@ var createBlockParagrah = writeOperation3("createBlockParagraph", z17.object({ p
   })), Query3(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query3((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z17.object({
-    block: z17.any(),
-    updatedParent: z17.any()
+  outputSchema: z19.object({
+    block: z19.any(),
+    updatedParent: z19.any()
   })
 });
 
 // src/operations/createBlockRow.ts
 import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOperation4 } from "roc-db";
-import { z as z18 } from "zod";
-var createBlockRow = writeOperation4("createBlockRow", z18.object({ parentRef: z18.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+import { z as z20 } from "zod";
+var createBlockRow = writeOperation4("createBlockRow", z20.object({ parentRef: z20.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
   return QueryChain3(Query4(() => txn.readEntity(parentRef)), Query4((parent) => {
@@ -267,16 +294,16 @@ var createBlockRow = writeOperation4("createBlockRow", z18.object({ parentRef: z
   })), Query4((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z18.object({
-    block: z18.any(),
-    updatedParent: z18.any()
+  outputSchema: z20.object({
+    block: z20.any(),
+    updatedParent: z20.any()
   })
 });
 
 // src/operations/createBlockTitle.ts
 import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
-import { z as z19 } from "zod";
-var PayloadSchema = z19.object({ parentRef: z19.union([PostRefSchema, BlockRowRefSchema]) }).strict();
+import { z as z21 } from "zod";
+var PayloadSchema = z21.object({ parentRef: z21.union([PostRefSchema, BlockRowRefSchema]) }).strict();
 var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn) => {
   const ref = txn.createRef("BlockTitle");
   const { postRef } = txn.payload;
@@ -285,8 +312,8 @@ var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn)
 
 // src/operations/createDraft.ts
 import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
-import { z as z20 } from "zod";
-var createDraft = writeOperation6("createDraft", z20.object({ postRef: PostRefSchema }).strict(), (txn) => {
+import { z as z22 } from "zod";
+var createDraft = writeOperation6("createDraft", z22.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("Draft");
   const { postRef } = txn.payload;
   return Query6(() => txn.createEntity(ref, {
@@ -298,11 +325,11 @@ var createDraft = writeOperation6("createDraft", z20.object({ postRef: PostRefSc
 
 // src/operations/createPost.ts
 import { Query as Query7, writeOperation as writeOperation7 } from "roc-db";
-import { z as z21 } from "zod";
-var PayloadSchema2 = z21.object({
-  title: z21.string(),
-  slug: z21.string().optional(),
-  tags: z21.array(z21.string()).default([])
+import { z as z23 } from "zod";
+var PayloadSchema2 = z23.object({
+  title: z23.string(),
+  slug: z23.string().optional(),
+  tags: z23.array(z23.string()).default([])
 }).strict();
 var createPost = writeOperation7("createPost", PayloadSchema2, (txn) => {
   const ref = txn.createRef("Post");
@@ -313,21 +340,30 @@ var createPost = writeOperation7("createPost", PayloadSchema2, (txn) => {
   }));
 });
 
+// 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) => {
+  const ref = txn.createRef("User");
+  const { email } = txn.payload;
+  return Query8(() => txn.createEntity(ref, { data: { email } }));
+});
+
 // src/operations/deleteBlocks.ts
-import { Query as Query8, QueryChain as QueryChain4, writeOperation as writeOperation8 } from "roc-db";
-import { z as z22 } from "zod";
+import { Query as Query9, QueryChain as QueryChain4, writeOperation as writeOperation9 } from "roc-db";
+import { z as z25 } from "zod";
 var DeleteBlockQuery = (txn, blockRef) => {
-  return QueryChain4(Query8(() => txn.readEntity(blockRef)), Query8((block) => {
+  return QueryChain4(Query9(() => txn.readEntity(blockRef)), Query9((block) => {
     return txn.readEntity(block.parents.parent, true);
-  }), Query8((post) => {
+  }), Query9((post) => {
     return txn.patchEntity(post.ref, {
       children: {
         blocks: post.children.blocks.filter((ref) => ref !== blockRef)
       }
     });
-  }), Query8(() => txn.deleteEntity(blockRef)));
+  }), Query9(() => txn.deleteEntity(blockRef)));
 };
-var deleteBlocks = writeOperation8("deleteBlocks", z22.array(z22.union([
+var deleteBlocks = writeOperation9("deleteBlocks", z25.array(z25.union([
   BlockParagraphRefSchema,
   BlockImageRefSchema,
   BlockRowRefSchema
@@ -337,54 +373,93 @@ var deleteBlocks = writeOperation8("deleteBlocks", z22.array(z22.union([
 }, { changeSetOnly: true });
 
 // src/operations/deleteDraft.ts
-import { Query as Query9, QueryChain as QueryChain5, writeOperation as writeOperation9 } from "roc-db";
-var deleteDraft = writeOperation9("deleteDraft", DraftRefSchema, (txn) => {
+import { Query as Query10, QueryChain as QueryChain5, writeOperation as writeOperation10 } from "roc-db";
+var deleteDraft = writeOperation10("deleteDraft", DraftRefSchema, (txn) => {
   const ref = txn.payload;
-  return QueryChain5(Query9(() => txn.deleteEntity(ref, true)), Query9(() => txn.deleteChangeSet(ref)));
+  return QueryChain5(Query10(() => txn.deleteEntity(ref, true)), Query10(() => txn.deleteChangeSet(ref)));
 });
 
 // src/operations/deletePost.ts
-import { Query as Query10, writeOperation as writeOperation10 } from "roc-db";
-var deletePost = writeOperation10("deletePost", PostRefSchema, (txn) => {
+import { Query as Query11, writeOperation as writeOperation11 } from "roc-db";
+var deletePost = writeOperation11("deletePost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query10(() => txn.deleteEntity(ref, true));
+  return Query11(() => txn.deleteEntity(ref, true));
 });
 
 // src/operations/moveBlocks.ts
-import { Query as Query11, QueryChain as QueryChain6, writeOperation as writeOperation11 } from "roc-db";
-import { z as z23 } from "zod";
-var PayloadSchema3 = z23.object({
-  refs: z23.array(z23.union([BlockParagraphRefSchema, BlockRowRefSchema])),
-  targetPosition: z23.number().min(0)
+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)
 }).strict();
-var moveBlocks = writeOperation11("moveBlocks", PayloadSchema3, (txn) => {
+var moveBlocks = writeOperation12("moveBlocks", PayloadSchema3, (txn) => {
   const { refs } = txn.payload;
-  return QueryChain6(Query11(() => txn.batchReadEntities(refs)), Query11((items) => {
+  return QueryChain6(Query12(() => txn.batchReadEntities(refs)), Query12((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()
+}), (txn) => {
+  const { size, parentRef } = txn.payload;
+  return Query13(() => txn.pageEntities({
+    entities: ["BlockImage", "BlockParagraph"],
+    size,
+    childrenOf: parentRef ? [parentRef] : []
+  }));
+});
+
+// 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) => {
+  const { size } = txn.payload;
+  return Query14(() => 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) => {
+  const { size } = txn.payload;
+  return Query15(() => 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) => {
+  const { size } = txn.payload;
+  return Query16(() => txn.pageEntities({ entities: "*", size }));
+});
+
 // src/operations/pagePostsByTag.ts
-import { Query as Query12, readOperation } from "roc-db";
-import { z as z24 } from "zod";
-var pagePostsByTag = readOperation("pagePostsByTag", z24.string(), (txn) => {
+import { Query as Query17, readOperation as readOperation5 } from "roc-db";
+import { z as z31 } from "zod";
+var pagePostsByTag = readOperation5("pagePostsByTag", z31.string(), (txn) => {
   const tag = txn.payload;
-  return Query12(() => txn.pageEntitiesByIndex("Post", "tags", tag));
+  return Query17(() => txn.pageEntitiesByIndex("Post", "tags", tag));
 });
 
 // src/operations/readEntity.ts
-import { NotFoundError, Query as Query13, QueryChain as QueryChain7, readOperation as readOperation2 } from "roc-db";
-import { z as z25 } from "zod";
-var readEntity = readOperation2("readEntity", z25.string(), (txn) => {
+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) => {
   const ref = txn.payload;
-  return QueryChain7(Query13(() => txn.readEntity(ref)), Query13((entity) => {
+  return QueryChain7(Query18(() => txn.readEntity(ref)), Query18((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
     return entity;
   }));
 }, {
-  outputSchema: z25.union([
+  outputSchema: z32.union([
     PostSchema,
     BlockImageSchema,
     BlockParagraphSchema
@@ -392,11 +467,11 @@ var readEntity = readOperation2("readEntity", z25.string(), (txn) => {
 });
 
 // src/operations/readMutation.ts
-import { NotFoundError as NotFoundError2, Query as Query14, QueryChain as QueryChain8, readOperation as readOperation3 } from "roc-db";
-import { z as z26 } from "zod";
-var readMutation = readOperation3("readMutation", z26.string(), (txn) => {
+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) => {
   const ref = txn.payload;
-  return QueryChain8(Query14(() => txn.readMutation(ref)), Query14((entity) => {
+  return QueryChain8(Query19(() => txn.readMutation(ref)), Query19((entity) => {
     if (!entity) {
       throw new NotFoundError2(ref);
     }
@@ -405,49 +480,49 @@ var readMutation = readOperation3("readMutation", z26.string(), (txn) => {
 });
 
 // src/operations/readPost.ts
-import { Query as Query15, readOperation as readOperation4 } from "roc-db";
-var readPost = readOperation4("readPost", PostRefSchema, (txn) => {
+import { Query as Query20, readOperation as readOperation8 } from "roc-db";
+var readPost = readOperation8("readPost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query15(() => txn.readEntity(ref, true));
+  return Query20(() => txn.readEntity(ref, true));
 }, { outputSchema: PostSchema });
 
 // src/operations/readPostBySlug.ts
-import { Query as Query16, readOperation as readOperation5 } from "roc-db";
-import { z as z27 } from "zod";
-var readPostBySlug = readOperation5("readPostBySlug", z27.string(), (txn) => {
+import { Query as Query21, readOperation as readOperation9 } from "roc-db";
+import { z as z34 } from "zod";
+var readPostBySlug = readOperation9("readPostBySlug", z34.string(), (txn) => {
   const slug = txn.payload;
-  return Query16(() => txn.readEntityByUniqueField("Post", "slug", slug));
+  return Query21(() => txn.readEntityByUniqueField("Post", "slug", slug));
 }, { outputSchema: PostSchema });
 
 // src/operations/testTransactionalEdits.ts
 import { expect } from "bun:test";
-import { Query as Query17, QueryChain as QueryChain9, writeOperation as writeOperation12 } from "roc-db";
-import { z as z28 } from "zod";
+import { Query as Query22, QueryChain as QueryChain9, writeOperation as writeOperation13 } from "roc-db";
+import { z as z35 } from "zod";
 var TestCreatePatchDeleteInSameTransaction = (txn, name) => {
   const postRef = txn.createRef("Post");
-  QueryChain9(Query17(() => txn.createEntity(postRef, { data: { name } })), Query17(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query17((post) => {
+  QueryChain9(Query22(() => txn.createEntity(postRef, { data: { name } })), Query22(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query22((post) => {
     expect(post.data.name).toBe(name);
     expect(post.data.foo).toBe("bar");
-  }), Query17(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query17((post) => {
+  }), Query22(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query22((post) => {
     expect(post.data.name).toBe(name);
     expect(post.data.foo).toBeUndefined();
     expect(post.data.bar).toBe("foo");
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(postRef)[0]).toBe("create");
-  }), Query17((post) => txn.deleteEntity(postRef)), Query17((res) => {
+  }), Query22((post) => txn.deleteEntity(postRef)), Query22((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(0);
   }));
 };
 var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
-  return QueryChain9(Query17(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query17((post) => {
+  return QueryChain9(Query22(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query22((post) => {
     expect(post.data.foo).toBe("bar");
-  }), Query17(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query17((post) => {
+  }), Query22(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query22((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");
-  }), Query17((post) => txn.deleteEntity(ref)), Query17((res) => {
+  }), Query22((post) => txn.deleteEntity(ref)), Query22((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(ref)[0]).toBe("delete");
@@ -455,14 +530,14 @@ var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
 };
 var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
-  return QueryChain9(Query17(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query17(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+  return QueryChain9(Query22(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query22(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var PayloadSchema4 = z28.object({
-  name: z28.string().optional(),
+var PayloadSchema4 = z35.object({
+  name: z35.string().optional(),
   post1ref: PostRefSchema.optional(),
   post2ref: PostRefSchema.optional()
 }).strict();
-var testTransactionalEdits = writeOperation12("testTransactionalEdits", PayloadSchema4, (txn) => {
+var testTransactionalEdits = writeOperation13("testTransactionalEdits", PayloadSchema4, (txn) => {
   const { name, post1ref, post2ref } = txn.payload;
   if (name)
     return TestCreatePatchDeleteInSameTransaction(txn, name);
@@ -473,30 +548,30 @@ var testTransactionalEdits = writeOperation12("testTransactionalEdits", PayloadS
 }, {});
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query18, writeOperation as writeOperation13 } from "roc-db";
-import { z as z29 } from "zod";
-var updateBlockParagraph = writeOperation13("updateBlockParagraph", z29.object({
+import { Query as Query23, writeOperation as writeOperation14 } from "roc-db";
+import { z as z36 } from "zod";
+var updateBlockParagraph = writeOperation14("updateBlockParagraph", z36.object({
   ref: BlockParagraphRefSchema,
-  content: z29.string()
+  content: z36.string()
 }), (txn) => {
   const { ref, content } = txn.payload;
-  return Query18(() => txn.patchEntity(ref, {
+  return Query23(() => txn.patchEntity(ref, {
     data: { content }
   }));
 }, { outputSchema: BlockParagraphSchema });
 
 // src/operations/updatePost.ts
-import { Query as Query19, writeOperation as writeOperation14 } from "roc-db";
-import { z as z30 } from "zod";
-var PayloadSchema5 = z30.object({
+import { Query as Query24, writeOperation as writeOperation15 } from "roc-db";
+import { z as z37 } from "zod";
+var PayloadSchema5 = z37.object({
   ref: PostRefSchema,
-  title: z30.string().optional(),
-  tags: z30.array(z30.string()).optional().default([]),
+  title: z37.string().optional(),
+  tags: z37.array(z37.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 });
-var updatePost = writeOperation14("updatePost", PayloadSchema5, (txn) => {
+var updatePost = writeOperation15("updatePost", PayloadSchema5, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query19(() => txn.updateEntity(ref, {
+  return Query24(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -504,35 +579,35 @@ var updatePost = writeOperation14("updatePost", PayloadSchema5, (txn) => {
 }, { outputSchema: PostSchema });
 
 // src/operations/updatePostDescription.ts
-import { Query as Query20, writeOperation as writeOperation15 } from "roc-db";
-import { z as z31 } from "zod";
-var updatePostDescription = writeOperation15("updatePostDescription", z31.object({ ref: PostRefSchema, description: z31.string() }), (txn) => {
+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) => {
   const { ref, description } = txn.payload;
-  return Query20(() => txn.patchEntity(ref, { data: { description } }));
+  return Query25(() => txn.patchEntity(ref, { data: { description } }));
 }, { debounce: 10, changeSetOnly: true, outputSchema: PostSchema });
 
 // src/operations/updatePostSlug.ts
-import { Query as Query21, writeOperation as writeOperation16 } from "roc-db";
-import { z as z32 } from "zod";
-var updatePostSlug = writeOperation16("updatePostSlug", z32.object({ ref: PostRefSchema, slug: z32.string() }), (txn) => {
+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) => {
   const { ref, slug } = txn.payload;
-  return Query21(() => txn.patchEntity(ref, { data: { slug } }));
+  return Query26(() => txn.patchEntity(ref, { data: { slug } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTags.ts
-import { Query as Query22, writeOperation as writeOperation17 } from "roc-db";
-import { z as z33 } from "zod";
-var updatePostTags = writeOperation17("updatePostTags", z33.object({ ref: PostRefSchema, tags: z33.array(z33.string()) }), (txn) => {
+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) => {
   const { ref, tags } = txn.payload;
-  return Query22(() => txn.patchEntity(ref, { data: { tags } }));
+  return Query27(() => txn.patchEntity(ref, { data: { tags } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query23, writeOperation as writeOperation18 } from "roc-db";
-import { z as z34 } from "zod";
-var updatePostTitle = writeOperation18("updatePostTitle", z34.object({ ref: PostRefSchema, title: z34.string() }), (txn) => {
+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) => {
   const { ref, title } = txn.payload;
-  return Query23(() => txn.patchEntity(ref, { data: { title } }));
+  return Query28(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/index.ts
@@ -544,15 +619,20 @@ var operations = [
   createBlockRow,
   createDraft,
   createPost,
+  createUser,
   deleteBlocks,
   deleteDraft,
   deletePost,
   readPostBySlug,
   moveBlocks,
   pagePostsByTag,
+  pageBlocks,
   readEntity,
   readMutation,
   readPost,
+  pageEmptyEntitiesArray,
+  pagePosts,
+  pageSplat,
   testTransactionalEdits,
   updateBlockParagraph,
   updatePost,
@@ -775,6 +855,67 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       })).toThrow(BadRequestError);
     });
   });
+  describe("paging", () => {
+    let adapter;
+    let post1ref;
+    beforeAll(async () => {
+      adapter = await createAdapter();
+      const [post1] = await adapter.createPost({ title: "Post 1" });
+      post1ref = post1.ref;
+      const [user] = await adapter.createUser({ email: "foo@bar.com" });
+      const [draft1] = await adapter.createDraft({
+        postRef: post1.ref
+      });
+      const [post2] = await adapter.createPost({ title: "Post 2" });
+      const [draft2] = await adapter.createDraft({
+        postRef: post2.ref
+      });
+      const draft1adapter = adapter.changeSet(draft1.ref);
+      await draft1adapter.createBlockImage({
+        parentRef: post1.ref,
+        url: "https://example.com/image.png"
+      });
+      await draft1adapter.createBlockParagraph({
+        parentRef: post1.ref
+      });
+      await adapter.applyDraft(draft1.ref);
+      const draft2adapter = adapter.changeSet(draft2.ref);
+      await draft2adapter.createBlockImage({
+        parentRef: post2.ref,
+        url: "https://example.com/image.png"
+      });
+      await draft2adapter.createBlockParagraph({
+        parentRef: post2.ref
+      });
+      await adapter.applyDraft(draft2.ref);
+    });
+    test("limited to given collection", async () => {
+      const res = await adapter.pagePosts();
+      expect2(res).toHaveLength(2);
+    });
+    test("limit", async () => {
+      const res = await adapter.pagePosts({ size: 1 });
+      expect2(res).toHaveLength(1);
+    });
+    test("pageSplat", async () => {
+      const res = await adapter.pageSplat({});
+      expect2(res).toHaveLength(11);
+    });
+    test("pageEmptyEntitiesArray", async () => {
+      const res = await adapter.pageEmptyEntitiesArray({});
+      expect2(res).toHaveLength(0);
+    });
+    test("pageBlocks", async () => {
+      const res = await adapter.pageBlocks({});
+      expect2(res).toHaveLength(4);
+    });
+    test("pageBlocks with parent ref", async () => {
+      const res = await adapter.pageBlocks({ parentRef: post1ref });
+      expect2(res).toHaveLength(2);
+      expect2(res[0].parents.parent).toBe(post1ref);
+      expect2(res[1].parents.parent).toBe(post1ref);
+    });
+  });
   describe("changeSet", () => {
     let postRef, draftRef, changeSetAdapter, blockParagraph1, post, blockRow, blockParagraph2, draft;
     beforeAll(async () => {

package/dist/types/entities/BlockImageEntity.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const BlockImageEntity: Entity<"BlockImage", z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{
+    parent: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+}, "strip", z.ZodTypeAny, {
+    parent: `Post/${string}`;
+}, {
+    parent: `Post/${string}`;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

package/dist/types/entities/UserEntity.d.ts

@@ -0,0 +1,9 @@
+import { Entity } from "roc-db";
+import { z } from "zod";
+export declare const UserEntity: Entity<"User", z.ZodObject<{
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>, z.ZodObject<{}, z.UnknownKeysParam, z.ZodTypeAny, {}, {}>>;

package/dist/types/entities/index.d.ts

@@ -10,6 +10,18 @@ export declare const entities: (import("roc-db").Entity<"Draft", import("zod").Z
     post: `Post/${string}`;
 }, {
     post: `Post/${string}`;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"BlockImage", import("zod").ZodObject<{
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{
+    parent: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
+}, "strip", import("zod").ZodTypeAny, {
+    parent: `Post/${string}`;
+}, {
+    parent: `Post/${string}`;
 }>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"Post", import("zod").ZodObject<{
     title: import("zod").ZodString;
     text: import("zod").ZodOptional<import("zod").ZodString>;
@@ -76,4 +88,10 @@ export declare const entities: (import("roc-db").Entity<"Draft", import("zod").Z
     post: `Post/${string}`;
 }, {
     post: `Post/${string}`;
-}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>>)[];
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>> | import("roc-db").Entity<"User", import("zod").ZodObject<{
+    email: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>, import("zod").ZodObject<{}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {}, {}>>)[];

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

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export declare const createBlockImage: import("roc-db").WriteOperation<"createBlockImage", z.ZodObject<{
-    postRef: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    parentRef: z.ZodType<`Post/${string}`, z.ZodTypeDef, `Post/${string}`>;
+    url: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    postRef: `Post/${string}`;
+    url: string;
+    parentRef: `Post/${string}`;
 }, {
-    postRef: `Post/${string}`;
+    url: string;
+    parentRef: `Post/${string}`;
 }>>;

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const createUser: import("roc-db").WriteOperation<"createUser", z.ZodObject<{
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>>;

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

@@ -1,124 +1 @@
-export declare const operations: readonly [import("roc-db").WriteOperation<"applyDraft", import("zod").ZodType<`Draft/${string}`, import("zod").ZodTypeDef, `Draft/${string}`>>, import("roc-db").WriteOperation<"createBlockImage", import("zod").ZodObject<{
-    postRef: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
-}, "strict", import("zod").ZodTypeAny, {
-    postRef: `Post/${string}`;
-}, {
-    postRef: `Post/${string}`;
-}>>, import("roc-db").WriteOperation<"createBlockTitle", import("zod").ZodObject<{
-    parentRef: import("zod").ZodUnion<[import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>;
-}, "strict", import("zod").ZodTypeAny, {
-    parentRef: `Post/${string}` | `BlockRow/${string}`;
-}, {
-    parentRef: `Post/${string}` | `BlockRow/${string}`;
-}>>, import("roc-db").WriteOperation<"createBlockParagraph", import("zod").ZodObject<{
-    parentRef: import("zod").ZodUnion<[import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>;
-}, "strict", import("zod").ZodTypeAny, {
-    parentRef: `Post/${string}` | `BlockRow/${string}`;
-}, {
-    parentRef: `Post/${string}` | `BlockRow/${string}`;
-}>>, import("roc-db").WriteOperation<"createBlockRow", import("zod").ZodObject<{
-    parentRef: import("zod").ZodUnion<[import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>;
-}, "strict", import("zod").ZodTypeAny, {
-    parentRef: `Post/${string}` | `BlockRow/${string}`;
-}, {
-    parentRef: `Post/${string}` | `BlockRow/${string}`;
-}>>, import("roc-db").WriteOperation<"createDraft", import("zod").ZodObject<{
-    postRef: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
-}, "strict", import("zod").ZodTypeAny, {
-    postRef: `Post/${string}`;
-}, {
-    postRef: `Post/${string}`;
-}>>, import("roc-db").WriteOperation<"createPost", import("zod").ZodObject<{
-    title: import("zod").ZodString;
-    slug: import("zod").ZodOptional<import("zod").ZodString>;
-    tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
-}, "strict", import("zod").ZodTypeAny, {
-    title: string;
-    tags: string[];
-    slug?: string | undefined;
-}, {
-    title: string;
-    tags?: string[] | undefined;
-    slug?: string | undefined;
-}>>, import("roc-db").WriteOperation<"deleteBlocks", import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodType<`BlockParagraph/${string}`, import("zod").ZodTypeDef, `BlockParagraph/${string}`>, import("zod").ZodType<`BlockImage/${string}`, import("zod").ZodTypeDef, `BlockImage/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>, "many">>, import("roc-db").WriteOperation<"deleteDraft", import("zod").ZodType<`Draft/${string}`, import("zod").ZodTypeDef, `Draft/${string}`>>, import("roc-db").WriteOperation<"deletePost", import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>>, any, import("roc-db").WriteOperation<"moveBlocks", import("zod").ZodObject<{
-    refs: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodType<`BlockParagraph/${string}`, import("zod").ZodTypeDef, `BlockParagraph/${string}`>, import("zod").ZodType<`BlockRow/${string}`, import("zod").ZodTypeDef, `BlockRow/${string}`>]>, "many">;
-    targetPosition: import("zod").ZodNumber;
-}, "strict", import("zod").ZodTypeAny, {
-    refs: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
-    targetPosition: number;
-}, {
-    refs: (`BlockParagraph/${string}` | `BlockRow/${string}`)[];
-    targetPosition: number;
-}>>, any, any, any, any, import("roc-db").WriteOperation<"testTransactionalEdits", import("zod").ZodObject<{
-    name: import("zod").ZodOptional<import("zod").ZodString>;
-    post1ref: import("zod").ZodOptional<import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>>;
-    post2ref: import("zod").ZodOptional<import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>>;
-}, "strict", import("zod").ZodTypeAny, {
-    name?: string | undefined;
-    post1ref?: `Post/${string}` | undefined;
-    post2ref?: `Post/${string}` | undefined;
-}, {
-    name?: string | undefined;
-    post1ref?: `Post/${string}` | undefined;
-    post2ref?: `Post/${string}` | undefined;
-}>>, import("roc-db").WriteOperation<"updateBlockParagraph", import("zod").ZodObject<{
-    ref: import("zod").ZodType<`BlockParagraph/${string}`, import("zod").ZodTypeDef, `BlockParagraph/${string}`>;
-    content: import("zod").ZodString;
-}, "strip", import("zod").ZodTypeAny, {
-    ref: `BlockParagraph/${string}`;
-    content: string;
-}, {
-    ref: `BlockParagraph/${string}`;
-    content: string;
-}>>, import("roc-db").WriteOperation<"updatePost", import("zod").ZodObject<{
-    ref: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
-    title: import("zod").ZodOptional<import("zod").ZodString>;
-    tags: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>;
-    authorRef: import("zod").ZodOptional<import("zod").ZodType<`User/${string}`, import("zod").ZodTypeDef, `User/${string}`>>;
-}, "strip", import("zod").ZodTypeAny, {
-    ref: `Post/${string}`;
-    tags: string[];
-    title?: string | undefined;
-    authorRef?: `User/${string}` | undefined;
-}, {
-    ref: `Post/${string}`;
-    title?: string | undefined;
-    tags?: string[] | undefined;
-    authorRef?: `User/${string}` | undefined;
-}>>, import("roc-db").WriteOperation<"updatePostDescription", import("zod").ZodObject<{
-    ref: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
-    description: import("zod").ZodString;
-}, "strip", import("zod").ZodTypeAny, {
-    ref: `Post/${string}`;
-    description: string;
-}, {
-    ref: `Post/${string}`;
-    description: string;
-}>>, import("roc-db").WriteOperation<"updatePostSlug", import("zod").ZodObject<{
-    ref: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
-    slug: import("zod").ZodString;
-}, "strip", import("zod").ZodTypeAny, {
-    ref: `Post/${string}`;
-    slug: string;
-}, {
-    ref: `Post/${string}`;
-    slug: string;
-}>>, import("roc-db").WriteOperation<"updatePostTags", import("zod").ZodObject<{
-    ref: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
-    tags: import("zod").ZodArray<import("zod").ZodString, "many">;
-}, "strip", import("zod").ZodTypeAny, {
-    ref: `Post/${string}`;
-    tags: string[];
-}, {
-    ref: `Post/${string}`;
-    tags: string[];
-}>>, import("roc-db").WriteOperation<"updatePostTitle", import("zod").ZodObject<{
-    ref: import("zod").ZodType<`Post/${string}`, import("zod").ZodTypeDef, `Post/${string}`>;
-    title: import("zod").ZodString;
-}, "strip", import("zod").ZodTypeAny, {
-    ref: `Post/${string}`;
-    title: string;
-}, {
-    ref: `Post/${string}`;
-    title: string;
-}>>];
+export declare const operations: any[];

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

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

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

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

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

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

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

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

package/package.json

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