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

package/dist/index.js

@@ -40,140 +40,172 @@ var BlockParagraphSchema = entitySchemaGenerator2("BlockParagraph", {
   })
 });
 
-// src/schemas/BlockRowSchema.ts
+// src/schemas/BlockTitleSchema.ts
 import { entitySchemaGenerator as entitySchemaGenerator3 } from "roc-db";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
-// src/schemas/BlockRowRefSchema.ts
+// src/schemas/BlockTitleRefSchema.ts
 import { refSchemaGenerator as refSchemaGenerator4 } from "roc-db";
-var BlockRowRefSchema = refSchemaGenerator4("BlockRow");
+var BlockTitleRefSchema = refSchemaGenerator4("BlockTitle");
 
-// src/schemas/BlockRefSchema.ts
-import { z as z3 } from "zod";
-var BlockRefSchema = z3.union([
-  BlockParagraphRefSchema,
-  BlockRowRefSchema
-]);
-
-// src/schemas/BlockRowSchema.ts
-var BlockRowSchema = entitySchemaGenerator3("BlockRow", {
-  ref: BlockRowRefSchema,
-  children: z4.object({
-    blocks: z4.array(BlockRefSchema)
+// src/schemas/BlockTitleSchema.ts
+var BlockTitleSchema = entitySchemaGenerator3("BlockTitle", {
+  ref: BlockTitleRefSchema,
+  data: z3.object({
+    content: z3.string()
   }),
-  parents: z4.object({
-    post: PostRefSchema,
-    block: BlockRefSchema
+  parents: z3.object({
+    post: PostRefSchema
   })
 });
 
-// src/schemas/BlockTitleSchema.ts
+// src/schemas/DraftSchema.ts
 import { entitySchemaGenerator as entitySchemaGenerator4 } from "roc-db";
 import { z as z5 } from "zod";
 
-// src/schemas/BlockTitleRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
-var BlockTitleRefSchema = refSchemaGenerator5("BlockTitle");
-
-// src/schemas/BlockTitleSchema.ts
-var BlockTitleSchema = entitySchemaGenerator4("BlockTitle", {
-  ref: BlockTitleRefSchema,
-  data: z5.object({
-    content: z5.string()
+// src/entities/Draft.ts
+import { Entity } from "roc-db";
+import { z as z4 } from "zod";
+var Draft = new Entity("Draft", {
+  data: z4.object({
+    appliedAt: z4.string().optional()
   }),
-  parents: z5.object({
+  parents: z4.object({
     post: PostRefSchema
   })
 });
 
-// src/schemas/DraftSchema.ts
-import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
-import { z as z6 } from "zod";
-
 // src/schemas/DraftRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
-var DraftRefSchema = refSchemaGenerator6("Draft");
+var DraftRefSchema = Draft.refSchema;
 
 // src/schemas/DraftSchema.ts
-var DraftSchema = entitySchemaGenerator5("Draft", {
+var DraftSchema = entitySchemaGenerator4("Draft", {
   ref: DraftRefSchema,
-  parents: z6.object({
+  parents: z5.object({
     post: PostRefSchema
   })
 });
 
 // src/schemas/PostSchema.ts
-import { entitySchemaGenerator as entitySchemaGenerator6 } from "roc-db";
-import { z as z7 } from "zod";
+import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
+import { z as z6 } from "zod";
 
 // src/schemas/UserRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator7 } from "roc-db";
-var UserRefSchema = refSchemaGenerator7("User");
+import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
+var UserRefSchema = refSchemaGenerator5("User");
 
 // src/schemas/PostSchema.ts
-var PostSchema = entitySchemaGenerator6("Post", {
+var PostSchema = entitySchemaGenerator5("Post", {
   ref: PostRefSchema,
-  data: z7.object({
-    title: z7.string(),
-    text: z7.string().optional(),
-    tags: z7.array(z7.string()),
-    slug: z7.string().optional()
+  data: z6.object({
+    title: z6.string(),
+    text: z6.string().optional(),
+    tags: z6.array(z6.string()),
+    slug: z6.string().optional()
   }),
-  parents: z7.object({ author: UserRefSchema.optional() }),
-  children: z7.object({ blocks: z7.array(z7.string()) })
-});
-
-// src/schemas/PostVersionSchema.ts
-import { entitySchemaGenerator as entitySchemaGenerator7 } from "roc-db";
-import { z as z8 } from "zod";
-
-// src/schemas/PostVersionRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator8 } from "roc-db";
-var PostVersionRefSchema = refSchemaGenerator8("PostVersion");
-
-// src/schemas/PostVersionSchema.ts
-var PostVersionSchema = entitySchemaGenerator7("PostVersion", {
-  ref: PostVersionRefSchema,
-  data: z8.object({
-    version: z8.number(),
-    snapshot: z8.array(z8.any())
-  }),
-  parents: z8.object({ post: PostRefSchema })
+  parents: z6.object({ author: UserRefSchema.optional() }),
+  children: z6.object({ blocks: z6.array(z6.string()) })
 });
 // src/schemas/CreatePostMutationSchema.ts
 import { mutationSchemaGenerator } from "roc-db";
-import { z as z9 } from "zod";
-var CreatePostMutationSchema = mutationSchemaGenerator("createPost", z9.object({
-  title: z9.string(),
-  slug: z9.string().optional(),
-  tags: z9.array(z9.string()).default([])
+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([])
 }).strict());
 // src/schemas/CreateUserMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator2 } from "roc-db";
-import { z as z10 } from "zod";
-var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z10.object({ email: z10.string() }));
+import { z as z8 } from "zod";
+var CreateUserMutationSchema = mutationSchemaGenerator2("createUser", z8.object({ email: z8.string() }));
 // src/schemas/UpdatePostMutationSchema.ts
 import { mutationSchemaGenerator as mutationSchemaGenerator3 } from "roc-db";
-import { z as z11 } from "zod";
-var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z11.object({
+import { z as z9 } from "zod";
+var UpdatePostMutationSchema = mutationSchemaGenerator3("updatePost", z9.object({
   ref: PostRefSchema,
-  title: z11.string().optional(),
-  tags: z11.array(z11.string()).optional().default([]),
+  title: z9.string().optional(),
+  tags: z9.array(z9.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() }));
+// src/entities/BlockParagraph.ts
+import { Entity as Entity3 } from "roc-db";
+import { z as z13 } from "zod";
+
+// src/entities/PostEntity.ts
+import { Entity as Entity2 } from "roc-db";
+import { z as z11 } from "zod";
+var PostEntity = new Entity2("Post", {
+  data: z11.object({
+    title: z11.string(),
+    text: z11.string().optional(),
+    tags: z11.array(z11.string()),
+    slug: z11.string().optional()
+  }),
+  parents: z11.object({ author: UserRefSchema.optional() }),
+  children: z11.object({ blocks: z11.array(z11.string()) }),
+  indexedDataKeys: ["tags", "slug"],
+  uniqueDataKeys: ["slug"]
+});
+
+// src/schemas/BlockRefSchema.ts
 import { z as z12 } from "zod";
-var UpdatePostTitleMutationSchema = mutationSchemaGenerator4("updatePostTitle", z12.object({ ref: PostRefSchema, title: z12.string() }));
-// src/schemas/index.ts
+
+// src/schemas/BlockRowRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
+var BlockRowRefSchema = refSchemaGenerator6("BlockRow");
+
+// src/schemas/BlockRefSchema.ts
+var BlockRefSchema = z12.union([
+  BlockParagraphRefSchema,
+  BlockRowRefSchema
+]);
+
+// src/entities/BlockParagraph.ts
+var BlockParagraph = new Entity3("BlockParagraph", {
+  data: z13.object({
+    content: z13.string().optional()
+  }),
+  parents: z13.object({
+    parent: z13.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)
+  }),
+  parents: z14.object({
+    parent: z14.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())
+  }),
+  parents: z15.object({ post: PostRefSchema }),
+  indexedDataKeys: ["version"],
+  uniqueDataKeys: ["slug"]
+});
+
+// src/entities/index.ts
 var entities = [
-  BlockRowSchema,
-  BlockImageSchema,
-  BlockParagraphSchema,
-  BlockTitleSchema,
-  DraftSchema,
-  PostSchema,
-  PostVersionSchema
+  BlockParagraph,
+  BlockRow,
+  Draft,
+  PostEntity,
+  PostVersion
 ];
 // src/operations/applyDraft.ts
 import { Query, QueryChain, writeOperation } from "roc-db";
@@ -182,17 +214,21 @@ var applyDraft = writeOperation("applyDraft", DraftRefSchema, (txn) => {
   const versionRef = txn.createRef("PostVersion");
   return QueryChain(Query(() => txn.applyChangeSet(ref)), Query(() => txn.patchEntity(ref, {
     data: { appliedAt: txn.timestamp }
-  })), Query((draft) => txn.childRefsOf(draft.parents.post, true)), Query((childRefs, draft) => txn.batchReadEntities([draft.parents.post, ...childRefs])), Query((childEntities) => txn.createEntity(versionRef, {
+  })), Query((draft) => txn.childRefsOf(draft.parents.post, true)), Query((childRefs, draft) => txn.batchReadEntities([draft.parents.post, ...childRefs])), Query((childEntities, _, draft) => txn.createEntity(versionRef, {
     data: {
+      version: 1,
       snapshot: childEntities
+    },
+    parents: {
+      post: draft.parents.post
     }
   })));
 });
 
 // src/operations/createBlockImage.ts
 import { Query as Query2, writeOperation as writeOperation2 } from "roc-db";
-import { z as z13 } from "zod";
-var createBlockImage = writeOperation2("createBlockImage", z13.object({ postRef: PostRefSchema }).strict(), (txn) => {
+import { z as z16 } from "zod";
+var createBlockImage = writeOperation2("createBlockImage", z16.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("BlockImage");
   const { postRef } = txn.payload;
   return Query2(() => txn.createEntity(ref, { parents: { post: postRef } }));
@@ -200,8 +236,8 @@ var createBlockImage = writeOperation2("createBlockImage", z13.object({ postRef:
 
 // src/operations/createBlockParagraph.ts
 import { Query as Query3, QueryChain as QueryChain2, writeOperation as writeOperation3 } from "roc-db";
-import { z as z14 } from "zod";
-var createBlockParagrah = writeOperation3("createBlockParagraph", z14.object({ parentRef: z14.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+import { z as z17 } from "zod";
+var createBlockParagrah = writeOperation3("createBlockParagraph", z17.object({ parentRef: z17.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, {
@@ -209,16 +245,16 @@ var createBlockParagrah = writeOperation3("createBlockParagraph", z14.object({ p
   })), Query3(() => txn.createEntity(ref, { parents: { parent: parentRef } })), Query3((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z14.object({
-    block: z14.any(),
-    updatedParent: z14.any()
+  outputSchema: z17.object({
+    block: z17.any(),
+    updatedParent: z17.any()
   })
 });
 
 // src/operations/createBlockRow.ts
 import { Query as Query4, QueryChain as QueryChain3, writeOperation as writeOperation4 } from "roc-db";
-import { z as z15 } from "zod";
-var createBlockRow = writeOperation4("createBlockRow", z15.object({ parentRef: z15.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
+import { z as z18 } from "zod";
+var createBlockRow = writeOperation4("createBlockRow", z18.object({ parentRef: z18.union([PostRefSchema, BlockRowRefSchema]) }).strict(), (txn) => {
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
   return QueryChain3(Query4(() => txn.readEntity(parentRef)), Query4((parent) => {
@@ -231,16 +267,16 @@ var createBlockRow = writeOperation4("createBlockRow", z15.object({ parentRef: z
   })), Query4((block, updatedParent) => ({ block, updatedParent })));
 }, {
   changeSetOnly: true,
-  outputSchema: z15.object({
-    block: z15.any(),
-    updatedParent: z15.any()
+  outputSchema: z18.object({
+    block: z18.any(),
+    updatedParent: z18.any()
   })
 });
 
 // src/operations/createBlockTitle.ts
 import { Query as Query5, writeOperation as writeOperation5 } from "roc-db";
-import { z as z16 } from "zod";
-var PayloadSchema = z16.object({ parentRef: z16.union([PostRefSchema, BlockRowRefSchema]) }).strict();
+import { z as z19 } from "zod";
+var PayloadSchema = z19.object({ parentRef: z19.union([PostRefSchema, BlockRowRefSchema]) }).strict();
 var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn) => {
   const ref = txn.createRef("BlockTitle");
   const { postRef } = txn.payload;
@@ -249,8 +285,8 @@ var createBlockTitle = writeOperation5("createBlockTitle", PayloadSchema, (txn)
 
 // src/operations/createDraft.ts
 import { Query as Query6, writeOperation as writeOperation6 } from "roc-db";
-import { z as z17 } from "zod";
-var createDraft = writeOperation6("createDraft", z17.object({ postRef: PostRefSchema }).strict(), (txn) => {
+import { z as z20 } from "zod";
+var createDraft = writeOperation6("createDraft", z20.object({ postRef: PostRefSchema }).strict(), (txn) => {
   const ref = txn.createRef("Draft");
   const { postRef } = txn.payload;
   return Query6(() => txn.createEntity(ref, {
@@ -262,11 +298,11 @@ var createDraft = writeOperation6("createDraft", z17.object({ postRef: PostRefSc
 
 // src/operations/createPost.ts
 import { Query as Query7, writeOperation as writeOperation7 } from "roc-db";
-import { z as z18 } from "zod";
-var PayloadSchema2 = z18.object({
-  title: z18.string(),
-  slug: z18.string().optional(),
-  tags: z18.array(z18.string()).default([])
+import { z as z21 } from "zod";
+var PayloadSchema2 = z21.object({
+  title: z21.string(),
+  slug: z21.string().optional(),
+  tags: z21.array(z21.string()).default([])
 }).strict();
 var createPost = writeOperation7("createPost", PayloadSchema2, (txn) => {
   const ref = txn.createRef("Post");
@@ -279,7 +315,7 @@ var createPost = writeOperation7("createPost", PayloadSchema2, (txn) => {
 
 // src/operations/deleteBlocks.ts
 import { Query as Query8, QueryChain as QueryChain4, writeOperation as writeOperation8 } from "roc-db";
-import { z as z19 } from "zod";
+import { z as z22 } from "zod";
 var DeleteBlockQuery = (txn, blockRef) => {
   return QueryChain4(Query8(() => txn.readEntity(blockRef)), Query8((block) => {
     return txn.readEntity(block.parents.parent, true);
@@ -291,7 +327,7 @@ var DeleteBlockQuery = (txn, blockRef) => {
     });
   }), Query8(() => txn.deleteEntity(blockRef)));
 };
-var deleteBlocks = writeOperation8("deleteBlocks", z19.array(z19.union([
+var deleteBlocks = writeOperation8("deleteBlocks", z22.array(z22.union([
   BlockParagraphRefSchema,
   BlockImageRefSchema,
   BlockRowRefSchema
@@ -316,10 +352,10 @@ var deletePost = writeOperation10("deletePost", PostRefSchema, (txn) => {
 
 // src/operations/moveBlocks.ts
 import { Query as Query11, QueryChain as QueryChain6, writeOperation as writeOperation11 } from "roc-db";
-import { z as z20 } from "zod";
-var PayloadSchema3 = z20.object({
-  refs: z20.array(z20.union([BlockParagraphRefSchema, BlockRowRefSchema])),
-  targetPosition: z20.number().min(0)
+import { z as z23 } from "zod";
+var PayloadSchema3 = z23.object({
+  refs: z23.array(z23.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z23.number().min(0)
 }).strict();
 var moveBlocks = writeOperation11("moveBlocks", PayloadSchema3, (txn) => {
   const { refs } = txn.payload;
@@ -328,19 +364,27 @@ var moveBlocks = writeOperation11("moveBlocks", PayloadSchema3, (txn) => {
   }));
 });
 
+// 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) => {
+  const tag = txn.payload;
+  return Query12(() => txn.pageEntitiesByIndex("Post", "tags", tag));
+});
+
 // src/operations/readEntity.ts
-import { NotFoundError, Query as Query12, QueryChain as QueryChain7, readOperation } from "roc-db";
-import { z as z21 } from "zod";
-var readEntity = readOperation("readEntity", z21.string(), (txn) => {
+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) => {
   const ref = txn.payload;
-  return QueryChain7(Query12(() => txn.readEntity(ref)), Query12((entity) => {
+  return QueryChain7(Query13(() => txn.readEntity(ref)), Query13((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
     return entity;
   }));
 }, {
-  outputSchema: z21.union([
+  outputSchema: z25.union([
     PostSchema,
     BlockImageSchema,
     BlockParagraphSchema
@@ -348,11 +392,11 @@ var readEntity = readOperation("readEntity", z21.string(), (txn) => {
 });
 
 // src/operations/readMutation.ts
-import { NotFoundError as NotFoundError2, Query as Query13, QueryChain as QueryChain8, readOperation as readOperation2 } from "roc-db";
-import { z as z22 } from "zod";
-var readMutation = readOperation2("readMutation", z22.string(), (txn) => {
+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) => {
   const ref = txn.payload;
-  return QueryChain8(Query13(() => txn.readMutation(ref)), Query13((entity) => {
+  return QueryChain8(Query14(() => txn.readMutation(ref)), Query14((entity) => {
     if (!entity) {
       throw new NotFoundError2(ref);
     }
@@ -361,41 +405,49 @@ var readMutation = readOperation2("readMutation", z22.string(), (txn) => {
 });
 
 // src/operations/readPost.ts
-import { Query as Query14, readOperation as readOperation3 } from "roc-db";
-var readPost = readOperation3("readPost", PostRefSchema, (txn) => {
+import { Query as Query15, readOperation as readOperation4 } from "roc-db";
+var readPost = readOperation4("readPost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query14(() => txn.readEntity(ref, true));
+  return Query15(() => 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) => {
+  const slug = txn.payload;
+  return Query16(() => txn.readEntityByUniqueField("Post", "slug", slug));
 }, { outputSchema: PostSchema });
 
 // src/operations/testTransactionalEdits.ts
 import { expect } from "bun:test";
-import { Query as Query15, QueryChain as QueryChain9, writeOperation as writeOperation12 } from "roc-db";
-import { z as z23 } from "zod";
+import { Query as Query17, QueryChain as QueryChain9, writeOperation as writeOperation12 } from "roc-db";
+import { z as z28 } from "zod";
 var TestCreatePatchDeleteInSameTransaction = (txn, name) => {
   const postRef = txn.createRef("Post");
-  QueryChain9(Query15(() => txn.createEntity(postRef, { data: { name } })), Query15(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query15((post) => {
+  QueryChain9(Query17(() => txn.createEntity(postRef, { data: { name } })), Query17(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query17((post) => {
     expect(post.data.name).toBe(name);
     expect(post.data.foo).toBe("bar");
-  }), Query15(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query15((post) => {
+  }), Query17(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query17((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");
-  }), Query15((post) => txn.deleteEntity(postRef)), Query15((res) => {
+  }), Query17((post) => txn.deleteEntity(postRef)), Query17((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(0);
   }));
 };
 var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
-  return QueryChain9(Query15(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query15((post) => {
+  return QueryChain9(Query17(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query17((post) => {
     expect(post.data.foo).toBe("bar");
-  }), Query15(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query15((post) => {
+  }), Query17(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query17((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");
-  }), Query15((post) => txn.deleteEntity(ref)), Query15((res) => {
+  }), Query17((post) => txn.deleteEntity(ref)), Query17((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(ref)[0]).toBe("delete");
@@ -403,10 +455,10 @@ var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
 };
 var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
-  return QueryChain9(Query15(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query15(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+  return QueryChain9(Query17(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query17(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var PayloadSchema4 = z23.object({
-  name: z23.string().optional(),
+var PayloadSchema4 = z28.object({
+  name: z28.string().optional(),
   post1ref: PostRefSchema.optional(),
   post2ref: PostRefSchema.optional()
 }).strict();
@@ -421,30 +473,30 @@ var testTransactionalEdits = writeOperation12("testTransactionalEdits", PayloadS
 }, {});
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query16, writeOperation as writeOperation13 } from "roc-db";
-import { z as z24 } from "zod";
-var updateBlockParagraph = writeOperation13("updateBlockParagraph", z24.object({
+import { Query as Query18, writeOperation as writeOperation13 } from "roc-db";
+import { z as z29 } from "zod";
+var updateBlockParagraph = writeOperation13("updateBlockParagraph", z29.object({
   ref: BlockParagraphRefSchema,
-  content: z24.string()
+  content: z29.string()
 }), (txn) => {
   const { ref, content } = txn.payload;
-  return Query16(() => txn.patchEntity(ref, {
+  return Query18(() => txn.patchEntity(ref, {
     data: { content }
   }));
 }, { outputSchema: BlockParagraphSchema });
 
 // src/operations/updatePost.ts
-import { Query as Query17, writeOperation as writeOperation14 } from "roc-db";
-import { z as z25 } from "zod";
-var PayloadSchema5 = z25.object({
+import { Query as Query19, writeOperation as writeOperation14 } from "roc-db";
+import { z as z30 } from "zod";
+var PayloadSchema5 = z30.object({
   ref: PostRefSchema,
-  title: z25.string().optional(),
-  tags: z25.array(z25.string()).optional().default([]),
+  title: z30.string().optional(),
+  tags: z30.array(z30.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 });
 var updatePost = writeOperation14("updatePost", PayloadSchema5, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query17(() => txn.updateEntity(ref, {
+  return Query19(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -452,19 +504,35 @@ var updatePost = writeOperation14("updatePost", PayloadSchema5, (txn) => {
 }, { outputSchema: PostSchema });
 
 // src/operations/updatePostDescription.ts
-import { Query as Query18, writeOperation as writeOperation15 } from "roc-db";
-import { z as z26 } from "zod";
-var updatePostDescription = writeOperation15("updatePostDescription", z26.object({ ref: PostRefSchema, description: z26.string() }), (txn) => {
+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) => {
   const { ref, description } = txn.payload;
-  return Query18(() => txn.patchEntity(ref, { data: { description } }));
+  return Query20(() => 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) => {
+  const { ref, slug } = txn.payload;
+  return Query21(() => 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) => {
+  const { ref, tags } = txn.payload;
+  return Query22(() => txn.patchEntity(ref, { data: { tags } }));
+}, { debounce: 10, outputSchema: PostSchema });
+
 // src/operations/updatePostTitle.ts
-import { Query as Query19, writeOperation as writeOperation16 } from "roc-db";
-import { z as z27 } from "zod";
-var updatePostTitle = writeOperation16("updatePostTitle", z27.object({ ref: PostRefSchema, title: z27.string() }), (txn) => {
+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) => {
   const { ref, title } = txn.payload;
-  return Query19(() => txn.patchEntity(ref, { data: { title } }));
+  return Query23(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/index.ts
@@ -479,7 +547,9 @@ var operations = [
   deleteBlocks,
   deleteDraft,
   deletePost,
+  readPostBySlug,
   moveBlocks,
+  pagePostsByTag,
   readEntity,
   readMutation,
   readPost,
@@ -487,16 +557,24 @@ var operations = [
   updateBlockParagraph,
   updatePost,
   updatePostDescription,
+  updatePostSlug,
+  updatePostTags,
   updatePostTitle
 ];
 // src/testAdapterImplementation.ts
 import { beforeAll, describe, expect as expect2, test } from "bun:test";
-import { BadRequestError, NotFoundError as NotFoundError3, Snowflake } from "roc-db";
+import {
+  BadRequestError,
+  ConflictError,
+  NotFoundError as NotFoundError3,
+  Snowflake
+} from "roc-db";
+import { faker } from "@faker-js/faker";
 var snowflake = new Snowflake(10, 10);
 var prepareChangeSetTest = async (adapter, adapter2) => {
   const [post, createPostMutation] = await adapter.createPost({
     title: "Title 1",
-    slug: "title-1",
+    slug: faker.lorem.slug(5),
     tags: ["Foo", "Bar"]
   });
   expect2(createPostMutation.log).toStrictEqual([[post.ref, "create"]]);
@@ -561,7 +639,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
     beforeAll(async () => {
       const createPostRes = await adapter1.createPost({
         title: "Title 1",
-        slug: "title-1",
+        slug: faker.lorem.slug(5),
         tags: ["Foo", "Bar"]
       });
       post = createPostRes[0];
@@ -569,7 +647,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       createPostMutation = createPostRes[1];
     });
     test("create (createEntity function)", async () => {
-      expect2(post).toMatchZodSchema(PostSchema);
+      expect2(post).toMatchZodSchema(PostEntity.schema);
       expect2(post.data.title).toBe("Title 1");
       expect2(post.data.tags).toStrictEqual(["Foo", "Bar"]);
       expect2(createPostMutation).toMatchZodSchema(CreatePostMutationSchema);
@@ -578,7 +656,58 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       const readPostRes = await adapter1.readPost(postRef);
       expect2(readPostRes.data.title).toStrictEqual("Title 1");
       expect2(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
-      expect2(readPostRes).toMatchZodSchema(PostSchema);
+      expect2(readPostRes).toMatchZodSchema(PostEntity.schema);
+    });
+    test("read by unique", async () => {
+      const readPostRes = await adapter1.readPostBySlug(post.data.slug);
+      expect2(readPostRes.data.title).toStrictEqual("Title 1");
+      expect2(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
+      expect2(readPostRes.data.slug).toStrictEqual(post.data.slug);
+    });
+    test("create with same slug", async () => {
+      expect2(() => adapter1.createPost({
+        title: "Title 2",
+        slug: post.data.slug,
+        tags: ["Foo", "Bar"]
+      })).toThrow(ConflictError);
+    });
+    test("update unique slug", async () => {
+      const slug1 = faker.lorem.slug(5);
+      const slug2 = faker.lorem.slug(5);
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        slug: slug1
+      });
+      const readPostRes1 = await adapter1.readPostBySlug(slug1);
+      expect2(readPostRes1.data.slug).toStrictEqual(slug1);
+      const [updateRes] = await adapter1.updatePostSlug({
+        ref: post2.ref,
+        slug: slug2
+      });
+      expect2(updateRes.data.slug).toStrictEqual(slug2);
+      expect2(() => adapter1.readPostBySlug(slug1)).toThrow(NotFoundError3);
+      const readPostRes2 = await adapter1.readPostBySlug(slug2);
+      expect2(readPostRes2.data.slug).toStrictEqual(slug2);
+    });
+    test("update index entries", async () => {
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        tags: ["foo"]
+      });
+      const pageTagFoo1 = await adapter1.pagePostsByTag("foo");
+      expect2(pageTagFoo1.length).toBe(1);
+      expect2(pageTagFoo1[0].ref).toBe(post2.ref);
+      const [updatedRes] = await adapter1.updatePostTags({
+        ref: post2.ref,
+        tags: ["bar"]
+      });
+      const pageTagFoo2 = await adapter1.pagePostsByTag("foo");
+      expect2(pageTagFoo2.length).toBe(0);
+      const pageTagBar1 = await adapter1.pagePostsByTag("bar");
+      expect2(pageTagBar1.length).toBe(1);
+      await adapter1.deletePost(post2.ref);
+      const pageTagBar2 = await adapter1.pagePostsByTag("bar");
+      expect2(pageTagBar2.length).toBe(0);
     });
     test("read not found (readEntity function)", async () => {
       expect2(() => adapter1.readPost("Post/999")).toThrow(NotFoundError3);
@@ -591,20 +720,20 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       });
       expect2(post2.data.tags).toStrictEqual(["Foo"]);
       expect2(post2.data.title).toBe("Title 2");
-      expect2(post2).toMatchZodSchema(PostSchema);
+      expect2(post2).toMatchZodSchema(PostEntity.schema);
     });
     test("updateTitle (patchEntity function + debounce)", async () => {
       const [update1, mutation1] = await adapter1.updatePostTitle({
         ref: postRef,
         title: "Title 3"
       });
-      expect2(update1).toMatchZodSchema(PostSchema);
+      expect2(update1).toMatchZodSchema(PostEntity.schema);
       expect2(mutation1).toMatchZodSchema(UpdatePostTitleMutationSchema);
       const [update2, mutation2] = await adapter1.updatePostTitle({
         ref: postRef,
         title: "Title 4"
       });
-      expect2(update2).toMatchZodSchema(PostSchema);
+      expect2(update2).toMatchZodSchema(PostEntity.schema);
       expect2(mutation2).toMatchZodSchema(UpdatePostTitleMutationSchema);
       expect2(mutation1.ref).toBe(mutation2.ref);
       expect2(mutation2.timestamp >= mutation1.timestamp).toBeTrue();
@@ -661,19 +790,19 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       } = await prepareChangeSetTest(adapter1, adapter2));
     });
     test("create (createEntity function w/changeSetRef)", async () => {
-      expect2(blockParagraph1).toMatchZodSchema(BlockParagraphSchema);
-      expect2(post).toMatchZodSchema(PostSchema);
+      expect2(blockParagraph1).toMatchZodSchema(BlockParagraph.schema);
+      expect2(post).toMatchZodSchema(PostEntity.schema);
     });
     test("read (readEntity function w/changeSetRef)", async () => {
       const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
-      expect2(read).toMatchZodSchema(BlockParagraphSchema);
+      expect2(read).toMatchZodSchema(BlockParagraph.schema);
     });
     test("update (patchEntity function w/changeSetRef)", async () => {
       const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
         ref: blockParagraph1.ref,
         content: "Hello, world!"
       });
-      expect2(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+      expect2(updatedBlock).toMatchZodSchema(BlockParagraph.schema);
     });
     test("move (batchReadEntities function)", async () => {
       const res = await changeSetAdapter.moveBlocks({
@@ -720,7 +849,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
     test("deleteBlocks (patch running 2 times removing on array element every time)", async () => {
       const [post2, createPostMutation] = await adapter1.createPost({
         title: "Title 1",
-        slug: "title-1",
+        slug: faker.lorem.slug(5),
         tags: ["Foo", "Bar"]
       });
       const [draft2, createDraftMutation] = await adapter1.createDraft({
@@ -789,6 +918,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       expect2(optimisticAdapter.loadMutations).toBeDefined();
       const [post2, createPostMutation] = await optimisticAdapter.createPost({
         title: "Foo",
+        slug: faker.lorem.slug(5),
         tags: []
       });
       const [persistCratePostMutation] = await persistedAdapter.persistOptimisticMutations([