@platforma-sdk/model 1.71.0 → 1.73.0

package/src/components/PlDatasetSelector/build_dataset_options.ts

@@ -2,22 +2,42 @@ import type { MultiColumnSelector, Option, PObjectSpec } from "@milaboratories/p
 import { multiColumnSelectorsToPredicate } from "@milaboratories/pl-model-common";
 import type { DeriveLabelsOptions } from "../../labels/derive_distinct_labels";
 import type { RenderCtxBase } from "../../render";
+import type { AnchoredColumnCollection } from "../../columns/column_collection_builder";
 import { ColumnCollectionBuilder } from "../../columns/column_collection_builder";
-import { collectCtxColumnSnapshotProviders } from "../../columns/ctx_column_sources";
+import {
+  ResultPoolColumnSnapshotProvider,
+  collectCtxColumnSnapshotProviders,
+} from "../../columns/ctx_column_sources";
 import type { DatasetOption } from "./dataset_selection";
 import { buildRefMap, filterMatchesToOptions, findFilterColumns } from "./filter_discovery";
 import { enrichmentVariantsToRefs, findEnrichmentColumns } from "./enrichment_discovery";
 
+type SpecPredicateOption =
+  | MultiColumnSelector
+  | MultiColumnSelector[]
+  | ((spec: PObjectSpec) => boolean);
+
+function toPredicate(opt: SpecPredicateOption | undefined): (spec: PObjectSpec) => boolean {
+  if (opt === undefined) return () => true;
+  return typeof opt === "function" ? opt : multiColumnSelectorsToPredicate(opt);
+}
+
 export type BuildDatasetOptions = {
   /** Which result pool columns qualify as datasets. Defaults to all. */
-  primary?: MultiColumnSelector | MultiColumnSelector[] | ((spec: PObjectSpec) => boolean);
+  primary?: SpecPredicateOption;
+  /**
+   * Restricts which result pool columns are considered as filters. Intersected
+   * with the built-in `pl7.app/isSubset: "true"` constraint. Defaults to
+   * accept-all.
+   */
+  filter?: SpecPredicateOption;
   /** Formatting options for filter labels. */
   labelOptions?: DeriveLabelsOptions;
   /**
    * Enables enrichment discovery and filters hits attached to
    * `DatasetOption.enrichments`. Use `() => true` to accept all; omit to disable.
    */
-  withEnrichments?: MultiColumnSelector | MultiColumnSelector[] | ((spec: PObjectSpec) => boolean);
+  withEnrichments?: SpecPredicateOption;
   /** Maximum linker hops considered. Only used when `withEnrichments` is set. */
   enrichmentMaxHops?: number;
 };
