style: 💄 run Prettier

Author: streamich

src/__demos__/json-crdt-server/__tests__/setup.ts

@@ -40,7 +40,7 @@ export const setupLevelMemory = async () => {
 };
 
 export const setupLevelClassic = async () => {
-  const kv = new ClassicLevel<string, Uint8Array>('./db', { valueEncoding: 'view' })
+  const kv = new ClassicLevel<string, Uint8Array>('./db', {valueEncoding: 'view'});
   await kv.open();
   const store = new LevelStore(<any>kv);
   return setup(store, async () => kv.close());

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

@@ -25,7 +25,7 @@ export const pull =
         description: 'Whether to create a new block if it does not exist.',
       }),
     );
-    
+
     // prettier-ignore
     const Response = t.Object(
       t.prop('batches', t.Array(BlockBatchRef)).options({

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

@@ -1,5 +1,12 @@
 import {ResolveType} from 'json-joy/lib/json-type';
-import {BlockBatchPartialRef, BlockBatchPartialReturnRef, BlockBatchRef, BlockCurRef, BlockIdRef, BlockSnapshotRef} from '../schema';
+import {
+  BlockBatchPartialRef,
+  BlockBatchPartialReturnRef,
+  BlockBatchRef,
+  BlockCurRef,
+  BlockIdRef,
+  BlockSnapshotRef,
+} from '../schema';
 import type {RouteDeps, Router, RouterBase} from '../../types';
 
 export const upd =
@@ -20,7 +27,8 @@ export const upd =
       }),
       t.propOpt('seq', BlockCurRef).options({
         title: 'Sequence Number',
-        description: 'The last client known sequence number. The server will return history starting from this sequence number.',
+        description:
+          'The last client known sequence number. The server will return history starting from this sequence number.',
       }),
     );
 
@@ -29,16 +37,20 @@ export const upd =
         title: 'Committed Batch Parts',
         description: 'Parts of committed batch which were generated on the server.',
       }),
