@platforma-sdk/model 1.25.0 → 1.26.0

package/src/render/util/axis_filtering.ts

@@ -0,0 +1,120 @@
+import type {
+  BinaryChunk,
+  DataInfoEntries,
+  PColumnDataEntry,
+  PColumnKey,
+  PColumnValue,
+  JsonDataInfoEntries,
+  JsonPartitionedDataInfoEntries,
+  BinaryPartitionedDataInfoEntries,
+} from '@milaboratories/pl-model-common';
+import type { AxisFilterByIdx } from '@milaboratories/pl-model-common';
+
+/**
+ * Filters DataInfoEntries using axis filters, removing specified axes from keys and
+ * only keeping entries that match the filter values.
+ *
+ * @param dataInfoEntries - The data info object to filter
+ * @param axisFilters - Array of axis filters (index, value pairs)
+ * @throws Error if any filter axis is outside the partitioning axes or data axes for Json data
+ */
+export function filterDataInfoEntries<Blob>(
+  dataInfoEntries: BinaryPartitionedDataInfoEntries<Blob>,
+  axisFilters: AxisFilterByIdx[],
+): BinaryPartitionedDataInfoEntries<Blob>;
+export function filterDataInfoEntries<Blob>(
+  dataInfoEntries: JsonPartitionedDataInfoEntries<Blob>,
+  axisFilters: AxisFilterByIdx[],
+): JsonPartitionedDataInfoEntries<Blob>;
+export function filterDataInfoEntries<Blob>(
+  dataInfoEntries: BinaryPartitionedDataInfoEntries<Blob> | JsonPartitionedDataInfoEntries<Blob>,
+  axisFilters: AxisFilterByIdx[],
+): BinaryPartitionedDataInfoEntries<Blob> | JsonPartitionedDataInfoEntries<Blob>;
+export function filterDataInfoEntries(
+  dataInfoEntries: JsonDataInfoEntries,
+  axisFilters: AxisFilterByIdx[],
+): JsonDataInfoEntries;
+export function filterDataInfoEntries<Blob>(
+  dataInfoEntries: DataInfoEntries<Blob>,
+  axisFilters: AxisFilterByIdx[],
+): DataInfoEntries<Blob> {
+  // Sort filters by axis index in descending order to safely remove elements from arrays
+  const sortedFilters = [...axisFilters].sort((a, b) => b[0] - a[0]);
+
+  // Check for invalid filter axes
+  if (dataInfoEntries.type === 'JsonPartitioned' || dataInfoEntries.type === 'BinaryPartitioned') {
+    const { partitionKeyLength } = dataInfoEntries;
+    for (const [axisIdx] of axisFilters)
+      if (axisIdx >= partitionKeyLength)
+        throw new Error(`Can't filter on non-partitioned axis ${axisIdx}. Must be >= ${partitionKeyLength}`);
+  } else if (dataInfoEntries.type === 'Json') {
+    const { keyLength } = dataInfoEntries;
+    for (const [axisIdx] of axisFilters)
+      if (axisIdx >= keyLength)
+        throw new Error(`Can't filter on non-data axis ${axisIdx}. Must be >= ${keyLength}`);
+  }
+
+  const keyMatchesFilters = (key: PColumnKey): boolean => {
+    for (const [axisIdx, axisValue] of sortedFilters)
+      if (key[axisIdx] !== axisValue)
+        return false;
+    return true;
+  };
+
+  const removeFilteredAxes = (key: PColumnKey): PColumnKey => {
+    const newKey = [...key];
+
+    // Remove axes in descending order to maintain correct indices
+    for (const [axisIdx] of sortedFilters)
+      newKey.splice(axisIdx, 1);
+
+    return newKey;
+  };
+
+  switch (dataInfoEntries.type) {
+    case 'Json': {
+      const filteredData: PColumnDataEntry<PColumnValue>[] = dataInfoEntries.data
+        .filter((entry: PColumnDataEntry<PColumnValue>) => keyMatchesFilters(entry.key))
+        .map((entry: PColumnDataEntry<PColumnValue>) => ({
+          key: removeFilteredAxes(entry.key),
+          value: entry.value,
+        }));
+
+      return {
+        type: 'Json',
+        keyLength: dataInfoEntries.keyLength - axisFilters.length,
+        data: filteredData,
+      };
+    }
+
+    case 'JsonPartitioned': {
+      const filteredParts = dataInfoEntries.parts
+        .filter((entry: PColumnDataEntry<Blob>) => keyMatchesFilters(entry.key))
+        .map((entry: PColumnDataEntry<Blob>) => ({
+          key: removeFilteredAxes(entry.key),
+          value: entry.value,
+        }));
+
+      return {
+        type: 'JsonPartitioned',
+        partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+        parts: filteredParts,
+      };
+    }
+
+    case 'BinaryPartitioned': {
+      const filteredParts = dataInfoEntries.parts
+        .filter((entry: PColumnDataEntry<BinaryChunk<Blob>>) => keyMatchesFilters(entry.key))
+        .map((entry: PColumnDataEntry<BinaryChunk<Blob>>) => ({
+          key: removeFilteredAxes(entry.key),
+          value: entry.value,
+        }));
+
+      return {
+        type: 'BinaryPartitioned',
+        partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+        parts: filteredParts,
+      };
+    }
+  }
+}

