@roc-db/test-utils 0.1.0 → 0.2.0-pre.10

package/dist/index.js

@@ -179,7 +179,6 @@ var createBlockRow = writeOperation3(CreateBlockRowMutationSchema, BlockParagrap
   const ref = txn.createRef("BlockRow");
   const { parentRef } = txn.payload;
   return QueryChain2(Query3(() => txn.readEntity(parentRef)), Query3((parent) => {
-    console.log("asdfasfd", parent);
     return txn.patchEntity(parentRef, {
       children: { blocks: [...parent.children.blocks, ref] }
     });
@@ -344,7 +343,7 @@ var operations = [
 ];
 // src/testAdapterImplementation.ts
 import { beforeAll, describe, expect, test } from "bun:test";
-import { NotFoundError as NotFoundError2 } from "roc-db";
+import { BadRequestError, NotFoundError as NotFoundError2 } from "roc-db";
 var prepareChangeSetTest = async (adapter) => {
   const [post] = await adapter.createPost({
     title: "Title 1",
@@ -378,54 +377,123 @@ var testAdapterImplementation = (adapterConstructor, engineArgsAdapter1 = {}, en
   return async () => {
     const adapter1 = adapterConstructor({ operations, entities, ...engineArgsAdapter1 });
     const adapter2 = adapterConstructor({ operations, entities, ...engineArgsAdapter2 });
+    describe("Post CRUD", async () => {
+      let postRef;
+      let post;
+      let createPostMutation;
+      beforeAll(async () => {
+        const createPostRes = await adapter1.createPost({
+          title: "Title 1",
+          slug: "title-1",
+          tags: ["Foo", "Bar"]
+        });
+        post = createPostRes[0];
+        postRef = createPostRes[0].ref;
+        createPostMutation = createPostRes[1];
+      });
+      test("create (createEntity function)", async () => {
+        expect(post).toMatchZodSchema(PostSchema);
+        expect(post.data.title).toBe("Title 1");
+        expect(post.data.tags).toStrictEqual(["Foo", "Bar"]);
+      });
+      test("read (readEntity function)", async () => {
+        const readPostRes = await adapter1.readPost(postRef);
+        expect(readPostRes.data.title).toStrictEqual("Title 1");
+        expect(readPostRes.data.tags).toStrictEqual(["Foo", "Bar"]);
+        expect(readPostRes).toMatchZodSchema(PostSchema);
+      });
+      test("update (updateEntity function)", async () => {
+        const [post2] = await adapter1.updatePost({
+          ref: postRef,
+          title: "Title 2",
+          tags: ["Foo"]
+        });
+        expect(post2.data.tags).toStrictEqual(["Foo"]);
+        expect(post2.data.title).toBe("Title 2");
+        expect(post2).toMatchZodSchema(PostSchema);
+      });
+      test("updateTitle (patchEntity function + debounce)", async () => {
+        const updatePostTitleRes1 = await adapter1.updatePostTitle({
+          ref: postRef,
+          title: "Title 3"
+        });
+        expect(updatePostTitleRes1[0]).toMatchZodSchema(PostSchema);
+        const updatePostTitleRes2 = await adapter1.updatePostTitle({
+          ref: postRef,
+          title: "Title 4"
+        });
+        expect(updatePostTitleRes2[0]).toMatchZodSchema(PostSchema);
+        expect(updatePostTitleRes2[1].ref).toBe(updatePostTitleRes1[1].ref);
+        expect(updatePostTitleRes2[1].timestamp >= updatePostTitleRes1[1].timestamp).toBeTrue();
+      });
+      test("delete (deleteEntity function)", async () => {
+        const [count, mutation] = await adapter1.deletePost(postRef);
+        expect(count).toBe(1);
+        expect(mutation.log).toStrictEqual([[postRef, "delete", null]]);
+      });
+      test("sync mutation", async () => {
+        const res = await adapter2.syncOptimisticMutation(createPostMutation);
+        expect(res[0]).toStrictEqual(post);
+        expect(res[1]).toStrictEqual(createPostMutation);
+        expect(() => adapter2.syncOptimisticMutation(createPostMutation)).toThrowError(BadRequestError);
+      });
+    });
     describe("changeSet", async () => {
-      let postRef, draftRef, changeSetAdapter, block, post, blockRow, blockParagraph2;
+      let postRef, draftRef, changeSetAdapter, blockParagraph1, post, blockRow, blockParagraph2;
       beforeAll(async () => {
-        const res = await prepareChangeSetTest(adapter1);
-        postRef = res.postRef;
-        draftRef = res.draftRef;
-        changeSetAdapter = res.changeSetAdapter;
-        block = res.blockParagraph1;
-        blockRow = res.blockRow;
-        blockParagraph2 = res.blockParagraph2;
-        post = res.post;
+        ({
+          postRef,
+          draftRef,
+          changeSetAdapter,
+          blockParagraph1,
+          post,
+          blockRow,
+          blockParagraph2
+        } = await prepareChangeSetTest(adapter1));
       });
       test("create (createEntity function w/changeSetRef)", async () => {
-        expect(block).toMatchZodSchema(BlockParagraphSchema);
+        expect(blockParagraph1).toMatchZodSchema(BlockParagraphSchema);
         expect(post).toMatchZodSchema(PostSchema);
       });
       test("read (readEntity function w/changeSetRef)", async () => {
-        const read = await changeSetAdapter.readEntity(block.ref);
+        const read = await changeSetAdapter.readEntity(blockParagraph1.ref);
         expect(read).toMatchZodSchema(BlockParagraphSchema);
       });
+      test("update (patchEntity function w/changeSetRef)", async () => {
+        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
+          ref: blockParagraph1.ref,
+          content: "Hello, world!"
+        });
+        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+      });
       test("delete (with cascade delete)", async () => {
         const [count, mutation] = await changeSetAdapter.deletePost(postRef);
         expect(count).toBe(4);
         expect(mutation.log).toStrictEqual([
-          [block.ref, "delete", draftRef],
+          [blockParagraph1.ref, "delete", draftRef],
           [blockRow.ref, "delete", draftRef],
           [blockParagraph2.ref, "delete", draftRef],
           [postRef, "delete", draftRef]
         ]);
+        await expect(() => changeSetAdapter.readEntity(blockParagraph1.ref)).toThrow(NotFoundError2);
+        await expect(() => changeSetAdapter.updateBlockParagraph({
+          ref: blockParagraph1.ref,
+          content: "Foo"
+        })).toThrow(NotFoundError2);
       });
-      test("update (patchEntity function w/changeSetRef)", async () => {
-        const [updatedBlock] = await changeSetAdapter.updateBlockParagraph({
-          ref: block.ref,
-          content: "Hello, world!"
+      test("pageMutations", async () => {
+        const res = await changeSetAdapter.pageMutations({
+          changeSetRef: draftRef
         });
-        expect(updatedBlock).toMatchZodSchema(BlockParagraphSchema);
+        expect(res.length).toBeGreaterThan(0);
+        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
       });
-      test.skip("delete (deleteEntity function w/changeSetRef)", async () => {
-        const [updatedBlock, deleteMutation] = await changeSetAdapter.deleteBlock(block.ref);
-        expect(deleteMutation.log).toStrictEqual([
-          [postRef, "update", draftRef],
-          [block.ref, "delete", draftRef]
-        ]);
-        expect(() => changeSetAdapter.readEntity(block.ref)).toThrow(NotFoundError2);
-        expect(() => changeSetAdapter.updateBlockParagraph({
-          ref: block.ref,
-          content: "Foo"
-        })).toThrow(NotFoundError2);
+      test("pageMutations2", async () => {
+        const res = await changeSetAdapter.pageMutations({
+          changeSetRef: draftRef
+        });
+        expect(res.length).toBeGreaterThan(0);
+        expect(res.every((m) => m.changeSetRef === draftRef)).toBeTrue();
       });
     });
   };

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

@@ -30,3 +30,4 @@ export declare const BlockParagraphSchema: z.ZodObject<z.objectUtil.extendShape<
 }, {
     [x: string]: any;
 }>;
+export type BlockParagraph = z.infer<typeof BlockParagraphSchema>;

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const BlockRefSchema: z.ZodUnion<[z.ZodType<`BlockParagraph/${string}`, z.ZodTypeDef, `BlockParagraph/${string}`>, z.ZodType<`BlockRow/${string}`, z.ZodTypeDef, `BlockRow/${string}`>]>;

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const BlockRowSchema: z.ZodObject<z.objectUtil.extendShape<{
+    ref: z.ZodType<never, z.ZodTypeDef, never>;
+    entity: z.ZodString;
+    created: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    updated: z.ZodObject<{
+        mutationRef: z.ZodType<`Mutation/${string}`, z.ZodTypeDef, `Mutation/${string}`>;
+        timestamp: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }, {
+        mutationRef: `Mutation/${string}`;
+        timestamp: string;
+    }>;
+    data: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    parents: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    ancestors: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, z.ZodRawShape>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+export type BlockRow = z.infer<typeof BlockRowSchema>;

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

@@ -30,3 +30,4 @@ export declare const PostSchema: z.ZodObject<z.objectUtil.extendShape<{
 }, {
     [x: string]: any;
 }>;
+export type Post = z.infer<typeof PostSchema>;

package/package.json

@@ -1,30 +1,23 @@
 {
     "name": "@roc-db/test-utils",
-    "version": "0.1.0",
+    "version": "0.2.0-pre.10",
     "type": "module",
     "exports": {
-        ".": "./src/index.ts",
-        "./setup": "./src/setup/index.ts"
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/types/index.d.ts"
+        },
+        "./setup": {
+            "import": "./dist/setup/index.js",
+            "types": "./dist/types/setup/index.d.ts"
+        }
     },
     "files": [
         "dist"
     ],
     "sideEffects": false,
-    "scripts": {
-        "build": "NODE_ENV=production bun run scripts/build.ts",
-        "build:types": "rm -rf dist/types && bun run tsc --noCheck",
-        "test": "echo"
-    },
-    "devDependencies": {
-        "@faker-js/faker": "9.6.0",
-        "@types/bun": "1.2.5",
-        "@types/sanitize-html": "2.13.0",
-        "bun": "1.2.5",
-        "expect-type": "1.2.0",
-        "roc-db": "0.1.0"
-    },
     "peerDependencies": {
-        "roc-db": "0.1.0",
+        "roc-db": "0.2.0-pre.10",
         "zod": "3.24.2"
     },
     "keywords": [],