@milaboratories/pl-tree 1.3.6

package/src/test_utils.ts

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

package/src/traversal_ops.ts

@@ -0,0 +1,56 @@
+import { FieldType, ResourceType } from '@milaboratories/pl-client';
+
+export type CommonTraversalOps = {
+  /**
+   * Don't terminate chain if current resource or field has an error associated
+   * with, by default resource or field error will be thrown. If field has error
+   * and no value, error will be thrown anyway, because this is the reason
+   * traversal is terminated.
+   * */
+  ignoreError?: boolean;
+};
+
+export type CommonFieldTraverseOps = {
+  /**
+   * Valid only if {@link assertFieldType} is defined and equal to 'Input',
+   * 'Service' or 'Output'. By default, if field is not found, and corresponding
+   * field list is locked, call will fail with exception.
+   * */
+  allowPermanentAbsence?: boolean;
+
+  /** Will not mark current context as unstable, if field is not found. */
+  stableIfNotFound?: boolean;
+
+  /**
+   * If encounter field with error and no value, will silently terminate the
+   * traversal and return undefined.
+   * */
+  pureFieldErrorToUndefined?: boolean;
+};
+
+export type ResourceTraversalOps = CommonTraversalOps & {
+  /**
+   * Assert resource type of the resource the fields points to. Call will fail
+   * with exception if this assertion is not fulfilled.
+   * */
+  assertResourceType?: ResourceType | ResourceType[];
+};
+
+export type GetFieldStep = CommonFieldTraverseOps & {
+  /** Field name */
+  field: string;
+
+  /** Field must exist, if this option is set, instead error will be thrown */
+  errorIfFieldNotFound?: boolean;
+
+  /** Field must be resolved into resource if this option is set, instead error will be thrown */
+  errorIfFieldNotSet?: boolean;
+
+  /**
+   * Assert field type. Call will fail with exception if this assertion is not
+   * fulfilled
+   * */
+  assertFieldType?: FieldType;
+};
+
+export type FieldTraversalStep = GetFieldStep & ResourceTraversalOps;

package/src/value_and_error.ts

@@ -0,0 +1,19 @@
+export interface ValueAndError<T> {
+  value?: T;
+  error?: T;
+}
+
+export function mapValueAndErrorIfDefined<T1, T2>(
+  input: ValueAndError<T1> | undefined,
+  mapping: (v: T1) => T2
+): ValueAndError<T2> | undefined {
+  if (input === undefined) return undefined;
+  else return mapValueAndError(input, mapping);
+}
+
+export function mapValueAndError<T1, T2>(input: ValueAndError<T1>, mapping: (v: T1) => T2) {
+  const ret = {} as ValueAndError<T2>;
+  if (input.value !== undefined) ret.value = mapping(input.value);
+  if (input.error !== undefined) ret.error = mapping(input.error);
+  return ret;
+}

package/src/value_or_error.ts

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