@platforma-sdk/model 1.9.0 → 1.10.0

package/src/render/accessor.ts

@@ -47,6 +47,7 @@ type FieldMapOps = {
 export class TreeNodeAccessor {
   constructor(public readonly handle: AccessorHandle) {}
 
+  /** Shortcut for {@link resolveInput} */
   public resolve(
     ...steps: [
       Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
@@ -54,8 +55,70 @@ export class TreeNodeAccessor {
       }
     ]
   ): TreeNodeAccessor;
+  /** Shortcut for {@link resolveInput} */
   public resolve(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
   public resolve(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
+    const transformedSteps = steps.map(
+      (s) =>
+        ({
+          assertFieldType: 'Input',
+          ...(typeof s === 'string' ? { field: s } : s)
+        }) satisfies FieldTraversalStep
+    );
+    return this.resolveWithCommon({}, ...transformedSteps);
+  }
+
+  /** If field type assertion is not specified for the step, default is Output. */
+  public resolveOutput(
+    ...steps: [
+      Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
+        errorIfFieldNotAssigned: true;
+      }
+    ]
+  ): TreeNodeAccessor;
+  /** If field type assertion is not specified for the step, default is Output. */
+  public resolveOutput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
+  public resolveOutput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
+    const transformedSteps = steps.map(
+      (s) =>
+        ({
+          assertFieldType: 'Output',
+          ...(typeof s === 'string' ? { field: s } : s)
+        }) satisfies FieldTraversalStep
+    );
+    return this.resolveWithCommon({}, ...transformedSteps);
+  }
+
+  /** If field type assertion is not specified for the step, default is Input. */
+  public resolveInput(
+    ...steps: [
+      Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
+        errorIfFieldNotAssigned: true;
+      }
+    ]
+  ): TreeNodeAccessor;
+  /** If field type assertion is not specified for the step, default is Input. */
+  public resolveInput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
+  public resolveInput(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
+    const transformedSteps = steps.map(
+      (s) =>
+        ({
+          assertFieldType: 'Input',
+          ...(typeof s === 'string' ? { field: s } : s)
+        }) satisfies FieldTraversalStep
+    );
+    return this.resolveWithCommon({}, ...transformedSteps);
+  }
+
+  public resolveAny(
+    ...steps: [
+      Omit<FieldTraversalStep, 'errorIfFieldNotSet'> & {
+        errorIfFieldNotAssigned: true;
+      }
+    ]
+  ): TreeNodeAccessor;
+  public resolveAny(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined;
+  public resolveAny(...steps: (FieldTraversalStep | string)[]): TreeNodeAccessor | undefined {
     return this.resolveWithCommon({}, ...steps);
   }
 

package/src/render/index.ts

@@ -1,5 +1,6 @@
 export * from './api';
 export * from './traversal_ops';
 export * from './accessor';
+export * from './util';
 export { type ExtractFutureRefType } from './future';
 export { FutureRef } from './future';

package/src/render/traversal_ops.ts

@@ -46,8 +46,11 @@ export type GetFieldStep = CommonFieldTraverseOps & {
   errorIfFieldNotSet?: true;
 
   /**
-   * Assert field type. Call will fail with exception if this assertion is not
-   * fulfilled
+   * Assert field type.
+   * Call will fail with exception if this assertion is not fulfilled.
+   * The information about expectedFieldType is also used for stability
+   * calculation and field absence error generation, so it is always a good
+   * ide to specify it.
    * */
   assertFieldType?: FieldType;
 };

package/src/render/util/index.ts

@@ -0,0 +1 @@
+export * from './resource_map'

package/src/render/util/resource_map.ts

@@ -0,0 +1,74 @@
+import { TreeNodeAccessor } from "../accessor";
+
+export const ResourceMapResourceTypeName = 'PColumnData/ResourceMap';
+export const ResourceMapResourcePartitionedTypeName = 'PColumnData/Partitioned/ResourceMap';
+
+export type PColumnKey = (string | number)[];
+
+export type PColumnResourceMapEntry<T> = {
+  key: PColumnKey;
+  value: T;
+};
+
+export type PColumnResourceMapData<T> = {
+  isComplete: boolean;
+  data: PColumnResourceMapEntry<T>[];
+};
+
+function populateResourceMapData<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  data: PColumnResourceMapEntry<T | undefined>[],
+  keyPrefix: PColumnKey = [],
+  addEntriesWithNoData: boolean
+): boolean {
+  if (acc === undefined) return false;
+  switch (acc.resourceType.name) {
+    case ResourceMapResourceTypeName: {
+      let isComplete = acc.getInputsLocked();
+      for (const keyStr of acc.listInputFields()) {
+        const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+        const key = [...keyPrefix, ...JSON.parse(keyStr)] as PColumnKey;
+        const converted = value === undefined ? undefined : resourceParser(value);
+        if (converted === undefined) isComplete = false;
+        if (converted !== undefined || addEntriesWithNoData) data.push({ key, value: converted });
+      }
+      return isComplete;
+    }
+    case ResourceMapResourcePartitionedTypeName: {
+      let isComplete = acc.getInputsLocked();
+      for (const keyStr of acc.listInputFields()) {
+        const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+        if (value === undefined) isComplete = false;
+        else {
+          const key = [...keyPrefix, ...JSON.parse(keyStr)] as PColumnKey;
+          const populateResult = populateResourceMapData(value, resourceParser, data, key, addEntriesWithNoData)
+          isComplete = isComplete && populateResult;
+        }
+      }
+      return isComplete;
+    }
+    default:
+      throw new Error(`Unknown resource type: ${acc.resourceType.name}`);
+  }
+}
+
+export function parseResourceMap<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  addEntriesWithNoData: false
+): PColumnResourceMapData<NonNullable<T>>;
+export function parseResourceMap<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  addEntriesWithNoData: true
+): PColumnResourceMapData<T | undefined>;
+export function parseResourceMap<T>(
+  acc: TreeNodeAccessor | undefined,
+  resourceParser: (acc: TreeNodeAccessor) => T | undefined,
+  addEntriesWithNoData: boolean = false
+): PColumnResourceMapData<T | undefined> {
+  const data: PColumnResourceMapEntry<T | undefined>[] = [];
+  const isComplete = populateResourceMapData(acc, resourceParser, data, [], addEntriesWithNoData);
+  return { isComplete, data };
+}