package/src/render/util/index.ts

@@ -1,2 +1,3 @@
 export * from './pcolumn_data';
 export * from './label';
+export * from './axis_filtering';

package/src/render/util/pcolumn_data.ts

@@ -1,3 +1,12 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  type BinaryChunk,
+  type BinaryPartitionedDataInfoEntries,
+  type DataInfoEntries,
+  type JsonPartitionedDataInfoEntries,
+  type PColumnDataEntry,
+  type PColumnKey,
+} from '@milaboratories/pl-model-common';
 import type { TreeNodeAccessor } from '../accessor';
 
 const PCD_PREFIX = 'PColumnData/';
@@ -12,8 +21,6 @@ const PCD_SUP_PREFIX = PCD_PREFIX + 'Partitioned/';
 export const RT_JSON_SUPER_PARTITIONED = PCD_SUP_PREFIX + 'JsonPartitioned';
 export const RT_BINARY_SUPER_PARTITIONED = PCD_SUP_PREFIX + 'BinaryPartitioned';
 
-export type PColumnKey = (string | number)[];
-
 export type PColumnResourceMapEntry<T> = {
   key: PColumnKey;
   value: T;
@@ -95,13 +102,13 @@ export type PColumnKeyList = {
   keyLength: number;
 };
 
-const removeIndexSuffix = (keyStr: string): string | undefined => {
+const removeIndexSuffix = (keyStr: string): { baseKey: string; type: 'index' | 'values' } => {
   if (keyStr.endsWith('.index')) {
-    return undefined;
+    return { baseKey: keyStr.substring(0, keyStr.length - 6), type: 'index' };
   } else if (keyStr.endsWith('.values')) {
-    return keyStr.substring(0, keyStr.length - 7);
+    return { baseKey: keyStr.substring(0, keyStr.length - 7), type: 'values' };
   } else {
-    throw Error(`key must ends on .index/.values for binary p-column, got: ${keyStr}`);
+    throw new Error(`key must ends on .index/.values for binary p-column, got: ${keyStr}`);
   }
 };
 
@@ -144,9 +151,7 @@ export function getPartitionKeysList(
     case RT_BINARY_PARTITIONED:
       for (let keyStr of acc.listInputFields()) {
         if (rt === RT_BINARY_PARTITIONED) {
-          const k = removeIndexSuffix(keyStr);
-          if (!k) continue;
-          else keyStr = k;
+          keyStr = removeIndexSuffix(keyStr).baseKey;
         }
         const key = [...JSON.parse(keyStr)] as PColumnKey;
         data.push(key);
@@ -164,9 +169,7 @@ export function getPartitionKeysList(
         if (value !== undefined) {
           for (let keyStr of value.listInputFields()) {
             if (rt === RT_BINARY_SUPER_PARTITIONED) {
-              const k = removeIndexSuffix(keyStr);
-              if (!k) continue;
-              else keyStr = k;
+              keyStr = removeIndexSuffix(keyStr).baseKey;
             }
             const key = [...keyPrefix, ...JSON.parse(keyStr)] as PColumnKey;
             data.push(key);
@@ -206,3 +209,179 @@ export function getUniquePartitionKeys(
 
   return result.map((s) => Array.from(s.values()));
 }
+
+/**
+ * Parses the PColumn data from a TreeNodeAccessor into a DataInfoEntries structure.
+ * Returns undefined if any required data is missing.
+ * Throws error on validation failures.
+ *
+ * @param acc - The TreeNodeAccessor containing PColumn data
+ * @param keyPrefix - Optional key prefix for recursive calls
+ * @returns DataInfoEntries representation of the PColumn data, or undefined if incomplete
+ */
+export function parsePColumnData(
+  acc: TreeNodeAccessor | undefined,
+  keyPrefix: PColumnKey = [],
+): JsonPartitionedDataInfoEntries<TreeNodeAccessor> | BinaryPartitionedDataInfoEntries<TreeNodeAccessor> | undefined {
+  if (acc === undefined) return undefined;
+
+  const resourceType = acc.resourceType.name;
+  const meta = acc.getDataAsJson<Record<string, number>>();
+
+  // Prevent recursive super-partitioned resources
+  if (keyPrefix.length > 0
+    && (resourceType === RT_JSON_SUPER_PARTITIONED || resourceType === RT_BINARY_SUPER_PARTITIONED)) {
+    throw new Error(`Unexpected nested super-partitioned resource: ${resourceType}`);
+  }
+
+  switch (resourceType) {
+    case RT_RESOURCE_MAP:
+    case RT_RESOURCE_MAP_PARTITIONED:
+      throw new Error(`Only data columns are supported, got: ${resourceType}`);
+
+    case RT_JSON_PARTITIONED: {
+      if (typeof meta?.partitionKeyLength !== 'number') {
+        throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
+      }
+
+      const parts: PColumnDataEntry<TreeNodeAccessor>[] = [];
+      for (const keyStr of acc.listInputFields()) {
+        const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+        if (value === undefined) return undefined;
+
+        const key = [...keyPrefix, ...JSON.parse(keyStr)];
+        parts.push({ key, value });
+      }
+
+      return {
+        type: 'JsonPartitioned',
+        partitionKeyLength: meta.partitionKeyLength,
+        parts,
+      };
+    }
+
+    case RT_BINARY_PARTITIONED: {
+      if (typeof meta?.partitionKeyLength !== 'number') {
+        throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
+      }
+
+      const parts: PColumnDataEntry<BinaryChunk<TreeNodeAccessor>>[] = [];
+      const baseKeys = new Map<string, { index?: TreeNodeAccessor; values?: TreeNodeAccessor }>();
+
+      // Group fields by base key (without .index/.values suffix)
+      for (const keyStr of acc.listInputFields()) {
+        const suffix = removeIndexSuffix(keyStr);
+
+        const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+        if (value === undefined) return undefined;
+
+        let entry = baseKeys.get(suffix.baseKey);
+        if (!entry) {
+          entry = {};
+          baseKeys.set(suffix.baseKey, entry);
+        }
+
+        if (suffix.type === 'index') {
+          entry.index = value;
+        } else {
+          entry.values = value;
+        }
+      }
+
+      // Process complete binary chunks only
+      for (const [baseKeyStr, entry] of baseKeys.entries()) {
+        if (!entry.index || !entry.values) return undefined;
+
+        const key = [...keyPrefix, ...JSON.parse(baseKeyStr)];
+        parts.push({
+          key,
+          value: {
+            index: entry.index,
+            values: entry.values,
+          },
+        });
+      }
+
+      return {
+        type: 'BinaryPartitioned',
+        partitionKeyLength: meta.partitionKeyLength,
+        parts,
+      };
+    }
+
+    case RT_JSON_SUPER_PARTITIONED: {
+      if (typeof meta?.superPartitionKeyLength !== 'number'
+        || typeof meta?.partitionKeyLength !== 'number') {
+        throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
+      }
+
+      const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
+      const parts: PColumnDataEntry<TreeNodeAccessor>[] = [];
+
+      // Process all super partitions
+      for (const supKeyStr of acc.listInputFields()) {
+        const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: 'Input' });
+        if (superPartition === undefined) return undefined;
+
+        // Validate inner type
+        if (superPartition.resourceType.name !== RT_JSON_PARTITIONED) {
+          throw new Error(`Expected ${RT_JSON_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
+        }
+
+        const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr) as PColumnKey);
+
+        if (innerResult === undefined) return undefined;
+
+        if (innerResult.type !== 'JsonPartitioned')
+          throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
+
+        parts.push(...innerResult.parts);
+      }
+
+      return {
+        type: 'JsonPartitioned',
+        partitionKeyLength: totalKeyLength,
+        parts,
+      };
+    }
+
+    case RT_BINARY_SUPER_PARTITIONED: {
+      if (typeof meta?.superPartitionKeyLength !== 'number'
+        || typeof meta?.partitionKeyLength !== 'number') {
+        throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
+      }
+
+      const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
+      const parts: PColumnDataEntry<BinaryChunk<TreeNodeAccessor>>[] = [];
+
+      // Process all super partitions
+      for (const supKeyStr of acc.listInputFields()) {
+        const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: 'Input' });
+        if (superPartition === undefined) return undefined;
+
+        // Validate inner type
+        if (superPartition.resourceType.name !== RT_BINARY_PARTITIONED) {
+          throw new Error(`Expected ${RT_BINARY_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
+        }
+
+        const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr) as PColumnKey);
+
+        if (innerResult === undefined) return undefined;
+
+        if (innerResult.type !== 'BinaryPartitioned')
+          throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
+
+        parts.push(...innerResult.parts);
+      }
+
+      return {
+        type: 'BinaryPartitioned',
+        partitionKeyLength: totalKeyLength,
+        parts,
+      };
+    }
+
+    default:
+      throw new Error(`Unknown resource type: ${resourceType}`);
+  }
+}