@platforma-sdk/model 1.53.15 → 1.54.7

package/src/filters/converters/filterToQuery.ts

@@ -0,0 +1,258 @@
+import { assertNever } from "@milaboratories/pl-model-common";
+import type {
+  FilterSpec,
+  FilterSpecLeaf,
+  PTableColumnId,
+  SingleAxisSelector,
+  SpecQueryExpression,
+} from "@milaboratories/pl-model-common";
+
+/** Parses a CanonicalizedJson<PTableColumnId> string into a SpecQueryExpression reference. */
+function resolveColumnRef(columnStr: string): SpecQueryExpression {
+  const parsed = JSON.parse(columnStr) as PTableColumnId;
+  if (parsed.type === "axis") {
+    return { type: "axisRef", value: parsed.id as SingleAxisSelector };
+  }
+  return { type: "columnRef", value: parsed.id };
+}
+
+/** Converts a FilterSpec tree into a SpecQueryExpression. */
+export function filterSpecToSpecQueryExpr(
+  filter: FilterSpec<FilterSpecLeaf<string>>,
+): SpecQueryExpression {
+  switch (filter.type) {
+    case "and":
+    case "or": {
+      const inputs = filter.filters
+        .filter((f) => f.type !== undefined)
+        .map(filterSpecToSpecQueryExpr);
+      if (inputs.length === 0) {
+        throw new Error(`${filter.type.toUpperCase()} filter requires at least one operand`);
+      }
+      return { type: filter.type, input: inputs };
+    }
+    case "not":
+      return { type: "not", input: filterSpecToSpecQueryExpr(filter.filter) };
+
+    case "patternEquals":
+      return {
+        type: "stringEquals",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+        caseInsensitive: false,
+      };
+    case "patternNotEquals":
+      return {
+        type: "not",
+        input: {
+          type: "stringEquals",
+          input: resolveColumnRef(filter.column),
+          value: filter.value,
+          caseInsensitive: false,
+        },
+      };
+    case "patternContainSubsequence":
+      return {
+        type: "stringContains",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+        caseInsensitive: false,
+      };
+    case "patternNotContainSubsequence":
+      return {
+        type: "not",
+        input: {
+          type: "stringContains",
+          input: resolveColumnRef(filter.column),
+          value: filter.value,
+          caseInsensitive: false,
+        },
+      };
+    case "patternMatchesRegularExpression":
+      return {
+        type: "stringRegex",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+      };
+    case "patternFuzzyContainSubsequence":
+      return {
+        type: "stringContainsFuzzy",
+        input: resolveColumnRef(filter.column),
+        value: filter.value,
+        maxEdits: filter.maxEdits ?? 1,
+        caseInsensitive: false,
+        substitutionsOnly: filter.substitutionsOnly ?? false,
+        wildcard: filter.wildcard ?? null,
+      };
+
+    case "equal":
+      return {
+        type: "numericComparison",
+        operand: "eq",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "notEqual":
+      return {
+        type: "numericComparison",
+        operand: "ne",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "lessThan":
+      return {
+        type: "numericComparison",
+        operand: "lt",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "greaterThan":
+      return {
+        type: "numericComparison",
+        operand: "gt",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "lessThanOrEqual":
+      return {
+        type: "numericComparison",
+        operand: "le",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+    case "greaterThanOrEqual":
+      return {
+        type: "numericComparison",
+        operand: "ge",
+        left: resolveColumnRef(filter.column),
+        right: { type: "constant", value: filter.x },
+      };
+
+    case "equalToColumn":
+      return {
+        type: "numericComparison",
+        operand: "eq",
+        left: resolveColumnRef(filter.column),
+        right: resolveColumnRef(filter.rhs),
+      };
+    case "lessThanColumn": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "lt",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "lt", left, right };
+    }
+    case "greaterThanColumn": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "gt",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "gt", left, right };
+    }
+    case "lessThanColumnOrEqual": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "le",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "le", left, right };
+    }
+    case "greaterThanColumnOrEqual": {
+      const left = resolveColumnRef(filter.column);
+      const right = resolveColumnRef(filter.rhs);
+      if (filter.minDiff !== undefined && filter.minDiff !== 0) {
+        return {
+          type: "numericComparison",
+          operand: "ge",
+          left: {
+            type: "numericBinary",
+            operand: "add",
+            left,
+            right: { type: "constant", value: filter.minDiff },
+          },
+          right,
+        };
+      }
+      return { type: "numericComparison", operand: "ge", left, right };
+    }
+
+    case "inSet":
+      return {
+        type: "isIn",
+        input: resolveColumnRef(filter.column),
+        set: filter.value,
+      };
+    case "notInSet":
+      return {
+        type: "not",
+        input: {
+          type: "isIn",
+          input: resolveColumnRef(filter.column),
+          set: filter.value,
+        },
+      };
+
+    case "isNA":
+      return {
+        type: "isNull",
+        input: resolveColumnRef(filter.column),
+      };
+    case "isNotNA":
+      return {
+        type: "not",
+        input: {
+          type: "isNull",
+          input: resolveColumnRef(filter.column),
+        },
+      };
+
+    case "ifNa":
+      return {
+        type: "ifNull",
+        input: resolveColumnRef(filter.column),
+        replacement: { type: "constant", value: filter.replacement },
+      };
+
+    case "topN":
+    case "bottomN":
+      throw new Error(`Filter type "${filter.type}" is not supported in query expressions`);
+
+    case undefined:
+      throw new Error("Filter type is undefined");
+
+    default:
+      assertNever(filter);
+  }
+}

