@milaboratories/pl-tree 1.8.33 → 1.8.35

package/src/synchronized_tree.test.ts

@@ -1,24 +1,24 @@
-import { test, expect } from 'vitest';
-import { field, TestHelpers } from '@milaboratories/pl-client';
-import { TestStructuralResourceType1 } from './test_utils';
-import { Computable } from '@milaboratories/computable';
-import { SynchronizedTreeState } from './synchronized_tree';
-import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
-import tp from 'timers/promises';
-
-test('simple synchronized tree test', async () => {
+import { test, expect } from "vitest";
+import { field, TestHelpers } from "@milaboratories/pl-client";
+import { TestStructuralResourceType1 } from "./test_utils";
+import { Computable } from "@milaboratories/computable";
+import { SynchronizedTreeState } from "./synchronized_tree";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
+import tp from "timers/promises";
+
+test("simple synchronized tree test", async () => {
   await TestHelpers.withTempRoot(async (pl) => {
     const r1 = await pl.withWriteTx(
-      'CreatingStructure1',
+      "CreatingStructure1",
       async (tx) => {
         const rr1 = tx.createStruct(TestStructuralResourceType1);
-        const ff1 = field(tx.clientRoot, 'f1');
-        tx.createField(ff1, 'Dynamic');
+        const ff1 = field(tx.clientRoot, "f1");
+        tx.createField(ff1, "Dynamic");
         tx.setField(ff1, rr1);
         await tx.commit();
         return await rr1.globalId;
       },
-      { sync: true }
+      { sync: true },
     );
 
     const treeState = await SynchronizedTreeState.init(
@@ -27,33 +27,33 @@ test('simple synchronized tree test', async () => {
       {
         stopPollingDelay: 10,
         pollingInterval: 10,
-        logStat: 'cumulative'
+        logStat: "cumulative",
       },
-      new ConsoleLoggerAdapter(require('console'))
+      new ConsoleLoggerAdapter(require("console")),
     );
 
     const theComputable = Computable.make((c) =>
-      c.accessor(treeState.entry()).node().traverse('a', 'b')?.getDataAsString()
+      c.accessor(treeState.entry()).node().traverse("a", "b")?.getDataAsString(),
     );
 
     await theComputable.refreshState();
 
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: false,
-      value: undefined
+      value: undefined,
     });
 
     const r2 = await pl.withWriteTx(
-      'CreatingStructure2',
+      "CreatingStructure2",
       async (tx) => {
         const rr2 = tx.createStruct(TestStructuralResourceType1);
-        const ff2 = field(r1, 'a');
-        tx.createField(ff2, 'Input');
+        const ff2 = field(r1, "a");
+        tx.createField(ff2, "Input");
         tx.setField(ff2, rr2);
         await tx.commit();
         return await rr2.globalId;
       },
-      { sync: true }
+      { sync: true },
     );
     await tp.setTimeout(10);
 
@@ -62,20 +62,20 @@ test('simple synchronized tree test', async () => {
     expect(theComputable.isChanged()).toBe(true);
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: false,
-      value: undefined
+      value: undefined,
     });
 
-    const r3 = await pl.withWriteTx(
-      'CreatingStructure3',
+    await pl.withWriteTx(
+      "CreatingStructure3",
       async (tx) => {
-        const rr3 = tx.createValue(TestStructuralResourceType1, 'hi!');
-        const ff3 = field(r2, 'b');
-        tx.createField(ff3, 'Input');
+        const rr3 = tx.createValue(TestStructuralResourceType1, "hi!");
+        const ff3 = field(r2, "b");
+        tx.createField(ff3, "Input");
         tx.setField(ff3, rr3);
         await tx.commit();
         return await rr3.globalId;
       },
-      { sync: true }
+      { sync: true },
     );
     await tp.setTimeout(10);
 
@@ -84,17 +84,17 @@ test('simple synchronized tree test', async () => {
     expect(theComputable.isChanged()).toBe(true);
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: true,
-      value: 'hi!'
+      value: "hi!",
     });
 
     await pl.withWriteTx(
-      'CreatingStructure3',
+      "CreatingStructure3",
       async (tx) => {
         tx.lock(r1);
         tx.lock(r2);
         await tx.commit();
       },
-      { sync: true }
+      { sync: true },
     );
     await tp.setTimeout(10);
 
@@ -103,26 +103,26 @@ test('simple synchronized tree test', async () => {
     expect(theComputable.isChanged()).toBe(true);
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: true,
-      value: 'hi!'
+      value: "hi!",
     });
 
     await treeState.awaitSyncLoopTermination();
   });
 });
 
-test('synchronized tree test with KV', async () => {
+test("synchronized tree test with KV", async () => {
   await TestHelpers.withTempRoot(async (pl) => {
     const r1 = await pl.withWriteTx(
-      'CreatingStructure1',
+      "CreatingStructure1",
       async (tx) => {
         const rr1 = tx.createStruct(TestStructuralResourceType1);
-        const ff1 = field(tx.clientRoot, 'f1');
-        tx.createField(ff1, 'Dynamic');
+        const ff1 = field(tx.clientRoot, "f1");
+        tx.createField(ff1, "Dynamic");
         tx.setField(ff1, rr1);
         await tx.commit();
         return await rr1.globalId;
       },
-      { sync: true }
+      { sync: true },
     );
 
     const treeState = await SynchronizedTreeState.init(
@@ -131,33 +131,33 @@ test('synchronized tree test with KV', async () => {
       {
         stopPollingDelay: 10,
         pollingInterval: 10,
-        logStat: 'cumulative'
+        logStat: "cumulative",
       },
-      new ConsoleLoggerAdapter(require('console'))
+      new ConsoleLoggerAdapter(require("console")),
     );
 
     const theComputable = Computable.make((c) =>
-      c.accessor(treeState.entry()).node().traverse('a')?.getKeyValueAsString('b', true)
+      c.accessor(treeState.entry()).node().traverse("a")?.getKeyValueAsString("b", true),
     );
 
     await theComputable.refreshState();
 
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: false,
-      value: undefined
+      value: undefined,
     });
 
     const r2 = await pl.withWriteTx(
-      'CreatingStructure2',
+      "CreatingStructure2",
       async (tx) => {
         const rr2 = tx.createStruct(TestStructuralResourceType1);
-        const ff2 = field(r1, 'a');
-        tx.createField(ff2, 'Input');
+        const ff2 = field(r1, "a");
+        tx.createField(ff2, "Input");
         tx.setField(ff2, rr2);
         await tx.commit();
         return await rr2.globalId;
       },
-      { sync: true }
+      { sync: true },
     );
     await tp.setTimeout(10);
 
@@ -166,11 +166,11 @@ test('synchronized tree test with KV', async () => {
     expect(theComputable.isChanged()).toBe(true);
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: false,
-      value: undefined
+      value: undefined,
     });
 
-    await pl.withWriteTx('AssignKeyValue', async (tx) => {
-      tx.setKValue(r2, 'b', 'hi!');
+    await pl.withWriteTx("AssignKeyValue", async (tx) => {
+      tx.setKValue(r2, "b", "hi!");
       await tx.commit();
     });
     await tp.setTimeout(10);
@@ -180,26 +180,26 @@ test('synchronized tree test with KV', async () => {
     expect(theComputable.isChanged()).toBe(true);
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: true,
-      value: 'hi!'
+      value: "hi!",
     });
 
     await treeState.awaitSyncLoopTermination();
   });
 });
 
-test('termination test', async () => {
+test("termination test", async () => {
   await TestHelpers.withTempRoot(async (pl) => {
     const r1 = await pl.withWriteTx(
-      'CreatingStructure1',
+      "CreatingStructure1",
       async (tx) => {
         const rr1 = tx.createStruct(TestStructuralResourceType1);
-        const ff1 = field(tx.clientRoot, 'f1');
-        tx.createField(ff1, 'Dynamic');
+        const ff1 = field(tx.clientRoot, "f1");
+        tx.createField(ff1, "Dynamic");
         tx.setField(ff1, rr1);
         await tx.commit();
         return await rr1.globalId;
       },
-      { sync: true }
+      { sync: true },
     );
     await tp.setTimeout(10);
 
@@ -209,29 +209,29 @@ test('termination test', async () => {
       {
         stopPollingDelay: 10,
         pollingInterval: 10,
-        logStat: 'cumulative'
+        logStat: "cumulative",
       },
-      new ConsoleLoggerAdapter(require('console'))
+      new ConsoleLoggerAdapter(require("console")),
     );
 
     const entry = treeState.entry();
     const theComputable = Computable.make((c) =>
-      c.accessor(entry).node().traverse('a')?.getKeyValueAsString('b', true)
+      c.accessor(entry).node().traverse("a")?.getKeyValueAsString("b", true),
     );
 
     await theComputable.refreshState();
 
     expect(await theComputable.getValueOrError()).toMatchObject({
       stable: false,
-      value: undefined
+      value: undefined,
     });
 
     await treeState.terminate();
 
     const resultAfterTermination = await theComputable.getValueOrError();
     expect(resultAfterTermination).toMatchObject({
-      type: 'error'
+      type: "error",
     });
-    expect((resultAfterTermination as any).errors[0].message).toMatch('terminated');
+    expect((resultAfterTermination as any).errors[0].message).toMatch("terminated");
   });
 });

package/src/synchronized_tree.ts

@@ -1,29 +1,20 @@
-import { PollingComputableHooks } from '@milaboratories/computable';
-import { PlTreeEntry } from './accessors';
+import { PollingComputableHooks } from "@milaboratories/computable";
+import { PlTreeEntry } from "./accessors";
 import type {
   FinalResourceDataPredicate,
   PlClient,
   ResourceId,
   TxOps,
-} from '@milaboratories/pl-client';
-import {
-  isTimeoutOrCancelError,
-} from '@milaboratories/pl-client';
-import type { ExtendedResourceData } from './state';
-import { PlTreeState, TreeStateUpdateError } from './state';
-import type {
-  PruningFunction,
-  TreeLoadingStat,
-} from './sync';
-import {
-  constructTreeLoadingRequest,
-  initialTreeLoadingStat,
-  loadTreeState,
-} from './sync';
-import * as tp from 'node:timers/promises';
-import type { MiLogger } from '@milaboratories/ts-helpers';
-
-type StatLoggingMode = 'cumulative' | 'per-request';
+} from "@milaboratories/pl-client";
+import { isTimeoutOrCancelError } from "@milaboratories/pl-client";
+import type { ExtendedResourceData } from "./state";
+import { PlTreeState, TreeStateUpdateError } from "./state";
+import type { PruningFunction, TreeLoadingStat } from "./sync";
+import { constructTreeLoadingRequest, initialTreeLoadingStat, loadTreeState } from "./sync";
+import * as tp from "node:timers/promises";
+import type { MiLogger } from "@milaboratories/ts-helpers";
+
+type StatLoggingMode = "cumulative" | "per-request";
 
 export type SynchronizedTreeOps = {
   /** Override final predicate from the PlClient */
@@ -81,19 +72,19 @@ export class SynchronizedTreeState {
 
   /** @deprecated use "entry" instead */
   public accessor(rid: ResourceId = this.root): PlTreeEntry {
-    if (this.terminated) throw new Error('tree synchronization is terminated');
+    if (this.terminated) throw new Error("tree synchronization is terminated");
     return this.entry(rid);
   }
 
   public entry(rid: ResourceId = this.root): PlTreeEntry {
-    if (this.terminated) throw new Error('tree synchronization is terminated');
+    if (this.terminated) throw new Error("tree synchronization is terminated");
     return new PlTreeEntry({ treeProvider: () => this.state, hooks: this.hooks }, rid);
   }
 
   /** Can be used to externally kick off the synchronization polling loop, and
    * await for the first synchronization to happen. */
   public async refreshState(): Promise<void> {
-    if (this.terminated) throw new Error('tree synchronization is terminated');
+    if (this.terminated) throw new Error("tree synchronization is terminated");
     await this.hooks.refreshState();
   }
 
@@ -102,7 +93,7 @@ export class SynchronizedTreeState {
 
   /** Called from computable hooks when external observer asks for state refresh */
   private scheduleOnNextState(resolve: () => void, reject: (err: any) => void): void {
-    if (this.terminated) reject(new Error('tree synchronization is terminated'));
+    if (this.terminated) reject(new Error("tree synchronization is terminated"));
     else {
       this.scheduledOnNextState.push({ resolve, reject });
       if (this.currentLoopDelayInterrupt) {
@@ -131,11 +122,15 @@ export class SynchronizedTreeState {
 
   /** Executed from the main loop, and initialization procedure. */
   private async refresh(stats?: TreeLoadingStat, txOps?: TxOps): Promise<void> {
-    if (this.terminated) throw new Error('tree synchronization is terminated');
+    if (this.terminated) throw new Error("tree synchronization is terminated");
     const request = constructTreeLoadingRequest(this.state, this.pruning);
-    const data = await this.pl.withReadTx('ReadingTree', async (tx) => {
-      return await loadTreeState(tx, request, stats);
-    }, txOps);
+    const data = await this.pl.withReadTx(
+      "ReadingTree",
+      async (tx) => {
+        return await loadTreeState(tx, request, stats);
+      },
+      txOps,
+    );
     this.state.updateFromResourceData(data, true);
   }
 
@@ -162,20 +157,26 @@ export class SynchronizedTreeState {
 
       try {
         // resetting stats if we were asked to collect non-cumulative stats
-        if (this.logStat === 'per-request') stat = initialTreeLoadingStat();
+        if (this.logStat === "per-request") stat = initialTreeLoadingStat();
 
         // actual tree synchronization
         await this.refresh(stat);
 
         // logging stats if we were asked to
-        if (stat && this.logger) this.logger.info(`Tree stat (success, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`);
+        if (stat && this.logger)
+          this.logger.info(
+            `Tree stat (success, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`,
+          );
         lastUpdate = Date.now();
 
         // notifying that we got new state
         if (toNotify !== undefined) for (const n of toNotify) n.resolve();
       } catch (e: any) {
         // logging stats if we were asked to (even if error occured)
-        if (stat && this.logger) this.logger.info(`Tree stat (error, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`);
+        if (stat && this.logger)
+          this.logger.info(
+            `Tree stat (error, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`,
+          );
         lastUpdate = Date.now();
 
         // notifying that we failed to refresh the state
@@ -187,7 +188,7 @@ export class SynchronizedTreeState {
           this.logger?.error(e);
 
           // marking everybody who used previous state as changed
-          this.state.invalidateTree('stat update error');
+          this.state.invalidateTree("stat update error");
           // creating new tree
           this.state = new PlTreeState(this.root, this.finalPredicate);
 
@@ -206,10 +207,12 @@ export class SynchronizedTreeState {
       if (this.scheduledOnNextState.length === 0) {
         try {
           this.currentLoopDelayInterrupt = new AbortController();
-          await tp.setTimeout(this.pollingInterval,
-            AbortSignal.any([this.abortController.signal, this.currentLoopDelayInterrupt.signal]));
+          await tp.setTimeout(
+            this.pollingInterval,
+            AbortSignal.any([this.abortController.signal, this.currentLoopDelayInterrupt.signal]),
+          );
         } catch (e: unknown) {
-          if (!isTimeoutOrCancelError(e)) throw new Error('Unexpected error', { cause: e });
+          if (!isTimeoutOrCancelError(e)) throw new Error("Unexpected error", { cause: e });
           break;
         } finally {
           this.currentLoopDelayInterrupt = undefined;
@@ -241,7 +244,7 @@ export class SynchronizedTreeState {
     if (this.currentLoop === undefined) return;
     await this.currentLoop;
 
-    this.state.invalidateTree('synchronization terminated for the tree');
+    this.state.invalidateTree("synchronization terminated for the tree");
   }
 
   /** @deprecated */
@@ -271,7 +274,7 @@ export class SynchronizedTreeState {
       // logging stats if we were asked to (even if error occured)
       if (stat && logger)
         logger.info(
-          `Tree stat (initial load, ${ok ? 'success' : 'failure'}): ${JSON.stringify(stat)}`,
+          `Tree stat (initial load, ${ok ? "success" : "failure"}): ${JSON.stringify(stat)}`,
         );
     }
 

package/src/test_utils.ts

@@ -5,50 +5,48 @@ import type {
   OptionalResourceId,
   ResourceId,
   ResourceType,
-} from '@milaboratories/pl-client';
-import {
-  NullResourceId,
-} from '@milaboratories/pl-client';
-import type { ExtendedResourceData } from './state';
+} from "@milaboratories/pl-client";
+import { NullResourceId } from "@milaboratories/pl-client";
+import type { ExtendedResourceData } from "./state";
 
 export const TestRootType1: ResourceType = {
-  name: 'TestRootResource1',
-  version: '0',
+  name: "TestRootResource1",
+  version: "0",
 };
 
 export const TestRootType2: ResourceType = {
-  name: 'TestRootResource2',
-  version: '0',
+  name: "TestRootResource2",
+  version: "0",
 };
 
 export const TestStructuralResourceType1: ResourceType = {
-  name: 'TestStructuralResource1',
-  version: '0',
+  name: "TestStructuralResource1",
+  version: "0",
 };
 
 export const TestStructuralResourceType2: ResourceType = {
-  name: 'TestStructuralResource2',
-  version: '0',
+  name: "TestStructuralResource2",
+  version: "0",
 };
 
 export const TestValueResourceType1: ResourceType = {
-  name: 'TestValueResource1',
-  version: '0',
+  name: "TestValueResource1",
+  version: "0",
 };
 
 export const TestValueResourceType2: ResourceType = {
-  name: 'TestValueResource2',
-  version: '0',
+  name: "TestValueResource2",
+  version: "0",
 };
 
 export const TestErrorResourceType1: ResourceType = {
-  name: 'json/resourceError',
-  version: '1',
+  name: "json/resourceError",
+  version: "1",
 };
 
 export const ResourceReady: Pick<
   BasicResourceData,
-  'inputsLocked' | 'outputsLocked' | 'resourceReady' | 'final'
+  "inputsLocked" | "outputsLocked" | "resourceReady" | "final"
 > = {
   inputsLocked: true,
   outputsLocked: true,
@@ -56,9 +54,9 @@ export const ResourceReady: Pick<
   final: true,
 };
 
-export const InitialStructuralResourceState: Omit<ExtendedResourceData, 'id' | 'type' | 'fields'>
-  = {
-    kind: 'Structural',
+export const InitialStructuralResourceState: Omit<ExtendedResourceData, "id" | "type" | "fields"> =
+  {
+    kind: "Structural",
     originalResourceId: NullResourceId,
     error: NullResourceId,
     inputsLocked: false,
@@ -68,8 +66,8 @@ export const InitialStructuralResourceState: Omit<ExtendedResourceData, 'id' | '
     kv: [],
   };
 
-export const InitialValueResourceState: Omit<ExtendedResourceData, 'id' | 'type' | 'data'> = {
-  kind: 'Value',
+export const InitialValueResourceState: Omit<ExtendedResourceData, "id" | "type" | "data"> = {
+  kind: "Value",
   originalResourceId: NullResourceId,
   error: NullResourceId,
   ...ResourceReady,
@@ -77,33 +75,33 @@ export const InitialValueResourceState: Omit<ExtendedResourceData, 'id' | 'type'
   kv: [],
 };
 
-export const TestStructuralResourceState1: Omit<ExtendedResourceData, 'id' | 'fields'> = {
+export const TestStructuralResourceState1: Omit<ExtendedResourceData, "id" | "fields"> = {
   ...InitialStructuralResourceState,
   type: TestStructuralResourceType1,
 };
 
-export const TestStructuralResourceState2: Omit<ExtendedResourceData, 'id' | 'fields'> = {
+export const TestStructuralResourceState2: Omit<ExtendedResourceData, "id" | "fields"> = {
   ...InitialStructuralResourceState,
   type: TestStructuralResourceType2,
 };
 
-export const TestValueResourceState1: Omit<ExtendedResourceData, 'id' | 'data'> = {
+export const TestValueResourceState1: Omit<ExtendedResourceData, "id" | "data"> = {
   ...InitialValueResourceState,
   type: TestValueResourceType1,
 };
 
-export const TestValueResourceState2: Omit<ExtendedResourceData, 'id' | 'data'> = {
+export const TestValueResourceState2: Omit<ExtendedResourceData, "id" | "data"> = {
   ...InitialValueResourceState,
   type: TestValueResourceType2,
 };
 
-export const TestErrorResourceState2: Omit<ExtendedResourceData, 'id' | 'data'> = {
+export const TestErrorResourceState2: Omit<ExtendedResourceData, "id" | "data"> = {
   ...InitialValueResourceState,
   type: TestErrorResourceType1,
 };
 
 export const TestDynamicRootId1 = 1000001n as ResourceId;
-export const TestDynamicRootState1: Omit<ExtendedResourceData, 'fields'> = {
+export const TestDynamicRootState1: Omit<ExtendedResourceData, "fields"> = {
   ...InitialStructuralResourceState,
   inputsLocked: true,
   outputsLocked: true,
@@ -113,7 +111,7 @@ export const TestDynamicRootState1: Omit<ExtendedResourceData, 'fields'> = {
 };
 
 export const TestDynamicRootId2 = 1000002n as ResourceId;
-export const TestDynamicRootState2: Omit<ExtendedResourceData, 'fields'> = {
+export const TestDynamicRootState2: Omit<ExtendedResourceData, "fields"> = {
   ...InitialStructuralResourceState,
   inputsLocked: true,
   outputsLocked: true,
@@ -134,7 +132,7 @@ export function field(
     type,
     value,
     error,
-    status: value !== NullResourceId ? 'Resolved' : error !== NullResourceId ? 'Assigned' : 'Empty',
+    status: value !== NullResourceId ? "Resolved" : error !== NullResourceId ? "Assigned" : "Empty",
     valueIsFinal,
   };
 }
@@ -144,7 +142,7 @@ export function dField(
   value: OptionalResourceId = NullResourceId,
   error: OptionalResourceId = NullResourceId,
 ): FieldData {
-  return field('Dynamic', name, value, error);
+  return field("Dynamic", name, value, error);
 }
 
 export function iField(
@@ -152,5 +150,5 @@ export function iField(
   value: OptionalResourceId = NullResourceId,
   error: OptionalResourceId = NullResourceId,
 ): FieldData {
-  return field('Input', name, value, error);
+  return field("Input", name, value, error);
 }

package/src/traversal_ops.ts

@@ -1,4 +1,4 @@
-import type { FieldType, ResourceType } from '@milaboratories/pl-client';
+import type { FieldType, ResourceType } from "@milaboratories/pl-client";
 
 export type CommonTraversalOps = {
   /**

package/src/value_or_error.ts

@@ -1,9 +1,9 @@
 export type ValueOrError<V, E> =
   | {
-    ok: true;
-    value: V;
-  }
+      ok: true;
+      value: V;
+    }
   | {
-    ok: false;
-    error: E;
-  };
+      ok: false;
+      error: E;
+    };