@@ -32,46 +52,62 @@ export function buildDatasetOptions(
   ctx: RenderCtxBase,
   opts?: BuildDatasetOptions,
 ): DatasetOption[] | undefined {
-  const primary = opts?.primary;
-  const primaryPredicate =
-    primary === undefined
-      ? () => true
-      : typeof primary === "function"
-        ? primary
-        : multiColumnSelectorsToPredicate(primary);
+  const primaryPredicate = toPredicate(opts?.primary);
+  const filterPredicate = toPredicate(opts?.filter);
+
   const options = ctx.resultPool.getOptions(primaryPredicate, { refsWithEnrichments: true });
   if (options.length === 0) return [];
 
-  const columnSources = collectCtxColumnSnapshotProviders(ctx);
   const refMap = buildRefMap(ctx.resultPool.getSpecs().entries);
   const pframeSpec = ctx.getService("pframeSpec");
 
+  const withEnrichments = opts?.withEnrichments ?? false;
+  const filterSource = new ResultPoolColumnSnapshotProvider(ctx.resultPool);
+  // Hoisted out of the per-option loop: collectCtxColumnSnapshotProviders
+  // walks the entire output tree, so calling it once per dataset option would
+  // be O(N × tree).
+  const enrichmentSources = withEnrichments ? collectCtxColumnSnapshotProviders(ctx) : undefined;
+
   return options.map((primary: Option): DatasetOption => {
     const datasetSpec = ctx.resultPool.getPColumnSpecByRef(primary.ref);
     if (!datasetSpec) return { primary };
 
-    const builder = new ColumnCollectionBuilder(pframeSpec);
-    for (const src of columnSources) builder.addSource(src);
-    const collection = builder.build({ anchors: { main: datasetSpec } });
-    if (!collection) return { primary };
-
+    // Allocations happen inside try so a throw on the second build()
+    // still disposes the first collection.
+    let filterCollection: AnchoredColumnCollection | undefined;
+    let enrichmentCollection: AnchoredColumnCollection | undefined;
     try {
-      const filterMatches = findFilterColumns(collection);
+      // ResultPoolColumnSnapshotProvider is always complete;
+      // allowPartialColumnList narrows the return type to non-undefined.
+      filterCollection = new ColumnCollectionBuilder(pframeSpec)
+        .addSource(filterSource)
+        .build({ anchors: { main: datasetSpec }, allowPartialColumnList: true });
+
+      enrichmentCollection =
+        enrichmentSources !== undefined
+          ? new ColumnCollectionBuilder(pframeSpec)
+              .addSources(enrichmentSources)
+              .build({ anchors: { main: datasetSpec } })
+          : undefined;
+
+      const filterMatches = findFilterColumns(filterCollection).filter((m) =>
+        filterPredicate(m.column.spec),
+      );
       const filters =
         filterMatches.length === 0
           ? undefined
           : filterMatchesToOptions(filterMatches, refMap, opts?.labelOptions);
 
       let enrichments;
-      if (opts?.withEnrichments !== undefined) {
-        const enrichmentVariants = findEnrichmentColumns(collection, {
-          maxHops: opts.enrichmentMaxHops,
-          ...(typeof opts.withEnrichments === "function"
-            ? { predicate: opts.withEnrichments }
-            : { include: opts.withEnrichments }),
+      if (enrichmentCollection && withEnrichments) {
+        const enrichmentVariants = findEnrichmentColumns(enrichmentCollection, {
+          maxHops: opts?.enrichmentMaxHops,
+          ...(typeof withEnrichments === "function"
+            ? { predicate: withEnrichments }
+            : { include: withEnrichments }),
         });
         if (enrichmentVariants.length > 0) {
-          enrichments = enrichmentVariantsToRefs(enrichmentVariants, opts.labelOptions);
+          enrichments = enrichmentVariantsToRefs(enrichmentVariants, opts?.labelOptions);
         }
       }
 
@@ -81,7 +117,8 @@ export function buildDatasetOptions(
         ...(enrichments !== undefined && enrichments.length > 0 ? { enrichments } : {}),
       };
     } finally {
-      collection.dispose();
+      filterCollection?.dispose();
+      enrichmentCollection?.dispose();
     }
   });
 }

package/src/components/PlDatasetSelector/filter_discovery.test.ts

@@ -140,17 +140,23 @@ describe("filterMatchesToOptions", () => {
     expect(filterMatchesToOptions([], new Map())).toEqual([]);
   });
 
-  test("throws when ref not found in map", () => {
-    const filterSpec1 = spec("orphan", [axis("sample")], { [Annotation.IsSubset]: "true" });
-    const f1Snap = snap("orphan-id", filterSpec1);
+  test("skips entries whose ref is not found in map", () => {
+    const knownRef = createPlRef("b1", "known");
+    const knownSpec = spec("known", [axis("sample")], { [Annotation.IsSubset]: "true" });
+    const orphanSpec = spec("orphan", [axis("sample")], { [Annotation.IsSubset]: "true" });
+    const knownSnap = snap(canonicalize(knownRef)! as string, knownSpec);
+    const orphanSnap = snap("orphan-id", orphanSpec);
 
     const builder = new ColumnCollectionBuilder(createSpecFrameCtx());
-    builder.addSource([f1Snap, anchorSnap]);
+    builder.addSource([knownSnap, orphanSnap, anchorSnap]);
     const collection = builder.build({ anchors: { main: anchorSpec } })!;
 
     const matches = findFilterColumns(collection);
-    expect(matches.length).toBe(1);
+    expect(matches.length).toBe(2);
 
-    expect(() => filterMatchesToOptions(matches, new Map())).toThrow(/no PlRef found/);
+    const refMap = buildRefMap([{ ref: knownRef }]);
+    const options = filterMatchesToOptions(matches, refMap);
+    expect(options).toHaveLength(1);
+    expect(options[0].ref).toBe(knownRef);
   });
 });

package/src/components/PlDatasetSelector/filter_discovery.ts

@@ -31,6 +31,9 @@ export function findFilterColumns(collection: AnchoredColumnCollection): ColumnM
 /**
  * Derive labeled options from filter column matches, for use in DatasetOption.filters.
  *
+ * Entries whose column id has no PlRef in `refsByObjectId` are silently
+ * skipped — they cannot be exposed as user-selectable options.
+ *
  * @param matches - from findFilterColumns()
  * @param refsByObjectId - from {@link buildRefMap}
  * @param labelOptions - forwarded to deriveDistinctLabels()
@@ -45,8 +48,13 @@ export function filterMatchesToOptions(
   // Each ColumnMatch can be reached via multiple variants (different linker
   // paths / qualifications). We emit one Option per variant so the user can
   // pick a specific path — `deriveDistinctLabels` disambiguates labels by
-  // path.
-  const flattened = matches.flatMap((m) => m.variants.map((v) => ({ match: m, variant: v })));
+  // path. All variants of a match share a column id, so the ref lookup
+  // happens once per match.
+  const flattened = matches.flatMap((match) => {
+    const ref = refsByObjectId.get(match.column.id);
+    if (ref === undefined) return [];
+    return match.variants.map((variant) => ({ match, variant, ref }));
+  });
 
   const entries: Entry[] = flattened.map(({ match, variant }) => ({
     spec: match.column.spec,
@@ -55,14 +63,7 @@ export function filterMatchesToOptions(
 
   const labels = deriveDistinctLabels(entries, labelOptions);
 
-  return flattened.map(({ match }, i) => {
-    const ref = refsByObjectId.get(match.column.id);
-    if (ref === undefined)
-      throw new Error(
-        `no PlRef found for filter column ${match.column.spec.name} (id: ${match.column.id})`,
-      );
-    return { ref, label: labels[i] };
-  });
+  return flattened.map(({ ref }, i) => ({ ref, label: labels[i] }));
 }
 
 /**