-      t.propOpt('pull', t.Object(
-        t.prop('batches', t.Array(BlockBatchRef)).options({
-          title: 'Batches',
-          description: 'The list of batches that happened after the given sequence number.',
-        }),
-        t.propOpt('snapshot', BlockSnapshotRef).options({
-          title: 'Snapshot',
-          description: 'The snapshot of the block, to which the batches can be applied to get the current state of the block.',
-        }),
-      )),
+      t.propOpt(
+        'pull',
+        t.Object(
+          t.prop('batches', t.Array(BlockBatchRef)).options({
+            title: 'Batches',
+            description: 'The list of batches that happened after the given sequence number.',
+          }),
+          t.propOpt('snapshot', BlockSnapshotRef).options({
+            title: 'Snapshot',
+            description:
+              'The snapshot of the block, to which the batches can be applied to get the current state of the block.',
+          }),
+        ),
+      ),
     );
 
     const Func = t.Function(Request, Response).options({
@@ -61,7 +73,7 @@ export const upd =
       if (typeof seq === 'number') {
         const diff = res.batch.seq - seq;
         if (diff <= 1) {
-          pull = { batches: [] };
+          pull = {batches: []};
         } else {
           const needsSnapshot = diff > 100;
           let min: number, max: number, limit: number;
@@ -74,7 +86,7 @@ export const upd =
             max = res.batch.seq - 1;
             limit = max - min + 1;
           }
-          pull = await blocks.scan(id, needsSnapshot, min, limit) as Pull;
+          pull = (await blocks.scan(id, needsSnapshot, min, limit)) as Pull;
         }
       }
       if (pull) response.pull = pull;

src/__demos__/json-crdt-server/routes/block/schema.ts

@@ -82,23 +82,25 @@ export const BlockBatchRef = t.Ref<typeof BlockBatch>('BlockBatch');
 
 // ------------------------------------------------------------------- Snapshot
 
-export const BlockSnapshotReturn = t.Object(
-  t.prop('id', BlockIdRef).options({
-    title: 'Block ID',
-    description: 'The ID of the block.',
-  }),
-  t.prop('seq', BlockCurRef).options({
-    title: 'Snapshot Cursor',
-    description: 'The cursor of the snapshot, representing the position in the history.',
-  }),
-  t.prop('ts', t.num.options({format: 'u'})).options({
-    title: 'Snapshot Creation Time',
-    description: 'The time when the snapshot was created, in milliseconds since the Unix epoch.',
-  }),
-).options({
-  title: 'Block Snapshot Return',
-  description: "Partial snapshot returned on creation, doesn't include the blob.",
-});
+export const BlockSnapshotReturn = t
+  .Object(
+    t.prop('id', BlockIdRef).options({
+      title: 'Block ID',
+      description: 'The ID of the block.',
+    }),
+    t.prop('seq', BlockCurRef).options({
+      title: 'Snapshot Cursor',
+      description: 'The cursor of the snapshot, representing the position in the history.',
+    }),
+    t.prop('ts', t.num.options({format: 'u'})).options({
+      title: 'Snapshot Creation Time',
+      description: 'The time when the snapshot was created, in milliseconds since the Unix epoch.',
+    }),
+  )
+  .options({
+    title: 'Block Snapshot Return',
+    description: "Partial snapshot returned on creation, doesn't include the blob.",
+  });
 export const BlockSnapshotReturnRef = t.Ref<typeof BlockSnapshotReturn>('BlockSnapshotReturn');
 
 // prettier-ignore

src/__demos__/json-crdt-server/services/Services.ts

@@ -5,7 +5,7 @@ import {MemoryStore} from './blocks/store/MemoryStore';
 import {Store} from './blocks/store/types';
 
 export interface ServicesOpts {
-  store?: Store,
+  store?: Store;
   blocks?: BlocksServicesOpts;
 }
 
@@ -14,12 +14,7 @@ export class Services {
   public readonly presence: PresenceService;
   public readonly blocks: BlocksServices;
 
-  constructor(
-    {
-      store = new MemoryStore(),
-      blocks,
-    }: ServicesOpts = {}
-  ) {
+  constructor({store = new MemoryStore(), blocks}: ServicesOpts = {}) {
     this.pubsub = new PubsubService();
     this.presence = new PresenceService();
     this.blocks = new BlocksServices(this, store, blocks);

src/__demos__/json-crdt-server/services/__tests__/BlocksService.spec.ts

@@ -14,7 +14,7 @@ const setup = async (opts?: ServicesOpts) => {
     services,
     genId,
     id,
-  }
+  };
 };
 
 const setupMemoryLevel = async (opts?: Omit<ServicesOpts, 'store'>) => {
@@ -38,10 +38,10 @@ const run = (setup: Setup) => {
     expect(res).toMatchObject({
       block: {
         id: kit.id,
-      }
+      },
     });
   });
-  
+
   describe('history compaction', () => {
     test('can generate a long history', async () => {
       const kit = await setup();
@@ -51,20 +51,22 @@ const run = (setup: Setup) => {
       for (let i = 0; i < 100; i++) {
         model.api.obj([]).set({x: i});
         const patch = model.api.flush();
-        await kit.services.blocks.edit(kit.id, {
-          patches: [{blob: patch.toBinary()}],
-        }, false);
+        await kit.services.blocks.edit(
+          kit.id,
+          {
+            patches: [{blob: patch.toBinary()}],
+          },
+          false,
+        );
       }
       const {batches, snapshot} = await kit.services.blocks.scan(kit.id, true, 0, 1000);
       expect(batches.length).toBe(101);
       expect(snapshot!.seq).toBe(-1);
       const model2 = Model.fromBinary(snapshot!.blob);
-      for (const batch of batches)
-        for (const patch of batch.patches)
-          model2.applyPatch(Patch.fromBinary(patch.blob));
+      for (const batch of batches) for (const patch of batch.patches) model2.applyPatch(Patch.fromBinary(patch.blob));
       expect(model2.view()).toEqual({foo: 'bar', x: 99});
     });
-    
+
     test('can compact history', async () => {
       const kit = await setup({
         blocks: {
@@ -78,22 +80,24 @@ const run = (setup: Setup) => {
       for (let i = 0; i < 100; i++) {
         model.api.obj([]).set({x: i});
         const patch = model.api.flush();
-        await kit.services.blocks.edit(kit.id, {
-          patches: [{blob: patch.toBinary()}],
-        }, false);
+        await kit.services.blocks.edit(
+          kit.id,
+          {
+            patches: [{blob: patch.toBinary()}],
+          },
+          false,
+        );
       }
       await until(async () => (await kit.services.blocks.scan(kit.id, true, 0, 1000)).batches.length === 10);
       const {batches, snapshot} = await kit.services.blocks.scan(kit.id, true, 0, 1000);
       expect(batches.length).toBe(10);
       expect(snapshot!.seq).toBe(90);
       const model2 = Model.fromBinary(snapshot!.blob);
-      for (const batch of batches)
-        for (const patch of batch.patches)
-          model2.applyPatch(Patch.fromBinary(patch.blob));
+      for (const batch of batches) for (const patch of batch.patches) model2.applyPatch(Patch.fromBinary(patch.blob));
       expect(model2.view()).toEqual({foo: 'bar', x: 99});
     });
   });
-  
+
   describe('GC - space reclaim', () => {
     test('deletes oldest blocks when GC is called', async () => {
       const blocksToDelete = {num: 0};
@@ -132,8 +136,8 @@ const run = (setup: Setup) => {
       await tick(2);
       blocksToDelete.num = 2;
       await create(ids[4]);
-      await until(async () => await exists(ids[0]) === false);
-      await until(async () => await exists(ids[1]) === false);
+      await until(async () => (await exists(ids[0])) === false);
+      await until(async () => (await exists(ids[1])) === false);
       expect(await exists(ids[0])).toBe(false);
       expect(await exists(ids[1])).toBe(false);
       expect(await exists(ids[2])).toBe(true);
@@ -142,7 +146,7 @@ const run = (setup: Setup) => {
       await tick(2);
       blocksToDelete.num = 1;
       await create(ids[5]);
-      await until(async () => await exists(ids[2]) === false);
+      await until(async () => (await exists(ids[2])) === false);
       expect(await exists(ids[0])).toBe(false);
       expect(await exists(ids[1])).toBe(false);
       expect(await exists(ids[2])).toBe(false);

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

@@ -50,7 +50,7 @@ export class BlocksServices {
     protected readonly store: Store = new MemoryStore(),
     protected readonly opts: BlocksServicesOpts = {
       historyPerBlock: 10000,
-      historyCompactionDecision: (seq, pushSize) => ((pushSize > 250) || !(seq % 100)),
+      historyCompactionDecision: (seq, pushSize) => pushSize > 250 || !(seq % 100),
     },
   ) {
     this.spaceReclaimDecision = opts.spaceReclaimDecision ?? storageSpaceReclaimDecision(fs.promises);
@@ -167,9 +167,14 @@ export class BlocksServices {
     return {batches};
   }
 
-  public async pull(id: string, lastKnownSeq: number, create: boolean = false): Promise<{batches: StoreBatch[], snapshot?: StoreSnapshot}> {
+  public async pull(
+    id: string,
+    lastKnownSeq: number,
+    create: boolean = false,
+  ): Promise<{batches: StoreBatch[]; snapshot?: StoreSnapshot}> {
     const {store} = this;
-    if (typeof lastKnownSeq !== 'number' || lastKnownSeq !== Math.round(lastKnownSeq) || lastKnownSeq < -1) throw RpcError.validation('INVALID_SEQ');
+    if (typeof lastKnownSeq !== 'number' || lastKnownSeq !== Math.round(lastKnownSeq) || lastKnownSeq < -1)
+      throw RpcError.validation('INVALID_SEQ');
     const seq = await store.seq(id);
     if (seq === undefined) {
       if (create) {
@@ -214,7 +219,7 @@ export class BlocksServices {
     };
     const res = await store.push(newSnapshot, batch);
     const opts = this.opts;
-    if ((seq > opts.historyPerBlock) && store.compact && opts.historyCompactionDecision(seq, blobSize)) {
+    if (seq > opts.historyPerBlock && store.compact && opts.historyCompactionDecision(seq, blobSize)) {
       go(() => this.compact(id, seq - opts.historyPerBlock));
     }
     this.__emitUpd(id, res.batch);
@@ -231,8 +236,7 @@ export class BlocksServices {
     await store.compact!(id, to, async (blob, iterator) => {
       const model = Model.fromBinary(blob);
       for await (const batch of iterator)
-        for (const patch of batch.patches)
-          model.applyPatch(Patch.fromBinary(patch.blob));
+        for (const patch of batch.patches) model.applyPatch(Patch.fromBinary(patch.blob));
       return model.toBinary();
     });
   }

src/__demos__/json-crdt-server/services/blocks/__tests__/util.spec.ts

@@ -2,7 +2,7 @@ import {storageSpaceReclaimDecision} from '../util';
 
 test('returns 0 when more than 300 MB available', async () => {
   const promises = {
-    statfs: async () => ({bavail: 400 * 1024, bsize: 1024} as any),
+    statfs: async () => ({bavail: 400 * 1024, bsize: 1024}) as any,
   };
   const fn = storageSpaceReclaimDecision(promises, () => true, 300 * 1024 * 1024);
   const res = await fn();
@@ -11,7 +11,7 @@ test('returns 0 when more than 300 MB available', async () => {
 
 test('returns greater than 0 when less than 300 MB available', async () => {
   const promises = {
-    statfs: async () => ({bavail: 200 * 1024, bsize: 1024} as any),
+    statfs: async () => ({bavail: 200 * 1024, bsize: 1024}) as any,
   };
   const fn = storageSpaceReclaimDecision(promises, () => true, 300 * 1024 * 1024);
   const res = await fn();
@@ -20,7 +20,7 @@ test('returns greater than 0 when less than 300 MB available', async () => {
 
 test('returns 0 when not good time for GC', async () => {
   const promises = {
-    statfs: async () => ({bavail: 200 * 1024, bsize: 1024} as any),
+    statfs: async () => ({bavail: 200 * 1024, bsize: 1024}) as any,
   };
   const fn = storageSpaceReclaimDecision(promises, () => false, 300 * 1024 * 1024);
   const res = await fn();

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

@@ -8,7 +8,7 @@ export class MemoryBlock {
   constructor(
     public readonly start: types.StoreSnapshot,
     public readonly data: types.StoreBlock,
-    public readonly history: types.StoreBatch[]
+    public readonly history: types.StoreBatch[],
   ) {}
 }
 
@@ -22,7 +22,10 @@ export class MemoryStore implements types.Store {
     return {block: block.data};
   }
 
-  public async getSnapshot(id: string, seq: number): Promise<{snapshot: types.StoreSnapshot, batches: types.StoreBatch[]}> {
+  public async getSnapshot(
+    id: string,
+    seq: number,
+  ): Promise<{snapshot: types.StoreSnapshot; batches: types.StoreBatch[]}> {
     await tick;
     const block = this.blocks.get(id);
     if (!block) throw RpcError.notFound();
@@ -113,7 +116,7 @@ export class MemoryStore implements types.Store {
     const batches = block.history;
     const length = batches.length;
     let i = 0;
-    async function * iterator() {
+    async function* iterator() {
       for (; i < length; i++) {
         const batch = batches[i];
         const seq = batch.seq;
@@ -168,11 +171,12 @@ export class MemoryStore implements types.Store {
   public async removeAccessedBefore(ts: number, limit = 10): Promise<void> {
     await tick;
     let cnt = 0;
-    for (const [id, block] of this.blocks) if (block.data.uts < ts) {
-      this.removeSync(id);
-      cnt++;
-      if (cnt >= limit) return;
-    }
+    for (const [id, block] of this.blocks)
+      if (block.data.uts < ts) {
+        this.removeSync(id);
+        cnt++;
+        if (cnt >= limit) return;
+      }
   }
 
   public async removeOldest(x: number): Promise<void> {