@platforma-sdk/model 1.70.0 → 1.72.0

package/src/columns/column_snapshot_provider.ts

@@ -1,11 +1,9 @@
 import type { PObjectId } from "@milaboratories/pl-model-common";
-import { PColumn } from "@milaboratories/pl-model-common";
+import { isDataInfo, PColumn, visitDataInfo } from "@milaboratories/pl-model-common";
 import { TreeNodeAccessor } from "../render/accessor";
 import type { PColumnDataUniversal } from "../render/internal";
 import type { ColumnDataStatus, ColumnSnapshot } from "./column_snapshot";
 
-// --- ColumnProvider ---
-
 /**
  * Data source interface for column enumeration.
  *
@@ -22,8 +20,6 @@ export interface ColumnSnapshotProvider {
   isColumnListComplete(): boolean;
 }
 
-// --- ColumnSource ---
-
 /**
  * Union of types that can serve as column sources for helpers and builders.
  * Does NOT include TreeNodeAccessor — call `.toColumnSource()` on it first.
@@ -33,8 +29,6 @@ export type ColumnSource =
   | ColumnSnapshot<PObjectId>[]
   | PColumn<PColumnDataUniversal | undefined>[];
 
-// --- ArrayColumnProvider ---
-
 /**
  * Simple provider wrapping an array of PColumns.
  * Always complete, data status always 'ready'.
@@ -46,8 +40,8 @@ export class ArrayColumnProvider implements ColumnSnapshotProvider {
     this.columns = columns.map((col) => ({
       id: col.id,
       spec: col.spec,
-      dataStatus: "ready" as const,
       data: { get: () => col.data },
+      dataStatus: this.getStatus(col.data),
     }));
   }
 
@@ -58,9 +52,35 @@ export class ArrayColumnProvider implements ColumnSnapshotProvider {
   isColumnListComplete(): boolean {
     return true;
   }
-}
 
-// --- SnapshotColumnProvider ---
+  protected getStatus(
+    d: undefined | PColumnDataUniversal | (() => undefined | PColumnDataUniversal),
+  ): ColumnDataStatus {
+    if (d == null) {
+      return "absent";
+    }
+    if (typeof d === "function") {
+      return this.getStatus(d());
+    }
+    if (d instanceof TreeNodeAccessor) {
+      if (d.getIsReadyOrError()) return "ready";
+      if (d.getIsFinal()) return "absent";
+      return "computing";
+    }
+    if (isDataInfo(d)) {
+      let ready = true;
+      let final = true;
+      visitDataInfo(d, (v) => {
+        ready &&= v.getIsReadyOrError();
+        final &&= v.getIsFinal();
+      });
+      if (ready) return "ready";
+      if (final) return "absent";
+      return "computing";
+    }
+    return "ready";
+  }
+}
 
 /**
  * Provider wrapping an array of ColumnSnapshots.
@@ -78,8 +98,6 @@ export class SnapshotColumnProvider implements ColumnSnapshotProvider {
   }
 }
 
-// --- OutputColumnProvider ---
-
 export interface OutputColumnProviderOpts {
   /** When true and the accessor is final, columns with no ready data get status 'absent'. */
   allowPermanentAbsence?: boolean;
@@ -133,8 +151,6 @@ export class OutputColumnProvider implements ColumnSnapshotProvider {
   }
 }
 
