feat: 🎸 allow new block creation through block.upd

Author: streamich

src/__demos__/json-crdt-server/routes/block/methods/upd.ts

@@ -14,6 +14,10 @@ export const upd =
         title: 'Patches',
         description: 'The patches to apply to the document.',
       }),
+      t.propOpt('create', t.bool).options({
+        title: 'Create if not exists',
+        description: 'If true, creates a new document if it does not exist.',
+      }),
     );
 
     const Response = t.Object(
@@ -29,8 +33,8 @@ export const upd =
       description: 'Applies patches to an existing document and returns the latest concurrent changes.',
     });
 
-    return r.prop('block.upd', Func, async ({id, patches}) => {
-      const res = await services.blocks.edit(id, patches);
+    return r.prop('block.upd', Func, async ({id, patches, create}) => {
+      const res = await services.blocks.edit(id, patches, !!create);
       const patchesReturn: ResolveType<typeof BlockPatchPartialReturnRef>[] = res.patches.map((patch) => ({
         ts: patch.created,
       }));

src/__demos__/json-crdt-server/services/blocks/BlocksServices.ts

@@ -119,7 +119,13 @@ export class BlocksServices {
     return {patches};
   }
 
-  public async edit(id: string, patches: Pick<StorePatch, 'blob'>[]) {
+  public async edit(id: string, patches: Pick<StorePatch, 'blob'>[], createIfNotExists: boolean) {
+    if (createIfNotExists) {
+      const exists = await this.store.exists(id);
+      if (!exists) {
+        return await this.create(id, patches);
+      }
+    }
     this.maybeGc();
     if (!Array.isArray(patches)) throw RpcError.validation('patches must be an array');
     if (!patches.length) throw RpcError.validation('patches must not be empty');

src/__demos__/json-crdt-server/services/blocks/MemoryStore.ts

@@ -1,5 +1,6 @@
 import {Model, Patch} from 'json-joy/lib/json-crdt';
 import type * as types from './types';
+import {RpcError} from '../../../../common/rpc/caller';
 
 const tick = new Promise((resolve) => setImmediate(resolve));
 
@@ -14,6 +15,11 @@ export class MemoryStore implements types.Store {
     return {snapshot};
   }
 
+  public async exists(id: string): Promise<boolean> {
+    await tick;
+    return this.snapshots.has(id);
+  }
+
   public async seq(id: string): Promise<number | undefined> {
     await tick;
     return this.snapshots.get(id)?.seq;
@@ -32,7 +38,7 @@ export class MemoryStore implements types.Store {
     if (!Array.isArray(patches) || !patches.length) throw new Error('NO_PATCHES');
     const snapshot = this.snapshots.get(id);
     const existingPatches = this.patches.get(id);
-    if (!snapshot || !existingPatches) throw new Error('BLOCK_NOT_FOUND');
+    if (!snapshot || !existingPatches) throw RpcError.notFound();
     let seq = patches[0].seq;
     const diff = seq - snapshot.seq - 1;
     if (snapshot.seq + 1 < seq) throw new Error('PATCH_SEQ_TOO_HIGH');

src/__tests__/json-crdt-server/block.ts

@@ -114,6 +114,60 @@ export const runBlockTests = (_setup: ApiTestSetup, params: {staticOnly?: true}
     });
 
     describe('block.upd', () => {
+      test('can create a new block', async () => {
+        const {call, stop} = await setup();
+        const id = getId();
+        const model = Model.withLogicalClock();
+        model.api.root({
+          text: 'Hell',
+        });
+        const patch1 = model.api.flush();
+        const result = await call('block.upd', {
+          create: true,
+          id,
+          patches: [
+            {
+              blob: patch1.toBinary(),
+            },
+          ],
+        });
+        expect(result).toMatchObject({
+          patches: [
+            {
+              ts: expect.any(Number),
+            },
+          ],
+        });
+        stop();
+      });
+
+      test('throws BLOCK_NOT_FOUND when "create" flag missing', async () => {
+        const {call, stop} = await setup();
+        const id = getId();
+        const model = Model.withLogicalClock();
+        model.api.root({
+          text: 'Hell',
+        });
+        const patch1 = model.api.flush();
+        try {
+          const result = await call('block.upd', {
+            create: false,
+            id,
+            patches: [
+              {
+                blob: patch1.toBinary(),
+              },
+            ],
+          });
+          throw 'not this error';
+        } catch (error) {
+          expect(error).toMatchObject({
+            code: 'NOT_FOUND',
+          });
+        }
+        stop();
+      });
+
       test('can edit a document sequentially', async () => {
         const {call, stop} = await setup();
         const id = getId();

src/common/rpc/caller/error/RpcError.ts

@@ -57,6 +57,10 @@ export class RpcError extends Error implements IRpcError {
     return RpcError.fromCode(RpcErrorCodes.BAD_REQUEST, message);
   }
 
+  public static notFound(message = 'Not Found'): RpcError {
+    return RpcError.fromCode(RpcErrorCodes.NOT_FOUND, message);
+  }
+
   public static validation(message: string, meta?: unknown): RpcError {
     return RpcError.fromCode(RpcErrorCodes.BAD_REQUEST, message, meta);
   }