@milaboratories/pl-tree 1.5.0 → 1.5.2

package/src/state.ts

@@ -1,26 +1,29 @@
-import {
+import type {
   BasicResourceData,
   FieldData,
   FieldStatus,
   FieldType,
-  isNotNullResourceId,
-  isNullResourceId,
   KeyValue,
-  NullResourceId,
   OptionalResourceId,
   ResourceData,
   ResourceId,
-  resourceIdToString,
   ResourceKind,
-  ResourceType,
-  stringifyWithResourceId
+  ResourceType } from '@milaboratories/pl-client';
+import {
+  isNotNullResourceId,
+  isNullResourceId,
+  NullResourceId,
+  resourceIdToString,
+  stringifyWithResourceId,
 } from '@milaboratories/pl-client';
-import { ChangeSource, Watcher } from '@milaboratories/computable';
+import type { Watcher } from '@milaboratories/computable';
+import { ChangeSource } from '@milaboratories/computable';
 import { PlTreeEntry } from './accessors';
-import { ValueAndError } from './value_and_error';
-import { MiLogger, notEmpty } from '@milaboratories/ts-helpers';
-import { FieldTraversalStep, GetFieldStep } from './traversal_ops';
-import { FinalResourceDataPredicate } from '@milaboratories/pl-client';
+import type { ValueAndError } from './value_and_error';
+import type { MiLogger } from '@milaboratories/ts-helpers';
+import { notEmpty } from '@milaboratories/ts-helpers';
+import type { FieldTraversalStep, GetFieldStep } from './traversal_ops';
+import type { FinalResourceDataPredicate } from '@milaboratories/pl-client';
 
 export type ExtendedResourceData = ResourceData & {
   kv: KeyValue[];
@@ -43,7 +46,7 @@ class PlTreeField implements FieldData {
     public status: FieldStatus,
     public valueIsFinal: boolean,
     /** Last version of resource this field was observed, used to garbage collect fields in tree patching procedure */
-    public resourceVersion: number
+    public resourceVersion: number,
   ) {}
 
   get state(): FieldData {
@@ -53,7 +56,7 @@ class PlTreeField implements FieldData {
       status: this.status,
       value: this.value,
       error: this.error,
-      valueIsFinal: this.valueIsFinal
+      valueIsFinal: this.valueIsFinal,
     };
   }
 }
@@ -168,7 +171,7 @@ export class PlTreeResource implements ResourceDataWithFinalState {
   public getField(
     watcher: Watcher,
     _step: string | GetFieldStep,
-    onUnstable: (marker: string) => void = () => {}
+    onUnstable: (marker: string) => void = () => {},
   ): ValueAndError<ResourceId> | undefined {
     const step: FieldTraversalStep = typeof _step === 'string' ? { field: _step } : _step;
 
@@ -176,7 +179,7 @@ export class PlTreeResource implements ResourceDataWithFinalState {
     if (field === undefined) {
       if (step.errorIfFieldNotFound || step.errorIfFieldNotSet)
         throw new Error(
-          `Field "${step.field}" not found in resource ${resourceIdToString(this.id)}`
+          `Field "${step.field}" not found in resource ${resourceIdToString(this.id)}`,
         );
 
       if (!this.inputsLocked) this.inputAndServiceFieldListChanged?.attachWatcher(watcher);
@@ -202,7 +205,7 @@ export class PlTreeResource implements ResourceDataWithFinalState {
     } else {
       if (step.assertFieldType !== undefined && field.type !== step.assertFieldType)
         throw new Error(
-          `Unexpected field type: expected ${step.assertFieldType} but got ${field.type} for the field name ${step.field}`
+          `Unexpected field type: expected ${step.assertFieldType} but got ${field.type} for the field name ${step.field}`,
         );
 
       const ret = {} as ValueAndError<ResourceId>;
@@ -234,9 +237,9 @@ export class PlTreeResource implements ResourceDataWithFinalState {
 
   public get isReadyOrError(): boolean {
     return (
-      this.error !== NullResourceId ||
-      this.resourceReady ||
-      this.originalResourceId !== NullResourceId
+      this.error !== NullResourceId
+      || this.resourceReady
+      || this.originalResourceId !== NullResourceId
     );
   }
 
@@ -331,7 +334,7 @@ export class PlTreeResource implements ResourceDataWithFinalState {
       outputsLocked: this.outputsLocked,
       error: this.error,
       originalResourceId: this.originalResourceId,
-      final: this.finalFlag
+      final: this.finalFlag,
     };
   }
 
@@ -339,7 +342,7 @@ export class PlTreeResource implements ResourceDataWithFinalState {
     return {
       ...this.basicState,
       fields: this.fields,
-      kv: Array.from(this.kv.entries()).map(([key, value]) => ({ key, value }))
+      kv: Array.from(this.kv.entries()).map(([key, value]) => ({ key, value })),
     };
   }
 
@@ -383,7 +386,7 @@ export class PlTreeState {
   constructor(
     /** This will be the only resource not deleted during GC round */
     public readonly root: ResourceId,
-    public readonly isFinalPredicate: FinalResourceDataPredicate
+    public readonly isFinalPredicate: FinalResourceDataPredicate,
   ) {}
 
   public forEachResource(cb: (res: ResourceDataWithFinalState) => void): void {
@@ -420,12 +423,13 @@ export class PlTreeState {
 
       const statBeforeMutation = resource?.basicState;
       const unexpectedTransitionError = (reason: string): never => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { fields, ...rdWithoutFields } = rd;
         this.invalidateTree();
         throw new TreeStateUpdateError(
           `Unexpected resource state transition (${reason}): ${stringifyWithResourceId(
-            rdWithoutFields
-          )} -> ${stringifyWithResourceId(statBeforeMutation)}`
+            rdWithoutFields,
+          )} -> ${stringifyWithResourceId(statBeforeMutation)}`,
         );
       };
 
@@ -442,7 +446,7 @@ export class PlTreeState {
         // duplicate / original
         if (resource.originalResourceId !== rd.originalResourceId) {
           if (resource.originalResourceId !== NullResourceId)
-            unexpectedTransitionError("originalResourceId can't change after it is set");
+            unexpectedTransitionError('originalResourceId can\'t change after it is set');
           resource.originalResourceId = rd.originalResourceId;
           // duplicate status of the resource counts as ready for the external observer
           notEmpty(resource.resourceStateChange).markChanged();
@@ -452,7 +456,7 @@ export class PlTreeState {
         // error
         if (resource.error !== rd.error) {
           if (isNotNullResourceId(resource.error))
-            unexpectedTransitionError("resource can't change attached error after it is set");
+            unexpectedTransitionError('resource can\'t change attached error after it is set');
           resource.error = rd.error;
           incrementRefs.push(resource.error as ResourceId);
           notEmpty(resource.resourceStateChange).markChanged();
@@ -473,7 +477,7 @@ export class PlTreeState {
               fd.error,
               fd.status,
               fd.valueIsFinal,
-              resource.version
+              resource.version,
             );
             if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
             if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);
@@ -481,13 +485,13 @@ export class PlTreeState {
             if (fd.type === 'Input' || fd.type === 'Service') {
               if (resource.inputsLocked)
                 unexpectedTransitionError(
-                  `adding ${fd.type} (${fd.name}) field while inputs locked`
+                  `adding ${fd.type} (${fd.name}) field while inputs locked`,
                 );
               notEmpty(resource.inputAndServiceFieldListChanged).markChanged();
             } else if (fd.type === 'Output') {
               if (resource.outputsLocked)
                 unexpectedTransitionError(
-                  `adding ${fd.type} (${fd.name}) field while outputs locked`
+                  `adding ${fd.type} (${fd.name}) field while outputs locked`,
                 );
               notEmpty(resource.outputFieldListChanged).markChanged();
             } else {
@@ -508,14 +512,14 @@ export class PlTreeState {
               if (field.type === 'Input' || field.type === 'Service') {
                 if (resource.inputsLocked)
                   unexpectedTransitionError(
-                    `adding input field "${fd.name}", while corresponding list is locked`
+                    `adding input field "${fd.name}", while corresponding list is locked`,
                   );
                 notEmpty(resource.inputAndServiceFieldListChanged).markChanged();
               }
               if (field.type === 'Output') {
                 if (resource.outputsLocked)
                   unexpectedTransitionError(
-                    `adding output field "${fd.name}", while corresponding list is locked`
+                    `adding output field "${fd.name}", while corresponding list is locked`,
                   );
                 notEmpty(resource.outputFieldListChanged).markChanged();
               }
@@ -599,7 +603,7 @@ export class PlTreeState {
           resource.verifyReadyState();
           if (!resource.isReadyOrError)
             unexpectedTransitionError(
-              `resource can't lose it's ready or error state (ready state before ${readyStateBefore})`
+              `resource can't lose it's ready or error state (ready state before ${readyStateBefore})`,
             );
           notEmpty(resource.resourceStateChange).markChanged();
           changed = true;
@@ -623,7 +627,7 @@ export class PlTreeState {
           const newStateKeys = new Set(rd.kv.map((kv) => kv.key));
 
           // deleting keys not present in resource anymore
-          resource.kv.forEach((value, key, map) => {
+          resource.kv.forEach((_value, key, map) => {
             if (!newStateKeys.has(key)) map.delete(key);
           });
 
@@ -651,7 +655,7 @@ export class PlTreeState {
             fd.error,
             fd.status,
             fd.valueIsFinal,
-            InitialResourceVersion
+            InitialResourceVersion,
           );
           if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
           if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);

package/src/sync.ts

@@ -1,13 +1,14 @@
-import {
+import type {
   FieldData,
-  isNotNullResourceId,
-  isNullResourceId,
   OptionalResourceId,
   PlTransaction,
-  ResourceId
+  ResourceId,
+} from '@milaboratories/pl-client';
+import {
+  isNullResourceId,
 } from '@milaboratories/pl-client';
 import Denque from 'denque';
-import { ExtendedResourceData, PlTreeState } from './state';
+import type { ExtendedResourceData, PlTreeState } from './state';
 import { msToHumanReadable } from '@milaboratories/ts-helpers';
 
 /** Applied to list of fields in resource data. */
@@ -36,7 +37,7 @@ export interface TreeLoadingRequest {
  * {@link loadTreeState} to load updated state. */
 export function constructTreeLoadingRequest(
   tree: PlTreeState,
-  pruningFunction?: PruningFunction
+  pruningFunction?: PruningFunction,
 ): TreeLoadingRequest {
   const seedResources: ResourceId[] = [];
   const finalResources = new Set<ResourceId>();
@@ -75,7 +76,7 @@ export function initialTreeLoadingStat(): TreeLoadingStat {
     retrievedKeyValueBytes: 0,
     prunedFields: 0,
     finalResourcesSkipped: 0,
-    millisSpent: 0
+    millisSpent: 0,
   };
 }
 
@@ -99,7 +100,7 @@ export function formatTreeLoadingStat(stat: TreeLoadingStat): string {
 export async function loadTreeState(
   tx: PlTransaction,
   loadingRequest: TreeLoadingRequest,
-  stats?: TreeLoadingStat
+  stats?: TreeLoadingStat,
 ): Promise<ExtendedResourceData[]> {
   // saving start timestamp to add time spent in this function to the stats at the end of the method
   const startTimestamp = Date.now();
@@ -159,7 +160,7 @@ export async function loadTreeState(
         if (kv === undefined) throw new Error('Inconsistent replies');
 
         return { ...resource, kv };
-      })()
+      })(),
     );
   };
 

package/src/synchronized_tree.ts

@@ -1,22 +1,27 @@
 import { PollingComputableHooks } from '@milaboratories/computable';
 import { PlTreeEntry } from './accessors';
-import {
+import type {
   FinalResourceDataPredicate,
-  isTimeoutOrCancelError,
   PlClient,
   ResourceId,
-  TxOps
+  TxOps,
+} from '@milaboratories/pl-client';
+import {
+  isTimeoutOrCancelError,
 } from '@milaboratories/pl-client';
-import { ExtendedResourceData, PlTreeState, TreeStateUpdateError } from './state';
+import type { ExtendedResourceData } from './state';
+import { PlTreeState, TreeStateUpdateError } from './state';
+import type {
+  PruningFunction,
+  TreeLoadingStat,
+} from './sync';
 import {
   constructTreeLoadingRequest,
   initialTreeLoadingStat,
   loadTreeState,
-  PruningFunction,
-  TreeLoadingStat
 } from './sync';
 import * as tp from 'node:timers/promises';
-import { MiLogger } from '@milaboratories/ts-helpers';
+import type { MiLogger } from '@milaboratories/ts-helpers';
 
 type StatLoggingMode = 'cumulative' | 'per-request';
 
@@ -58,7 +63,7 @@ export class SynchronizedTreeState {
     private readonly pl: PlClient,
     private readonly root: ResourceId,
     ops: SynchronizedTreeOps,
-    private readonly logger?: MiLogger
+    private readonly logger?: MiLogger,
   ) {
     const { finalPredicateOverride, pruning, pollingInterval, stopPollingDelay, logStat } = ops;
     this.pruning = pruning;
@@ -70,7 +75,7 @@ export class SynchronizedTreeState {
       () => this.startUpdating(),
       () => this.stopUpdating(),
       { stopDebounce: stopPollingDelay },
-      (resolve, reject) => this.scheduleOnNextState(resolve, reject)
+      (resolve, reject) => this.scheduleOnNextState(resolve, reject),
     );
   }
 
@@ -231,24 +236,24 @@ export class SynchronizedTreeState {
     pl: PlClient,
     root: ResourceId,
     ops: SynchronizedTreeOps,
-    logger?: MiLogger
+    logger?: MiLogger,
   ) {
     const tree = new SynchronizedTreeState(pl, root, ops, logger);
 
-    let stat = ops.logStat ? initialTreeLoadingStat() : undefined;
+    const stat = ops.logStat ? initialTreeLoadingStat() : undefined;
 
     let ok = false;
 
     try {
       await tree.refresh(stat, {
-        timeout: ops.initialTreeLoadingTimeout
+        timeout: ops.initialTreeLoadingTimeout,
       });
       ok = true;
     } finally {
       // 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

@@ -1,49 +1,49 @@
-import { Optional } from 'utility-types';
-import {
+import type {
   BasicResourceData,
   FieldData,
   FieldType,
-  NullResourceId,
   OptionalResourceId,
-  ResourceData,
   ResourceId,
-  ResourceType
+  ResourceType,
 } from '@milaboratories/pl-client';
-import { ExtendedResourceData } from './state';
+import {
+  NullResourceId,
+} from '@milaboratories/pl-client';
+import type { ExtendedResourceData } from './state';
 
 export const TestRootType1: ResourceType = {
   name: 'TestRootResource1',
-  version: '0'
+  version: '0',
 };
 
 export const TestRootType2: ResourceType = {
   name: 'TestRootResource2',
-  version: '0'
+  version: '0',
 };
 
 export const TestStructuralResourceType1: ResourceType = {
   name: 'TestStructuralResource1',
-  version: '0'
+  version: '0',
 };
 
 export const TestStructuralResourceType2: ResourceType = {
   name: 'TestStructuralResource2',
-  version: '0'
+  version: '0',
 };
 
 export const TestValueResourceType1: ResourceType = {
   name: 'TestValueResource1',
-  version: '0'
+  version: '0',
 };
 
 export const TestValueResourceType2: ResourceType = {
   name: 'TestValueResource2',
-  version: '0'
+  version: '0',
 };
 
 export const TestErrorResourceType1: ResourceType = {
   name: 'json/resourceError',
-  version: '1'
+  version: '1',
 };
 
 export const ResourceReady: Pick<
@@ -53,11 +53,11 @@ export const ResourceReady: Pick<
   inputsLocked: true,
   outputsLocked: true,
   resourceReady: true,
-  final: true
+  final: true,
 };
 
-export const InitialStructuralResourceState: Omit<ExtendedResourceData, 'id' | 'type' | 'fields'> =
-  {
+export const InitialStructuralResourceState: Omit<ExtendedResourceData, 'id' | 'type' | 'fields'>
+  = {
     kind: 'Structural',
     originalResourceId: NullResourceId,
     error: NullResourceId,
@@ -65,7 +65,7 @@ export const InitialStructuralResourceState: Omit<ExtendedResourceData, 'id' | '
     outputsLocked: false,
     resourceReady: false,
     final: false,
-    kv: []
+    kv: [],
   };
 
 export const InitialValueResourceState: Omit<ExtendedResourceData, 'id' | 'type' | 'data'> = {
@@ -74,32 +74,32 @@ export const InitialValueResourceState: Omit<ExtendedResourceData, 'id' | 'type'
   error: NullResourceId,
   ...ResourceReady,
   fields: [],
-  kv: []
+  kv: [],
 };
 
 export const TestStructuralResourceState1: Omit<ExtendedResourceData, 'id' | 'fields'> = {
   ...InitialStructuralResourceState,
-  type: TestStructuralResourceType1
+  type: TestStructuralResourceType1,
 };
 
 export const TestStructuralResourceState2: Omit<ExtendedResourceData, 'id' | 'fields'> = {
   ...InitialStructuralResourceState,
-  type: TestStructuralResourceType2
+  type: TestStructuralResourceType2,
 };
 
 export const TestValueResourceState1: Omit<ExtendedResourceData, 'id' | 'data'> = {
   ...InitialValueResourceState,
-  type: TestValueResourceType1
+  type: TestValueResourceType1,
 };
 
 export const TestValueResourceState2: Omit<ExtendedResourceData, 'id' | 'data'> = {
   ...InitialValueResourceState,
-  type: TestValueResourceType2
+  type: TestValueResourceType2,
 };
 
 export const TestErrorResourceState2: Omit<ExtendedResourceData, 'id' | 'data'> = {
   ...InitialValueResourceState,
-  type: TestErrorResourceType1
+  type: TestErrorResourceType1,
 };
 
 export const TestDynamicRootId1 = 1000001n as ResourceId;
@@ -109,7 +109,7 @@ export const TestDynamicRootState1: Omit<ExtendedResourceData, 'fields'> = {
   outputsLocked: true,
   resourceReady: true,
   type: TestRootType1,
-  id: TestDynamicRootId1
+  id: TestDynamicRootId1,
 };
 
 export const TestDynamicRootId2 = 1000002n as ResourceId;
@@ -119,7 +119,7 @@ export const TestDynamicRootState2: Omit<ExtendedResourceData, 'fields'> = {
   outputsLocked: true,
   resourceReady: true,
   type: TestRootType2,
-  id: TestDynamicRootId2
+  id: TestDynamicRootId2,
 };
 
 export function field(
@@ -127,7 +127,7 @@ export function field(
   name: string,
   value: OptionalResourceId = NullResourceId,
   error: OptionalResourceId = NullResourceId,
-  valueIsFinal: boolean = false
+  valueIsFinal: boolean = false,
 ): FieldData {
   return {
     name,
@@ -135,14 +135,14 @@ export function field(
     value,
     error,
     status: value !== NullResourceId ? 'Resolved' : error !== NullResourceId ? 'Assigned' : 'Empty',
-    valueIsFinal
+    valueIsFinal,
   };
 }
 
 export function dField(
   name: string,
   value: OptionalResourceId = NullResourceId,
-  error: OptionalResourceId = NullResourceId
+  error: OptionalResourceId = NullResourceId,
 ): FieldData {
   return field('Dynamic', name, value, error);
 }
@@ -150,7 +150,7 @@ export function dField(
 export function iField(
   name: string,
   value: OptionalResourceId = NullResourceId,
-  error: OptionalResourceId = NullResourceId
+  error: OptionalResourceId = NullResourceId,
 ): FieldData {
   return field('Input', name, value, error);
 }

package/src/value_and_error.ts

@@ -5,7 +5,7 @@ export interface ValueAndError<T> {
 
 export function mapValueAndErrorIfDefined<T1, T2>(
   input: ValueAndError<T1> | undefined,
-  mapping: (v: T1) => T2
+  mapping: (v: T1) => T2,
 ): ValueAndError<T2> | undefined {
   if (input === undefined) return undefined;
   else return mapValueAndError(input, mapping);

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;
+  };