package/src/filters/{converter.test.ts → converters/filterUiToExpressionImpl.test.ts}

@@ -1,7 +1,7 @@
 import type { SUniversalPColumnId } from "@milaboratories/pl-model-common";
 import { describe, expect, it } from "vitest";
-import { convertFilterUiToExpressions } from "./converter";
-import { FilterSpec } from "./types";
+import { convertFilterUiToExpressions } from "./filterUiToExpressionImpl";
+import { FilterSpec } from "../types";
 
 describe("convertFilterUiToExpressions", () => {
   it('should compile "or" filter to ptabler expression', () => {

package/src/filters/{converter.ts → converters/filterUiToExpressionImpl.ts}

@@ -8,7 +8,7 @@ import {
   type Expression,
   type ExpressionImpl,
 } from "@milaboratories/ptabler-expression-js";
-import type { FilterSpec } from "../filters";
+import type { FilterSpec } from "../types";
 
 export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionImpl {
   if (value.type === "or") {
@@ -127,7 +127,8 @@ export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionIm
     value.type === "patternMatchesRegularExpression" ||
     value.type === "patternFuzzyContainSubsequence" ||
     value.type === "inSet" ||
-    value.type === "notInSet"
+    value.type === "notInSet" ||
+    value.type === "ifNa"
   ) {
     throw new Error("Not implemented filter type: " + value.type);
   }

package/src/filters/converters/index.ts

@@ -0,0 +1,2 @@
+export * from "./filterToQuery";
+export * from "./filterUiToExpressionImpl";

package/src/filters/distill.ts

@@ -0,0 +1,59 @@
+import { DistributiveKeys, UnionToTuples } from "@milaboratories/helpers";
+import {
+  type FilterSpec,
+  type FilterSpecLeaf,
+  type PTableFilters,
+} from "@milaboratories/pl-model-common";
+
+/** All possible field names that can appear in any FilterSpecLeaf variant. */
+type FilterSpecLeafKey = DistributiveKeys<FilterSpecLeaf<string>>;
+
+/** Compile-time check: every key in the tuple is a valid leaf key (via satisfies). */
+const KNOWN_LEAF_KEYS_TUPLE: UnionToTuples<FilterSpecLeafKey> = [
+  "n",
+  "x",
+  "rhs",
+  "type",
+  "value",
+  "column",
+  "minDiff",
+  "maxEdits",
+  "wildcard",
+  "replacement",
+  "substitutionsOnly",
+];
+const KNOWN_LEAF_KEYS: Set<FilterSpecLeafKey> = new Set(KNOWN_LEAF_KEYS_TUPLE);
+
+type UnknownFilterNode = FilterSpec<
+  FilterSpecLeaf<string>,
+  Record<string, unknown>,
+  Record<string, unknown>
+>;
+
+function distillLeaf(node: Record<string, unknown>): FilterSpecLeaf<string> {
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (KNOWN_LEAF_KEYS.has(key as FilterSpecLeafKey)) {
+      result[key] = value;
+    }
+  }
+  return result as FilterSpecLeaf<string>;
+}
+
+function distillNode(node: UnknownFilterNode): FilterSpec<FilterSpecLeaf<string>> {
+  switch (node.type) {
+    case "and":
+    case "or":
+      return { type: node.type, filters: node.filters.map(distillNode) };
+    case "not":
+      return { type: "not", filter: distillNode(node.filter) };
+    default:
+      return distillLeaf(node as Record<string, unknown>);
+  }
+}
+
+/** Strips all non-FilterSpec metadata from the filter tree (whitelist approach). */
+export function distillFilter(filter: UnknownFilterNode | null | undefined): PTableFilters {
+  if (filter == null) return null;
+  return distillNode(filter);
+}

package/src/filters/index.ts

@@ -1,2 +1,3 @@
-export * from "./converter";
+export * from "./converters";
+export * from "./distill";
 export * from "./types";

package/src/filters/types.ts

@@ -8,51 +8,11 @@ export type SimplifiedUniversalPColumnEntry = {
   obj: SimplifiedPColumnSpec;
 };
 
-export type FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> =
-  | (CommonLeaf & Leaf)
-  | (CommonNode & { type: "not"; filter: FilterSpecNode<Leaf, CommonNode, CommonLeaf> })
-  | (CommonNode & { type: "or"; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] })
-  | (CommonNode & { type: "and"; filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[] });
-
-export type FilterSpecLeaf<T = SUniversalPColumnId> =
-  | { type: undefined }
-  | { type: "isNA"; column: T }
-  | { type: "isNotNA"; column: T }
-  | { type: "patternEquals"; column: T; value: string }
-  | { type: "patternNotEquals"; column: T; value: string }
-  | { type: "patternContainSubsequence"; column: T; value: string }
-  | { type: "patternNotContainSubsequence"; column: T; value: string }
-  | { type: "patternMatchesRegularExpression"; column: T; value: string }
-  | {
-      type: "patternFuzzyContainSubsequence";
-      column: T;
-      value: string;
-      maxEdits?: number;
-      substitutionsOnly?: boolean;
-      wildcard?: string;
-    }
-  | { type: "inSet"; column: T; value: string[] }
-  | { type: "notInSet"; column: T; value: string[] }
-  | { type: "topN"; column: T; n: number }
-  | { type: "bottomN"; column: T; n: number }
-  | { type: "equal"; column: T; x: number }
-  | { type: "notEqual"; column: T; x: number }
-  | { type: "lessThan"; column: T; x: number }
-  | { type: "greaterThan"; column: T; x: number }
-  | { type: "lessThanOrEqual"; column: T; x: number }
-  | { type: "greaterThanOrEqual"; column: T; x: number }
-  | { type: "equalToColumn"; column: T; rhs: T }
-  | { type: "lessThanColumn"; column: T; rhs: T; minDiff?: number }
-  | { type: "greaterThanColumn"; column: T; rhs: T; minDiff?: number }
-  | { type: "lessThanColumnOrEqual"; column: T; rhs: T; minDiff?: number }
-  | { type: "greaterThanColumnOrEqual"; column: T; rhs: T; minDiff?: number };
-
-export type FilterSpec<
-  Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>,
-  CommonNode = {},
-  CommonLeaf = CommonNode,
-> = FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
-
-export type FilterSpecType = Exclude<FilterSpec, { type: undefined }>["type"];
-
-export type FilterSpecOfType<T extends FilterSpecType> = Extract<FilterSpec, { type: T }>;
+export type {
+  FilterSpecNode,
+  FilterSpecLeaf,
+  FilterSpec,
+  FilterSpecType,
+  FilterSpecOfType,
+  PTableFilters,
+} from "@milaboratories/pl-model-common";

package/src/pframe_utils/querySpec.ts

@@ -0,0 +1 @@
+export { collectQueryColumns, isBooleanExpression } from "@milaboratories/pl-model-common";

package/src/render/api.ts

@@ -16,6 +16,7 @@ import type {
   PObjectSpec,
   PSpecPredicate,
   PTableDef,
+  PTableDefV2,
   PTableHandle,
   PTableRecordFilter,
   PTableSorting,
@@ -36,6 +37,7 @@ import {
   mapDataInfo,
   mapPObjectData,
   mapPTableDef,
+  mapPTableDefV2,
   mapValueInVOE,
   PColumnName,
   readAnnotation,
@@ -58,12 +60,9 @@ import type { LabelDerivationOps } from "./util/label";
 import { deriveLabels } from "./util/label";
 import type { APColumnSelectorWithSplit } from "./util/split_selectors";
 import { patchInSetFilters } from "./util/pframe_upgraders";
-import { allPColumnsReady } from "./util";
-
-export type PColumnDataUniversal<TreeEntry = TreeNodeAccessor> =
-  | TreeEntry
-  | DataInfo<TreeEntry>
-  | PColumnValues;
+import { allPColumnsReady } from "./util/pcolumn_data";
+import type { PColumnDataUniversal } from "./internal";
+import { collectQueryColumns } from "@milaboratories/pl-model-common";
 
 /**
  * Helper function to match domain objects
@@ -682,6 +681,13 @@ export abstract class RenderCtxBase<Args, Data> {
     return this.ctx.createPTable(mapPTableDef(rawDef, (po) => transformPColumnData(po)));
   }
 
+  public createPTableV2(def: PTableDefV2<PColumn<PColumnDataUniversal>>): PTableHandle | undefined {
+    const columns = collectQueryColumns(def.query);
+    this.verifyInlineAndExplicitColumnsSupport(columns);
+    if (!allPColumnsReady(columns)) return undefined;
+    return this.ctx.createPTableV2(mapPTableDefV2(def, (po) => transformPColumnData(po)));
+  }
+
   /** @deprecated scheduled for removal from SDK */
   public getBlockLabel(blockId: string): string {
     return this.ctx.getBlockLabel(blockId);
@@ -721,6 +727,7 @@ export class RenderCtx<Args, Data> extends RenderCtxBase<Args, Data> {
 /** Render context for legacy v1/v2 blocks - provides backward compatibility */
 export class RenderCtxLegacy<Args, UiState> extends RenderCtxBase<Args, UiState> {
   private _argsCache?: { v: Args };
+
   public get args(): Args {
     if (this._argsCache === undefined) {
       const raw = this.ctx.args;

package/src/render/index.ts

@@ -2,5 +2,6 @@ export * from "./api";
 export * from "./traversal_ops";
 export * from "./accessor";
 export * from "./util";
-export { type ExtractFutureRefType } from "./future";
 export { FutureRef } from "./future";
+export type { PColumnDataUniversal } from "./internal";
+export type { ExtractFutureRefType } from "./future";

package/src/render/internal.ts

@@ -13,12 +13,14 @@ import type {
   PObjectSpec,
   PSpecPredicate,
   PTableDef,
+  PTableDefV2,
   PTableHandle,
   ResultCollection,
   ValueOrError,
   DataInfo,
   RangeBytes,
 } from "@milaboratories/pl-model-common";
+import type { TreeNodeAccessor } from "./accessor";
 
 export const StagingAccessorName = "staging";
 export const MainAccessorName = "main";
@@ -26,6 +28,11 @@ export const MainAccessorName = "main";
 export type AccessorHandle = Branded<string, "AccessorHandle">;
 export type FutureHandle = Branded<string, "FutureHandle">;
 
+export type PColumnDataUniversal<TreeEntry = TreeNodeAccessor> =
+  | TreeEntry
+  | DataInfo<TreeEntry>
+  | PColumnValues;
+
 export interface GlobalCfgRenderCtxMethods<AHandle = AccessorHandle, FHandle = FutureHandle> {
   //
   // Root accessor creation
@@ -146,6 +153,10 @@ export interface GlobalCfgRenderCtxMethods<AHandle = AccessorHandle, FHandle = F
 
   createPTable(def: PTableDef<PColumn<AHandle | PColumnValues | DataInfo<AHandle>>>): PTableHandle;
 
+  createPTableV2(
+    def: PTableDefV2<PColumn<AHandle | PColumnValues | DataInfo<AHandle>>>,
+  ): PTableHandle;
+
   //
   // Computable
   //

package/src/render/util/column_collection.ts

@@ -33,7 +33,7 @@ import {
 import canonicalize from "canonicalize";
 import type { Optional } from "utility-types";
 import type { TreeNodeAccessor } from "../accessor";
-import type { PColumnDataUniversal } from "../api";
+import type { PColumnDataUniversal } from "../internal";
 import { filterDataInfoEntries } from "./axis_filtering";
 import type { LabelDerivationOps, TraceEntry } from "./label";
 import { deriveLabels } from "./label";

package/src/render/util/pcolumn_data.ts

@@ -16,7 +16,7 @@ import {
   type PColumnKey,
 } from "@milaboratories/pl-model-common";
 import { TreeNodeAccessor } from "../accessor";
-import type { PColumnDataUniversal } from "../api";
+import type { PColumnDataUniversal } from "../internal";
 
 const PCD_PREFIX = "PColumnData/";