-// --- Source normalization ---
-
 /** Checks if a value is a ColumnSnapshotProvider (duck-typing). */
 export function isColumnSnapshotProvider(source: unknown): source is ColumnSnapshotProvider {
   return (

package/src/components/PlDataTable/createPlDataTable/createPlDataTableV3.ts

@@ -32,6 +32,7 @@ import {
   withLabelAnnotations,
   withTableVisualAnnotations,
   withInfoAnnotations,
+  withDataStatusAnnotations,
 } from "./utils";
 import type { PrimaryEntry, SecondaryGroup } from "./createPTableDefV3";
 import { createPTableDefV3 } from "./createPTableDefV3";
@@ -79,8 +80,6 @@ export type ColumnVisibilityRule = {
 
 export type ColumnMatcher = (spec: PColumnSpec) => boolean;
 
-// Main Function
-
 export function createPlDataTableV3<A, U>(
   ctx: RenderCtxBase<A, U>,
   options: createPlDataTableOptionsV3,
@@ -138,17 +137,18 @@ export function createPlDataTableV3<A, U>(
   ]);
 
   const remapedDefaultFilters = remapFilterColumnIds(options.filters, discovered);
-  const filters = concatFilters(
-    state.pTableParams.filters,
-    state.pTableParams.defaultFilters ?? remapedDefaultFilters,
+  const filters = filterFilters(
+    concatFilters(
+      state.pTableParams.filters,
+      state.pTableParams.defaultFilters ?? remapedDefaultFilters,
+    ),
+    columnIsAvailable,
   );
-  validateFilters(filters, columnIsAvailable);
 
-  const sorting = resolveSorting(
-    state.pTableParams.sorting,
-    remapSortingColumnIds(options.sorting, discovered),
+  const sorting = filterSorting(
+    resolveSorting(state.pTableParams.sorting, remapSortingColumnIds(options.sorting, discovered)),
+    columnIsAvailable,
   );
-  validateSorting(sorting, columnIsAvailable);
 
   const primaryEntries: PrimaryEntry<undefined | PColumnDataUniversal>[] = primarySnapshots.map(
     (v) => ({ column: resolveSnapshot(v.column) }),
@@ -274,6 +274,7 @@ function annotateColumnGroups(params: {
   const directAnnotated = liftToVariantColumns(
     direct,
     flow(
+      (cols) => withDataStatusAnnotations(cols),
       (cols) => withLabelAnnotations(derivedLabels, cols),
       (cols) => withInfoAnnotations(derivedTooltips, cols),
       (cols) => withTableVisualAnnotations(visibilityByColId, orderByColId, cols),
@@ -283,6 +284,7 @@ function annotateColumnGroups(params: {
   const linkedAnnotated = liftToVariantColumns(
     linked,
     flow(
+      (cols) => withDataStatusAnnotations(cols),
       (cols) => withHidenAxesAnnotations(cols),
       (cols) => withLabelAnnotations(derivedLabels, cols),
       (cols) => withInfoAnnotations(derivedTooltips, cols),
@@ -344,19 +346,35 @@ function createColumnValidationById(
   };
 }
 
-/** Validate that all column references in filters exist in the table. */
-function validateFilters(
+/** Drop filter leaves whose column references are not available in the table. */
+function filterFilters(
   filters: Nil | PlDataTableFilters,
   isValidColumnId: (id: string) => boolean,
-): void {
-  if (filters == null) return;
-  const filterColumns = collectFilterSpecColumns(filters);
-  const firstInvalid = filterColumns.find((col) => !isValidColumnId(col));
-  if (firstInvalid !== undefined) {
-    throw new Error(
-      `Invalid filter column ${firstInvalid}: column reference does not match the table columns`,
-    );
-  }
+): Nil | PlDataTableFilters {
+  if (isNil(filters)) return filters;
+
+  const isLeafValid = (leaf: PlDataTableFilterSpecLeaf): boolean => {
+    if (leaf.type === undefined) return true;
+    if ("column" in leaf && !isValidColumnId(leaf.column)) return false;
+    if ("rhs" in leaf && !isValidColumnId(leaf.rhs)) return false;
+    return true;
+  };
+
+  const prune = (node: PlDataTableFilterNode): Nil | PlDataTableFilterNode => {
+    if (node.type === "and" || node.type === "or") {
+      const kept = node.filters
+        .map((f) => prune(f))
+        .filter((f): f is PlDataTableFilterNode => !isNil(f));
+      return { type: node.type, filters: kept };
+    }
+    if (node.type === "not") {
+      const inner = prune(node.filter);
+      return isNil(inner) ? undefined : { type: "not", filter: inner };
+    }
+    return isLeafValid(node) ? node : undefined;
+  };
+
+  return prune(filters) as Nil | PlDataTableFilters;
 }
 
 /** Merge two filter trees into one AND-combined tree. Returns the non-nil one if the other is nil. */
@@ -377,16 +395,12 @@ function resolveSorting(
   return (isEmpty(userSorting) ? defaultSorting : userSorting) ?? [];
 }
 
-/** Validate that all column references in sorting exist in the table. */
-function validateSorting(sorting: PTableSorting[], isValidColumnId: (id: string) => boolean): void {
-  const firstInvalid = sorting.find(
-    (s) => !isValidColumnId(canonicalizeJson<PTableColumnId>(s.column)),
-  );
-  if (firstInvalid !== undefined) {
-    throw new Error(
-      `Invalid sorting column ${JSON.stringify(firstInvalid.column)}: column reference does not match the table columns`,
-    );
-  }
+/** Drop sorting entries whose column is not available in the table. */
+function filterSorting(
+  sorting: PTableSorting[],
+  isValidColumnId: (id: string) => boolean,
+): PTableSorting[] {
+  return sorting.filter((s) => isValidColumnId(canonicalizeJson<PTableColumnId>(s.column)));
 }
 
 function buildSecondaryGroups(
@@ -473,21 +487,22 @@ function remapSortingColumnIds(
   sorting: Nil | PTableSorting[],
   columns: TableColumnVariant[],
 ): Nil | PTableSorting[] {
-  return sorting?.map((s) => {
-    if (s.column.type === "axis") return s; // Axis references are unaffected by column ID remapping
+  return sorting?.flatMap((s) => {
+    if (s.column.type === "axis") return [s]; // Axis references are unaffected by column ID remapping
 
     const id = s.column.id;
-    const column =
-      columns.find((c) => (c.originalId ?? c.column.id) === id) ??
-      throwError(`Column ID "${id}" in sorting does not match any discovered column`);
-
-    return {
-      ...s,
-      column: {
-        type: "column",
-        id: column.column.id,
+    const column = columns.find((c) => (c.originalId ?? c.column.id) === id);
+    if (column === undefined) return [];
+
+    return [
+      {
+        ...s,
+        column: {
+          type: "column" as const,
+          id: column.column.id,
+        },
       },
-    };
+    ];
   });
 }
 

package/src/components/PlDataTable/createPlDataTable/utils.ts

@@ -17,7 +17,7 @@ import {
   deriveDistinctTooltips,
   type TooltipEntry,
 } from "../../../labels/derive_distinct_tooltips";
-import type { MatchQualifications, MatchVariant } from "../../../columns";
+import type { ColumnDataStatus, MatchQualifications, MatchVariant } from "../../../columns";
 import type { ColumnMatcher, ColumnOrderRule, ColumnVisibilityRule } from "./createPlDataTableV3";
 import type { ColumnSelector } from "../../../columns";
 import { ArrayColumnProvider, ColumnCollectionBuilder } from "../../../columns";
@@ -130,7 +130,10 @@ function dedupeById(columns: RuleColumn[]): RuleColumn[] {
  * For each axis in column specs: writes derived axis label into AxisSpec annotations.
  */
 export function withLabelAnnotations<
-  T extends { readonly id: PObjectId; readonly spec: PColumnSpec },
+  T extends {
+    readonly id: PObjectId;
+    readonly spec: PColumnSpec;
+  },
 >(derivedLabels: undefined | Record<string, string>, columns: T[]): T[] {
   if (derivedLabels === undefined) return columns;
   return columns.map((col) => {
@@ -153,6 +156,26 @@ export function withLabelAnnotations<
   });
 }
 
+export function withDataStatusAnnotations<
+  T extends {
+    readonly spec: PColumnSpec;
+    readonly dataStatus: ColumnDataStatus;
+  },
+>(columns: T[]): T[] {
+  return columns.map((col) => {
+    return {
+      ...col,
+      spec: {
+        ...col.spec,
+        annotations: {
+          ...col.spec.annotations,
+          [Annotation.DataStatus]: col.dataStatus,
+        },
+      },
+    } as T;
+  });
+}
+
 /**
  * Writes effective display properties (OrderPriority, Visibility) from precomputed rule maps
  * into column annotations. Returns new column objects — originals are not mutated.

package/src/render/api.ts

@@ -29,10 +29,8 @@ import type {
 } from "@milaboratories/pl-model-common";
 import {
   AnchoredIdDeriver,
-  collectSpecQueryColumns,
   ensurePColumn,
   parseJson,
-  extractAllColumns,
   isDataInfo,
   isPColumn,
   isPColumnSpec,
@@ -46,6 +44,7 @@ import {
   readAnnotation,
   withEnrichments,
   legacyColumnSelectorsToPredicate,
+  extractAllColumns,
 } from "@milaboratories/pl-model-common";
 import canonicalize from "canonicalize";
 import type { Optional } from "utility-types";
@@ -70,9 +69,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/pcolumn_data";
 import type { PColumnDataUniversal } from "./internal";
 import { getService } from "../services";
+import { allPColumnsReady } from "./util";
 
 /**
  * Helper function to match domain objects
@@ -97,7 +96,7 @@ export type UniversalColumnOption = { label: string; value: SUniversalPColumnId
  * @returns Transformed data compatible with platform API
  */
 function transformPColumnData(
-  data: PColumn<PColumnDataUniversal> | PColumnLazy<PColumnDataUniversal>,
+  data: PColumn<undefined | PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>,
 ): PColumn<PColumnValues | AccessorHandle | DataInfo<AccessorHandle>> {
   return mapPObjectData(data, (d) => {
     if (d instanceof TreeNodeAccessor) {
@@ -105,7 +104,7 @@ function transformPColumnData(
     } else if (isDataInfo(d)) {
       return mapDataInfo(d, (accessor) => accessor.handle);
     } else {
-      return d;
+      return d ?? [];
     }
   });
 }
@@ -663,8 +662,6 @@ export abstract class RenderCtxBase<Args = unknown, Data = unknown> {
       PColumn<undefined | PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>
     >,
   ): PFrameHandle | undefined {
-    if (!allPColumnsReady(def)) return undefined;
-    this.verifyInlineAndExplicitColumnsSupport(def);
     return this.ctx.createPFrame(def.map((c) => transformPColumnData(c)));
   }
 
@@ -709,16 +706,7 @@ export abstract class RenderCtxBase<Args = unknown, Data = unknown> {
   public createPTableV2(
     def: PTableDefV2<PColumn<undefined | PColumnDataUniversal>>,
   ): PTableHandle | undefined {
-    const columns = collectSpecQueryColumns(def.query);
-    if (!allPColumnsReady(columns)) return undefined;
-    this.verifyInlineAndExplicitColumnsSupport(columns);
-    return this.ctx.createPTableV2(
-      mapPTableDefV2(def, (po) => {
-        if (po.data === undefined)
-          throw new Error("unreachable: column data undefined after readiness check");
-        return transformPColumnData({ id: po.id, spec: po.spec, data: po.data });
-      }),
-    );
+    return this.ctx.createPTableV2(mapPTableDefV2(def, (po) => transformPColumnData(po)));
   }
 
   /** @deprecated scheduled for removal from SDK */