@roc-db/test-utils 0.2.0-pre.98 → 0.2.0-pre.99

package/dist/index.js

@@ -66,12 +66,20 @@ import { z as z5 } from "zod";
 // src/entities/Draft.ts
 import { Entity } from "roc-db";
 import { z as z4 } from "zod";
+
+// src/schemas/PostVersionRefSchema.ts
+import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
+var PostVersionRefSchema = refSchemaGenerator5("PostVersion");
+
+// src/entities/Draft.ts
 var Draft = new Entity("Draft", {
+  changeSet: true,
   data: z4.object({
     appliedAt: z4.string().optional()
   }),
   parents: z4.object({
-    post: PostRefSchema
+    post: PostRefSchema,
+    version: PostVersionRefSchema.optional()
   })
 });
 
@@ -91,8 +99,8 @@ import { entitySchemaGenerator as entitySchemaGenerator5 } from "roc-db";
 import { z as z6 } from "zod";
 
 // src/schemas/UserRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator5 } from "roc-db";
-var UserRefSchema = refSchemaGenerator5("User");
+import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
+var UserRefSchema = refSchemaGenerator6("User");
 
 // src/schemas/PostSchema.ts
 var PostSchema = entitySchemaGenerator5("Post", {
@@ -167,8 +175,8 @@ var PostEntity = new Entity3("Post", {
 import { z as z13 } from "zod";
 
 // src/schemas/BlockRowRefSchema.ts
-import { refSchemaGenerator as refSchemaGenerator6 } from "roc-db";
-var BlockRowRefSchema = refSchemaGenerator6("BlockRow");
+import { refSchemaGenerator as refSchemaGenerator7 } from "roc-db";
+var BlockRowRefSchema = refSchemaGenerator7("BlockRow");
 
 // src/schemas/BlockRefSchema.ts
 var BlockRefSchema = z13.union([
@@ -215,6 +223,7 @@ var OrgSettingsEntity = new Entity6("OrgSettings", {
 import { Entity as Entity7 } from "roc-db";
 import { z as z17 } from "zod";
 var PostVersion = new Entity7("PostVersion", {
+  version: true,
   data: z17.object({
     version: z17.number(),
     snapshot: z17.array(z17.any())
@@ -433,29 +442,42 @@ var deletePost = writeOperation14("deletePost", PostRefSchema, (txn) => {
   return Query14(() => txn.deleteEntity(ref, true));
 });
 
-// src/operations/moveBlocks.ts
+// src/operations/duplicateDraft.ts
 import { Query as Query15, QueryChain as QueryChain6, writeOperation as writeOperation15 } from "roc-db";
 import { z as z30 } from "zod";
-var PayloadSchema3 = z30.object({
-  refs: z30.array(z30.union([BlockParagraphRefSchema, BlockRowRefSchema])),
-  targetPosition: z30.number().min(0)
+var duplicateDraft = writeOperation15("duplicateDraft", z30.object({ sourceRef: DraftRefSchema, postRef: PostRefSchema }).strict(), (txn) => {
+  const newDraftRef = txn.createRef("Draft");
+  const { sourceRef, postRef } = txn.payload;
+  return QueryChain6(Query15(() => txn.createEntity(newDraftRef, { parents: { post: postRef } })), Query15(() => txn.duplicateChangeSetMutations(sourceRef, newDraftRef)), Query15((dup) => ({
+    draftRef: newDraftRef,
+    mutations: dup.mutations,
+    refMap: dup.refMap
+  })));
+});
+
+// src/operations/moveBlocks.ts
+import { Query as Query16, QueryChain as QueryChain7, writeOperation as writeOperation16 } from "roc-db";
+import { z as z31 } from "zod";
+var PayloadSchema3 = z31.object({
+  refs: z31.array(z31.union([BlockParagraphRefSchema, BlockRowRefSchema])),
+  targetPosition: z31.number().min(0)
 }).strict();
-var moveBlocks = writeOperation15("moveBlocks", PayloadSchema3, (txn) => {
+var moveBlocks = writeOperation16("moveBlocks", PayloadSchema3, (txn) => {
   const { refs } = txn.payload;
-  return QueryChain6(Query15(() => txn.batchReadEntities(refs)), Query15((items) => {
+  return QueryChain7(Query16(() => txn.batchReadEntities(refs)), Query16((items) => {
     return "todo";
   }));
 });
 
 // src/operations/pageBlocks.ts
-import { Query as Query16, readOperation } from "roc-db";
-import { z as z31 } from "zod";
-var pageBlocks = readOperation("pageBlocks", z31.object({
-  size: z31.number().default(100),
-  parentRef: z31.string().optional()
+import { Query as Query17, readOperation } from "roc-db";
+import { z as z32 } from "zod";
+var pageBlocks = readOperation("pageBlocks", z32.object({
+  size: z32.number().default(100),
+  parentRef: z32.string().optional()
 }), (txn) => {
   const { size, parentRef } = txn.payload;
-  return Query16(() => txn.pageEntities({
+  return Query17(() => txn.pageEntities({
     entities: ["BlockImage", "BlockParagraph"],
     size,
     childrenOf: parentRef ? [parentRef] : []
@@ -463,50 +485,50 @@ var pageBlocks = readOperation("pageBlocks", z31.object({
 });
 
 // src/operations/pageEmptyEntitiesArray.ts
-import { Query as Query17, readOperation as readOperation2 } from "roc-db";
-import { z as z32 } from "zod";
-var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z32.object({ size: z32.number().default(100) }), (txn) => {
+import { Query as Query18, readOperation as readOperation2 } from "roc-db";
+import { z as z33 } from "zod";
+var pageEmptyEntitiesArray = readOperation2("pageEmptyEntitiesArray", z33.object({ size: z33.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query17(() => txn.pageEntities({ entities: [], size }));
+  return Query18(() => txn.pageEntities({ entities: [], size }));
 });
 
 // src/operations/pagePosts.ts
-import { Query as Query18, readOperation as readOperation3 } from "roc-db";
-import { z as z33 } from "zod";
-var pagePosts = readOperation3("pagePosts", z33.object({ size: z33.number().default(100) }).default({}), (txn) => {
+import { Query as Query19, readOperation as readOperation3 } from "roc-db";
+import { z as z34 } from "zod";
+var pagePosts = readOperation3("pagePosts", z34.object({ size: z34.number().default(100) }).default({}), (txn) => {
   const { size } = txn.payload;
-  return Query18(() => txn.pageEntities({ entities: ["Post"], size }));
+  return Query19(() => txn.pageEntities({ entities: ["Post"], size }));
 });
 
 // src/operations/pageSplat.ts
-import { Query as Query19, readOperation as readOperation4 } from "roc-db";
-import { z as z34 } from "zod";
-var pageSplat = readOperation4("pageSplat", z34.object({ size: z34.number().default(100) }), (txn) => {
+import { Query as Query20, readOperation as readOperation4 } from "roc-db";
+import { z as z35 } from "zod";
+var pageSplat = readOperation4("pageSplat", z35.object({ size: z35.number().default(100) }), (txn) => {
   const { size } = txn.payload;
-  return Query19(() => txn.pageEntities({ entities: "*", size }));
+  return Query20(() => txn.pageEntities({ entities: "*", size }));
 });
 
 // src/operations/pagePostsByTag.ts
-import { Query as Query20, readOperation as readOperation5 } from "roc-db";
-import { z as z35 } from "zod";
-var pagePostsByTag = readOperation5("pagePostsByTag", z35.string(), (txn) => {
+import { Query as Query21, readOperation as readOperation5 } from "roc-db";
+import { z as z36 } from "zod";
+var pagePostsByTag = readOperation5("pagePostsByTag", z36.string(), (txn) => {
   const tag = txn.payload;
-  return Query20(() => txn.pageEntitiesByIndex("Post", "tags", tag));
+  return Query21(() => txn.pageEntitiesByIndex("Post", "tags", tag));
 });
 
 // src/operations/readEntity.ts
-import { NotFoundError, Query as Query21, QueryChain as QueryChain7, readOperation as readOperation6 } from "roc-db";
-import { z as z36 } from "zod";
-var readEntity = readOperation6("readEntity", z36.string(), (txn) => {
+import { NotFoundError, Query as Query22, QueryChain as QueryChain8, readOperation as readOperation6 } from "roc-db";
+import { z as z37 } from "zod";
+var readEntity = readOperation6("readEntity", z37.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain7(Query21(() => txn.readEntity(ref)), Query21((entity) => {
+  return QueryChain8(Query22(() => txn.readEntity(ref)), Query22((entity) => {
     if (!entity) {
       throw new NotFoundError(ref);
     }
     return entity;
   }));
 }, {
-  outputSchema: z36.union([
+  outputSchema: z37.union([
     PostSchema,
     BlockImageSchema,
     BlockParagraphSchema
@@ -514,11 +536,11 @@ var readEntity = readOperation6("readEntity", z36.string(), (txn) => {
 });
 
 // src/operations/readMutation.ts
-import { NotFoundError as NotFoundError2, Query as Query22, QueryChain as QueryChain8, readOperation as readOperation7 } from "roc-db";
-import { z as z37 } from "zod";
-var readMutation = readOperation7("readMutation", z37.string(), (txn) => {
+import { NotFoundError as NotFoundError2, Query as Query23, QueryChain as QueryChain9, readOperation as readOperation7 } from "roc-db";
+import { z as z38 } from "zod";
+var readMutation = readOperation7("readMutation", z38.string(), (txn) => {
   const ref = txn.payload;
-  return QueryChain8(Query22(() => txn.readMutation(ref)), Query22((entity) => {
+  return QueryChain9(Query23(() => txn.readMutation(ref)), Query23((entity) => {
     if (!entity) {
       throw new NotFoundError2(ref);
     }
@@ -527,57 +549,57 @@ var readMutation = readOperation7("readMutation", z37.string(), (txn) => {
 });
 
 // src/operations/readOrgSettings.ts
-import { Query as Query23, readOperation as readOperation8 } from "roc-db";
-import { z as z38 } from "zod";
-var readOrgSettings = readOperation8("readOrgSettings", z38.object({}).optional(), (txn) => Query23(() => txn.readEntity("OrgSettings", true)));
+import { Query as Query24, readOperation as readOperation8 } from "roc-db";
+import { z as z39 } from "zod";
+var readOrgSettings = readOperation8("readOrgSettings", z39.object({}).optional(), (txn) => Query24(() => txn.readEntity("OrgSettings", true)));
 
 // src/operations/readPost.ts
-import { Query as Query24, readOperation as readOperation9 } from "roc-db";
+import { Query as Query25, readOperation as readOperation9 } from "roc-db";
 var readPost = readOperation9("readPost", PostRefSchema, (txn) => {
   const ref = txn.payload;
-  return Query24(() => txn.readEntity(ref, true));
+  return Query25(() => txn.readEntity(ref, true));
 }, { outputSchema: PostSchema });
 
 // src/operations/readPostBySlug.ts
-import { Query as Query25, readOperation as readOperation10 } from "roc-db";
-import { z as z39 } from "zod";
-var readPostBySlug = readOperation10("readPostBySlug", z39.string(), (txn) => {
+import { Query as Query26, readOperation as readOperation10 } from "roc-db";
+import { z as z40 } from "zod";
+var readPostBySlug = readOperation10("readPostBySlug", z40.string(), (txn) => {
   const slug = txn.payload;
-  return Query25(() => txn.readEntityByUniqueField("Post", "slug", slug));
+  return Query26(() => txn.readEntityByUniqueField("Post", "slug", slug));
 }, { outputSchema: PostSchema });
 
 // src/operations/testTransactionalEdits.ts
 import { expect } from "bun:test";
-import { Query as Query26, QueryChain as QueryChain9, writeOperation as writeOperation16 } from "roc-db";
-import { z as z40 } from "zod";
+import { Query as Query27, QueryChain as QueryChain10, writeOperation as writeOperation17 } from "roc-db";
+import { z as z41 } from "zod";
 var TestCreatePatchDeleteInSameTransaction = (txn, title) => {
   const postRef = txn.createRef("Post");
-  return QueryChain9(Query26(() => txn.createEntity(postRef, {
+  return QueryChain10(Query27(() => txn.createEntity(postRef, {
     data: { title, tags: [] },
     children: { blocks: [] }
-  })), Query26(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query26((post) => {
+  })), Query27(() => txn.patchEntity(postRef, { data: { foo: "bar" } })), Query27((post) => {
     expect(post.data.title).toBe(title);
     expect(post.data.foo).toBe("bar");
-  }), Query26(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query26((post) => {
+  }), Query27(() => txn.patchEntity(postRef, { data: { foo: null, bar: "foo" } })), Query27((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");
-  }), Query26((post) => txn.deleteEntity(postRef)), Query26((res) => {
+  }), Query27((post) => txn.deleteEntity(postRef)), Query27((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(0);
   }));
 };
 var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
-  return QueryChain9(Query26(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query26((post) => {
+  return QueryChain10(Query27(() => txn.patchEntity(ref, { data: { foo: "bar" } })), Query27((post) => {
     expect(post.data.foo).toBe("bar");
-  }), Query26(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query26((post) => {
+  }), Query27(() => txn.patchEntity(ref, { data: { foo: null, bar: "foo" } })), Query27((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");
-  }), Query26((post) => txn.deleteEntity(ref)), Query26((res) => {
+  }), Query27((post) => txn.deleteEntity(ref)), Query27((res) => {
     expect(res).toBe(1);
     expect(txn.log).toHaveLength(1);
     expect(txn.log.get(ref)[0]).toBe("delete");
@@ -585,14 +607,14 @@ var TestUpdateAndDeleteInSameTransaction = (txn, ref) => {
 };
 var TestCreateOnExistingRef = (txn) => {
   const ref = txn.createRef("Post");
-  return QueryChain9(Query26(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query26(() => txn.createEntity(ref, { data: { foo: "bar" } })));
+  return QueryChain10(Query27(() => txn.createEntity(ref, { data: { foo: "bar" } })), Query27(() => txn.createEntity(ref, { data: { foo: "bar" } })));
 };
-var PayloadSchema4 = z40.object({
-  name: z40.string().optional(),
+var PayloadSchema4 = z41.object({
+  name: z41.string().optional(),
   post1ref: PostRefSchema.optional(),
   post2ref: PostRefSchema.optional()
 }).strict();
-var testTransactionalEdits = writeOperation16("testTransactionalEdits", PayloadSchema4, (txn) => {
+var testTransactionalEdits = writeOperation17("testTransactionalEdits", PayloadSchema4, (txn) => {
   const { name, post1ref, post2ref } = txn.payload;
   if (name)
     return TestCreatePatchDeleteInSameTransaction(txn, name);
@@ -603,38 +625,38 @@ var testTransactionalEdits = writeOperation16("testTransactionalEdits", PayloadS
 }, {});
 
 // src/operations/updateBlockParagraph.ts
-import { Query as Query27, writeOperation as writeOperation17 } from "roc-db";
-import { z as z41 } from "zod";
-var updateBlockParagraph = writeOperation17("updateBlockParagraph", z41.object({
+import { Query as Query28, writeOperation as writeOperation18 } from "roc-db";
+import { z as z42 } from "zod";
+var updateBlockParagraph = writeOperation18("updateBlockParagraph", z42.object({
   ref: BlockParagraphRefSchema,
-  content: z41.string()
+  content: z42.string()
 }), (txn) => {
   const { ref, content } = txn.payload;
-  return Query27(() => txn.patchEntity(ref, {
+  return Query28(() => txn.patchEntity(ref, {
     data: { content }
   }));
 }, { outputSchema: BlockParagraphSchema });
 
 // src/operations/updateOrgSettingsName.ts
-import { Query as Query28, writeOperation as writeOperation18 } from "roc-db";
-import { z as z42 } from "zod";
-var updateOrgSettingsName = writeOperation18("updateOrgSettingsName", z42.object({ name: z42.string() }), (txn) => {
+import { Query as Query29, writeOperation as writeOperation19 } from "roc-db";
+import { z as z43 } from "zod";
+var updateOrgSettingsName = writeOperation19("updateOrgSettingsName", z43.object({ name: z43.string() }), (txn) => {
   const { name } = txn.payload;
-  return Query28(() => txn.patchEntity("OrgSettings", { data: { name } }));
+  return Query29(() => txn.patchEntity("OrgSettings", { data: { name } }));
 }, { debounce: 10 });
 
 // src/operations/updatePost.ts
-import { Query as Query29, writeOperation as writeOperation19 } from "roc-db";
-import { z as z43 } from "zod";
-var PayloadSchema5 = z43.object({
+import { Query as Query30, writeOperation as writeOperation20 } from "roc-db";
+import { z as z44 } from "zod";
+var PayloadSchema5 = z44.object({
   ref: PostRefSchema,
-  title: z43.string().optional(),
-  tags: z43.array(z43.string()).optional().default([]),
+  title: z44.string().optional(),
+  tags: z44.array(z44.string()).optional().default([]),
   authorRef: UserRefSchema.optional()
 });
-var updatePost = writeOperation19("updatePost", PayloadSchema5, (txn) => {
+var updatePost = writeOperation20("updatePost", PayloadSchema5, (txn) => {
   const { ref, authorRef, ...data } = txn.payload;
-  return Query29(() => txn.updateEntity(ref, {
+  return Query30(() => txn.updateEntity(ref, {
     data,
     parents: { author: authorRef },
     children: { blocks: [] }
@@ -642,43 +664,43 @@ var updatePost = writeOperation19("updatePost", PayloadSchema5, (txn) => {
 }, { outputSchema: PostSchema });
 
 // src/operations/updatePostDescription.ts
-import { Query as Query30, writeOperation as writeOperation20 } from "roc-db";
-import { z as z44 } from "zod";
-var updatePostDescription = writeOperation20("updatePostDescription", z44.object({ ref: PostRefSchema, description: z44.string() }), (txn) => {
+import { Query as Query31, writeOperation as writeOperation21 } from "roc-db";
+import { z as z45 } from "zod";
+var updatePostDescription = writeOperation21("updatePostDescription", z45.object({ ref: PostRefSchema, description: z45.string() }), (txn) => {
   const { ref, description } = txn.payload;
-  return Query30(() => txn.patchEntity(ref, { data: { description } }));
+  return Query31(() => txn.patchEntity(ref, { data: { description } }));
 }, { debounce: 10, changeSetOnly: true, outputSchema: PostSchema });
 
 // src/operations/updatePostSlug.ts
-import { Query as Query31, writeOperation as writeOperation21 } from "roc-db";
-import { z as z45 } from "zod";
-var updatePostSlug = writeOperation21("updatePostSlug", z45.object({ ref: PostRefSchema, slug: z45.string() }), (txn) => {
+import { Query as Query32, writeOperation as writeOperation22 } from "roc-db";
+import { z as z46 } from "zod";
+var updatePostSlug = writeOperation22("updatePostSlug", z46.object({ ref: PostRefSchema, slug: z46.string() }), (txn) => {
   const { ref, slug } = txn.payload;
-  return Query31(() => txn.patchEntity(ref, { data: { slug } }));
+  return Query32(() => txn.patchEntity(ref, { data: { slug } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTags.ts
-import { Query as Query32, writeOperation as writeOperation22 } from "roc-db";
-import { z as z46 } from "zod";
-var updatePostTags = writeOperation22("updatePostTags", z46.object({ ref: PostRefSchema, tags: z46.array(z46.string()) }), (txn) => {
+import { Query as Query33, writeOperation as writeOperation23 } from "roc-db";
+import { z as z47 } from "zod";
+var updatePostTags = writeOperation23("updatePostTags", z47.object({ ref: PostRefSchema, tags: z47.array(z47.string()) }), (txn) => {
   const { ref, tags } = txn.payload;
-  return Query32(() => txn.patchEntity(ref, { data: { tags } }));
+  return Query33(() => txn.patchEntity(ref, { data: { tags } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/updatePostTitle.ts
-import { Query as Query33, writeOperation as writeOperation23 } from "roc-db";
-import { z as z47 } from "zod";
-var updatePostTitle = writeOperation23("updatePostTitle", z47.object({ ref: PostRefSchema, title: z47.string() }), (txn) => {
+import { Query as Query34, writeOperation as writeOperation24 } from "roc-db";
+import { z as z48 } from "zod";
+var updatePostTitle = writeOperation24("updatePostTitle", z48.object({ ref: PostRefSchema, title: z48.string() }), (txn) => {
   const { ref, title } = txn.payload;
-  return Query33(() => txn.patchEntity(ref, { data: { title } }));
+  return Query34(() => txn.patchEntity(ref, { data: { title } }));
 }, { debounce: 10, outputSchema: PostSchema });
 
 // src/operations/crudBySlug.ts
-import { Query as Query34, QueryChain as QueryChain10, writeOperation as writeOperation24 } from "roc-db";
-import { z as z48 } from "zod";
-var crudBySlug = writeOperation24("crudBySlug", z48.object({ slug: z48.string(), newSlug: z48.string() }), (txn) => {
+import { Query as Query35, QueryChain as QueryChain11, writeOperation as writeOperation25 } from "roc-db";
+import { z as z49 } from "zod";
+var crudBySlug = writeOperation25("crudBySlug", z49.object({ slug: z49.string(), newSlug: z49.string() }), (txn) => {
   const { slug, newSlug } = txn.payload;
-  return QueryChain10(Query34(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query34((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query34(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query34((post) => txn.deleteEntity(post.ref)), Query34(() => {
+  return QueryChain11(Query35(() => txn.readEntityByUniqueField("Post", "slug", slug)), Query35((post) => txn.patchEntity(post.ref, { data: { slug: newSlug } })), Query35(() => txn.readEntityByUniqueField("Post", "slug", newSlug)), Query35((post) => txn.deleteEntity(post.ref)), Query35(() => {
     return [
       txn.readEntityByUniqueField("Post", "slug", slug, false),
       txn.readEntityByUniqueField("Post", "slug", newSlug, false)
@@ -703,6 +725,7 @@ var operations = [
   deleteDraft,
   deleteOrgSettings,
   deletePost,
+  duplicateDraft,
   readPostBySlug,
   moveBlocks,
   pagePostsByTag,
@@ -732,7 +755,7 @@ import {
   NotFoundError as NotFoundError3,
   Snowflake
 } from "roc-db";
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 import { faker } from "@faker-js/faker";
 var snowflake = new Snowflake(10, 10);
 var prepareChangeSetTest = async (adapter, adapter2) => {
@@ -1056,7 +1079,7 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
     test("constructor rejects singleton + uniqueDataKeys", () => {
       expect2(() => new Entity9("Bad", {
         singleton: true,
-        data: z49.object({ name: z49.string() }),
+        data: z50.object({ name: z50.string() }),
         uniqueDataKeys: ["name"]
       })).toThrow(/singleton/);
     });
@@ -1196,6 +1219,40 @@ var testAdapterImplementation = async (adapterConstructor, generateArgs) => {
       const changeSetAdapter2 = adapter1.changeSet("Draft/123");
       expect2(() => changeSetAdapter2.createPost({ title: "Title 1" })).toThrow(BadRequestError);
     });
+    test("duplicateDraft (txn.duplicateChangeSetMutations) produces an independent copy with remapped refs", async () => {
+      const [post2] = await adapter1.createPost({
+        title: "Title 1",
+        slug: faker.lorem.slug(5)
+      });
+      const [sourceDraft] = await adapter1.createDraft({
+        postRef: post2.ref
+      });
+      const sourceCs = adapter1.changeSet(sourceDraft.ref);
+      const [{ block: row }] = await sourceCs.createBlockRow({
+        parentRef: post2.ref
+      });
+      const [{ block: para }] = await sourceCs.createBlockParagraph({
+        parentRef: row.ref,
+        content: "Hello"
+      });
+      const [{ draftRef: newDraftRef, mutations, refMap }] = await adapter1.duplicateDraft({
+        sourceRef: sourceDraft.ref,
+        postRef: post2.ref
+      });
+      expect2(mutations).toHaveLength(2);
+      const newRow = refMap.get(row.ref);
+      const newPara = refMap.get(para.ref);
+      expect2(newRow).toBeDefined();
+      expect2(newPara).toBeDefined();
+      expect2(newRow).not.toBe(row.ref);
+      expect2(newPara).not.toBe(para.ref);
+      expect2([...refMap.values()]).not.toContain(row.ref);
+      expect2([...refMap.values()]).not.toContain(para.ref);
+      const targetCs = adapter1.changeSet(newDraftRef);
+      expect2((await targetCs.readEntity(newRow)).ref).toBe(newRow);
+      expect2((await targetCs.readEntity(newPara)).parents.parent).toBe(newRow);
+      expect2((await sourceCs.readEntity(para.ref)).parents.parent).toBe(row.ref);
+    });
     test("deleteBlocks (patch running 2 times removing on array element every time)", async () => {
       const [post2, createPostMutation] = await adapter1.createPost({
         title: "Title 1",

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

@@ -4,4 +4,5 @@ export declare const Draft: Entity<"Draft", z.ZodObject<{
     appliedAt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
     post: z.ZodTemplateLiteral<`Post/${number}`>;
+    version: z.ZodOptional<z.ZodTemplateLiteral<`PostVersion/${number}`>>;
 }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, false>;

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

@@ -2,6 +2,7 @@ export declare const entities: (import("roc-db").Entity<"Draft", import("zod").Z
     appliedAt: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     post: import("zod").ZodTemplateLiteral<`Post/${number}`>;
+    version: import("zod").ZodOptional<import("zod").ZodTemplateLiteral<`PostVersion/${number}`>>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, false> | import("roc-db").Entity<"BlockImage", import("zod").ZodObject<{
     url: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+/**
+ * Canonical consumer usage of the `txn.duplicateChangeSetMutations` primitive:
+ * create the new draft and copy the source draft's pending mutations into it,
+ * all in one transaction.
+ */
+export declare const duplicateDraft: import("roc-db").WriteOperation<"duplicateDraft", z.ZodObject<{
+    sourceRef: z.ZodType<`Draft/${number}`, `Draft/${number}`, z.core.$ZodTypeInternals<`Draft/${number}`, `Draft/${number}`>>;
+    postRef: z.ZodTemplateLiteral<`Post/${number}`>;
+}, z.core.$strict>>;

package/dist/types/schemas/PostVersionRefSchema.d.ts

@@ -0,0 +1 @@
+export declare const PostVersionRefSchema: import("zod").ZodTemplateLiteral<`PostVersion/${number}`>;

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

@@ -0,0 +1,11 @@
+import type { ZodSchema } from "zod";
+interface CustomMatchers {
+    toMatchZodSchema(schema: ZodSchema): any;
+}
+declare module "bun:test" {
+    interface Matchers<T> extends CustomMatchers {
+    }
+    interface AsymmetricMatchers extends CustomMatchers {
+    }
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/test-utils",
-    "version": "0.2.0-pre.98",
+    "version": "0.2.0-pre.99",
     "type": "module",
     "exports": {
         ".": {
@@ -17,7 +17,7 @@
     ],
     "sideEffects": false,
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.98",
+        "roc-db": ">=0.2.0-pre.98 <1.0.0",
         "zod": ">=4.0.0"
     },
     "keywords": [],
@@ -26,5 +26,9 @@
         "type": "git",
         "url": "git+https://github.com/eigilsagafos/roc-db.git"
     },
-    "license": "MIT"
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
 }