@platforma-sdk/model 1.79.24 → 1.80.0

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

@@ -1,171 +1,75 @@
-import type { PColumnSpec, PlRef, PObjectId } from "@milaboratories/pl-model-common";
-import { createDiscoveredPColumnId, isPlRef, PColumnName } from "@milaboratories/pl-model-common";
-import type { RenderCtxBase } from "../../../render";
 import type {
-  ColumnSource,
-  ColumnVariant,
+  PColumnSpec,
+  PlRef,
+  PObjectId,
   RelaxedColumnSelector,
-  ColumnSnapshotProvider,
-  ColumnSnapshot,
-} from "../../../columns";
-import { ColumnCollectionBuilder } from "../../../columns";
-import { toColumnSnapshotProvider } from "../../../columns/column_snapshot_provider";
-import { collectCtxColumnSnapshotProviders } from "../../../columns/ctx_column_sources";
-import { throwError } from "@milaboratories/helpers";
-import type { ColumnsSelectorConfig, TableColumnVariant } from "./createPlDataTableV3";
+} from "@milaboratories/pl-model-common";
+import { PColumnName } from "@milaboratories/pl-model-common";
+import type { RenderCtxBase } from "../../../render";
+import type { ColumnRecipe, ColumnsSource } from "../../../columns";
+import { ColumnsCollection, collectLinkerIds, isLeafColumn } from "../../../columns";
+import type { ColumnsSelectorConfig } from "./createPlDataTableV3";
 
 export type DiscoverTableColumnOptions = {
-  sources?: ColumnSource[];
+  sources?: ColumnsSource[];
   anchors: Record<string, PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector>;
   selector: ColumnsSelectorConfig;
 };
 
-/** Discover columns from sources/anchors and normalize into a flat TableColumnVariant list. */
-export function discoverTableColumnSnaphots(
+/** Split of discovered columns into anchor-matching (primary) and the rest. */
+export type DiscoveredTableColumns = {
+  readonly primary: ColumnRecipe[];
+  readonly secondary: ColumnRecipe[];
+};
+
+/**
+ * Discover columns from sources/anchors and split them into primary
+ * (direct anchor hits — zero-hop, query is a bare column) and secondary
+ * (reached via a linker chain, query carries a join).
+ */
+export function discoverTableColumns(
   ctx: RenderCtxBase,
   options: DiscoverTableColumnOptions,
-): TableColumnVariant[] | undefined {
-  // Resolve PlRef anchors to PColumnSpec
-  const resolvedOptions = {
-    ...options,
-    anchors: resolveAnchors(ctx, options.anchors),
-  };
-
-  // Resolve providers
-  const providers = resolveProviders(ctx, resolvedOptions.sources);
-  if (providers.length === 0) return undefined;
-
-  // Build collection (anchored or plain)
-  const collection = new ColumnCollectionBuilder(ctx.getService("pframeSpec"))
-    .addSources(providers)
-    .build(resolvedOptions);
-  if (collection === undefined) return undefined;
+): undefined | DiscoveredTableColumns {
+  const discoveredColumns = ColumnsCollection(options.sources, { ctx: ctx.ctx })
+    .discover({ ...options.selector, anchors: options.anchors })
+    .getColumns();
 
-  try {
-    const variants = collection.findColumnVariants(resolvedOptions.selector);
-    const anchors = collection.getAnchors();
-    return mapToTableColumnVariants(variants, anchors);
-  } finally {
-    collection.dispose();
+  const primary: ColumnRecipe[] = [];
+  const secondary: ColumnRecipe[] = [];
+  for (const col of discoveredColumns) {
+    if (isLeafColumn(col)) primary.push(col);
+    else secondary.push(col);
   }
+  return { primary, secondary };
 }
 
 /**
  * Discover label columns matching the axes of the given value columns from
- * ctx providers. Returns label snapshots wrapped as direct TableColumnVariants
- * (path: [], empty qualifications, isPrimary: false).
+ * ctx providers. Returns a list of label {@link ColumnRecipe}s.
+ *
+ * Primary columns are used as anchors for axis-aware label discovery.
+ * `maxHops` is taken from the longest linker chain present in `columns`.
  */
-export function discoverLabelColumnVariants<A, U>(
+export function discoverLabelColumns<A, U>(
   ctx: RenderCtxBase<A, U>,
-  columns: TableColumnVariant[],
-): TableColumnVariant[] {
+  primary: ColumnRecipe[],
+  columns: ColumnRecipe[],
+): ColumnRecipe[] {
   if (columns.length === 0) return [];
-  const collection = new ColumnCollectionBuilder(ctx.getService("pframeSpec"))
-    .addSources(collectCtxColumnSnapshotProviders(ctx))
-    .addSource(columns.map((c) => c.column))
-    .build({
-      allowPartialColumnList: true,
-      anchors: Object.fromEntries(
-        columns
-          .filter((col) => (col.path?.length ?? 0) === 0 && col.isPrimary)
-          .map((col, i) => [`anchor_${i}`, col.column.spec]),
-      ),
-    });
 
-  try {
-    const axes = columns.flatMap((col) => col.column.spec.axesSpec);
-    return collection
-      .findColumnVariants({
+  const axes = columns.flatMap((col) => col.getSpec().axesSpec);
+  return (
+    ColumnsCollection(undefined, { ctx: ctx.ctx })
+      // .addSource({ columns, isFinal: true })
+      .discover({
         include: axes.map((a) => ({
           name: { type: "exact", value: PColumnName.Label },
           axes: [{ name: { type: "exact", value: a.name } }],
         })),
-        maxHops: columns.reduce((acc, c) => Math.max(acc, c.path?.length ?? 0), 0),
+        anchors: Object.fromEntries(primary.map((col, i) => [`anchor_${i}`, col.getSpec()])),
+        maxHops: columns.reduce((acc, c) => Math.max(acc, collectLinkerIds(c).length), 0),
       })
-      .map((variant) => ({
-        ...variant,
-        column: {
-          ...variant.column,
-          id: createDiscoveredPColumnId({
-            column: variant.column.id,
-            path: variant.path?.map((p) => ({
-              type: "linker",
-              column: p.linker.id,
-            })),
-            columnQualifications: variant.qualifications?.forHit,
-            queriesQualifications: variant.qualifications?.forQueries,
-          }),
-          originalId: variant.column.id,
-        },
-      }));
-  } finally {
-    collection.dispose();
-  }
-}
-
-/** Resolve PlRef values in anchors to PColumnSpec via the result pool. */
-function resolveAnchors(
-  ctx: RenderCtxBase,
-  anchors: Record<string, PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector>,
-): Record<string, PObjectId | PColumnSpec | RelaxedColumnSelector> {
-  const result: Record<string, PObjectId | PColumnSpec | RelaxedColumnSelector> = {};
-  for (const [key, value] of Object.entries(anchors)) {
-    if (isPlRef(value)) {
-      result[key] =
-        ctx.resultPool.getPColumnSpecByRef(value) ??
-        throwError(
-          `Anchor ${key} with ref ${JSON.stringify(value)} could not be resolved to a PColumnSpec`,
-        );
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-/** Resolve column snapshot providers from explicit sources or context. */
-function resolveProviders(
-  ctx: RenderCtxBase,
-  sources: undefined | ColumnSource[],
-): ColumnSnapshotProvider[] {
-  return sources !== undefined
-    ? sources.map(toColumnSnapshotProvider)
-    : collectCtxColumnSnapshotProviders(ctx);
-}
-
-/** Map column variants into TableColumnVariant list with anchor-derived isPrimary flag. */
-function mapToTableColumnVariants(
-  variants: readonly ColumnVariant[],
-  anchors: Map<string, ColumnSnapshot<PObjectId>>,
-): TableColumnVariant[] {
-  const columnIdToAnchorName = new Map<PObjectId, string>(
-    Array.from(anchors.entries(), ([key, { id }]) => [id, key] as const),
+      .getColumns()
   );
-
-  return variants.map((variant): TableColumnVariant => {
-    const snap = variant.column;
-    const isPrimary = columnIdToAnchorName.get(snap.id) !== undefined;
-
-    const discoveredId = createDiscoveredPColumnId({
-      column: snap.id,
-      path: variant.path?.map((p) => ({
-        type: "linker",
-        column: p.linker.id,
-      })),
-      columnQualifications: variant.qualifications?.forHit,
-      queriesQualifications: variant.qualifications?.forQueries,
-    });
-    return {
-      column: {
-        id: discoveredId,
-        spec: snap.spec,
-        data: snap.data,
-        dataStatus: snap.dataStatus,
-      },
-      path: variant.path,
-      qualifications: variant.qualifications,
-      originalId: snap.id,
-      isPrimary,
-    };
-  });
 }

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

@@ -1,5 +1,5 @@
 import type { RenderCtxBase } from "../../../render";
-import type { PlDataTableModel } from "../typesV7";
+import type { PlDataTableModel } from "../typesV8";
 import { createPlDataTableOptionsV2, createPlDataTableV2 } from "./createPlDataTableV2";
 import { createPlDataTableV3 } from "./createPlDataTableV3";
 import type { createPlDataTableOptionsV3 } from "./createPlDataTableV3";
@@ -26,4 +26,4 @@ export function createPlDataTable<A, U>(
   }
 }
 
-export { discoverTableColumnSnaphots } from "./discoverColumns";
+export { discoverTableColumns as discoverTableColumnSnaphots } from "./discoverColumns";

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

@@ -1,8 +1,17 @@
-import { Annotation, type PColumnSpec, type PObjectId } from "@milaboratories/pl-model-common";
-import { SpecDriver } from "@milaboratories/pf-spec-driver";
-import { describe, expect, test } from "vitest";
-import { deriveAllLabels, evaluateRules, type LabelableColumn, type RuleColumn } from "./utils";
+import {
+  Annotation,
+  createGlobalPObjectId,
+  type PColumnSpec,
+  type PObjectId,
+} from "@milaboratories/pl-model-common";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { deriveAllLabels, evaluateRules, type LabelableColumn } from "./utils";
 import type { ColumnOrderRule, ColumnVisibilityRule } from "./createPlDataTableV3";
+import { ColumnLazy } from "../../../columns";
+import {
+  createTestCollectionDriver,
+  type TestCollectionDriverHandle,
+} from "../../../columns/__test_helpers__/collection_driver";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -100,11 +109,6 @@ describe("deriveAllLabels", () => {
     expect(result["c2"]).toBe("Score 2");
   });
 
-  // Regression: LabelableColumn.linkerPath used to be `linkerPath` while
-  // deriveDistinctLabels.Entry expected `linkersPath`. Structural typing +
-  // optional fields hid the mismatch from the type checker — the field flowed
-  // through as "extra" and disambiguation silently broke. This asserts the
-  // linker label reaches the output.
   test("linkerPath flows into deriveDistinctLabels and produces the 'via' suffix", () => {
     const linkerSpec = makeSpec({
       name: "linker",
@@ -136,92 +140,79 @@ describe("deriveAllLabels", () => {
 // evaluateRules
 // ---------------------------------------------------------------------------
 
-function makeRuleColumn(id: string, spec: Partial<PColumnSpec> = {}): RuleColumn {
-  return {
-    id: id as PObjectId,
-    spec: makeSpec({ axesSpec: [{ name: "id", type: "String" }], ...spec }),
-  };
+let driverHandle: TestCollectionDriverHandle;
+
+beforeEach(() => {
+  driverHandle = createTestCollectionDriver();
+  driverHandle.installAmbientCtx();
+});
+
+afterEach(async () => {
+  driverHandle.uninstallAmbientCtx();
+  await driverHandle.dispose();
+});
+
+function gid(name: string): PObjectId {
+  return createGlobalPObjectId("test-block", name);
+}
+
+function makeLazyColumn(name: string, spec: Partial<PColumnSpec> = {}): ColumnLazy {
+  const s = makeSpec({ axesSpec: [{ name: "id", type: "String" }], ...spec });
+  const id = gid(name);
+  driverHandle.register([{ id, spec: s }]);
+  return ColumnLazy.fromColumn({ id, spec: s, data: undefined as never });
 }
 
 describe("evaluateRules", () => {
   test("returns empty map when rules or columns are empty", () => {
-    const driver = new SpecDriver();
-    expect(evaluateRules([], [makeRuleColumn("c1")], driver).size).toBe(0);
+    expect(evaluateRules([], [makeLazyColumn("c1")]).size).toBe(0);
     expect(
-      evaluateRules<ColumnVisibilityRule>([{ match: () => true, visibility: "hidden" }], [], driver)
-        .size,
+      evaluateRules<ColumnVisibilityRule>(
+        [{ match: { name: "anything" }, visibility: "hidden" }],
+        [],
+      ).size,
     ).toBe(0);
   });
 
-  test("evaluates predicate rules without touching the driver", () => {
-    const driver = new Proxy({} as SpecDriver, {
-      get() {
-        throw new Error("driver should not be called for predicate-only rules");
-      },
-    });
-
-    const rules: ColumnOrderRule[] = [
-      { match: (spec) => spec.name === "alpha", priority: 10 },
-      { match: (spec) => spec.name === "beta", priority: 5 },
-    ];
-    const result = evaluateRules(
-      rules,
-      [
-        makeRuleColumn("a", { name: "alpha" }),
-        makeRuleColumn("b", { name: "beta" }),
-        makeRuleColumn("c", { name: "gamma" }),
-      ],
-      driver,
-    );
-
-    expect(result.get("a" as PObjectId)?.priority).toBe(10);
-    expect(result.get("b" as PObjectId)?.priority).toBe(5);
-    expect(result.has("c" as PObjectId)).toBe(false);
-  });
-
-  test("evaluates selector rules via PFrameSpec.discoverColumns", () => {
-    const driver = new SpecDriver();
+  test("evaluates selector rules via the columnsCollection service", () => {
     const rules: ColumnVisibilityRule[] = [
       { match: { name: "^note$" }, visibility: "hidden" },
       { match: { name: "^score$" }, visibility: "optional" },
     ];
     const columns = [
-      makeRuleColumn("n", { name: "note" }),
-      makeRuleColumn("s", { name: "score" }),
-      makeRuleColumn("x", { name: "other" }),
+      makeLazyColumn("n", { name: "note" }),
+      makeLazyColumn("s", { name: "score" }),
+      makeLazyColumn("x", { name: "other" }),
     ];
 
-    const result = evaluateRules(rules, columns, driver);
+    const result = evaluateRules(rules, columns);
 
-    expect(result.get("n" as PObjectId)?.visibility).toBe("hidden");
-    expect(result.get("s" as PObjectId)?.visibility).toBe("optional");
-    expect(result.has("x" as PObjectId)).toBe(false);
+    expect(result.get(gid("n"))?.visibility).toBe("hidden");
+    expect(result.get(gid("s"))?.visibility).toBe("optional");
+    expect(result.has(gid("x"))).toBe(false);
   });
 
-  test("preserves original rule order when predicate and selector rules are mixed", () => {
-    const driver = new SpecDriver();
+  test("preserves original rule order with overlapping selector rules", () => {
     const rules: ColumnOrderRule[] = [
-      { match: (spec) => spec.name === "alpha", priority: 100 },
-      { match: { name: "^alpha$" }, priority: 1 }, // shadowed by the predicate above
+      { match: { name: "^alpha$" }, priority: 100 },
+      { match: { name: "^alpha$" }, priority: 1 }, // shadowed by the earlier rule
       { match: { name: "^beta$" }, priority: 50 },
     ];
-    const result = evaluateRules(
-      rules,
-      [makeRuleColumn("a", { name: "alpha" }), makeRuleColumn("b", { name: "beta" })],
-      driver,
-    );
-
-    expect(result.get("a" as PObjectId)?.priority).toBe(100);
-    expect(result.get("b" as PObjectId)?.priority).toBe(50);
+    const result = evaluateRules(rules, [
+      makeLazyColumn("a", { name: "alpha" }),
+      makeLazyColumn("b", { name: "beta" }),
+    ]);
+
+    expect(result.get(gid("a"))?.priority).toBe(100);
+    expect(result.get(gid("b"))?.priority).toBe(50);
   });
 
   test("dedupes columns by id before building spec frame (no duplicate-key crash)", () => {
-    const driver = new SpecDriver();
     const rules: ColumnVisibilityRule[] = [{ match: { name: "^dup$" }, visibility: "hidden" }];
-    const dup = makeRuleColumn("d", { name: "dup" });
+    const dup = makeLazyColumn("d", { name: "dup" });
 
-    const result = evaluateRules(rules, [dup, dup, dup], driver);
+    const result = evaluateRules(rules, [dup, dup, dup]);
 
-    expect(result.get("d" as PObjectId)?.visibility).toBe("hidden");
+    expect(result.get(gid("d"))?.visibility).toBe("hidden");
   });
 });