@platforma-sdk/model 1.54.9 → 1.54.13

package/src/components/PlDataTable/table.ts

@@ -15,6 +15,7 @@ import type {
   SingleAxisSelector,
   SpecQueryExpression,
   SpecQueryJoinEntry,
+  CanonicalizedJson,
 } from "@milaboratories/pl-model-common";
 import {
   Annotation,
@@ -25,6 +26,7 @@ import {
   readAnnotation,
   uniqueBy,
   isBooleanExpression,
+  parseJson,
 } from "@milaboratories/pl-model-common";
 import { filterSpecToSpecQueryExpr } from "../../filters";
 import type { RenderCtxBase, TreeNodeAccessor, PColumnDataUniversal } from "../../render";
@@ -36,6 +38,7 @@ import { upgradePlDataTableStateV2 } from "./state-migration";
 import type { PlDataTableStateV2 } from "./state-migration";
 import type { PlDataTableSheet } from "./v5";
 import { getAllLabelColumns, getMatchingLabelColumns } from "./labels";
+import { collectFilterSpecColumns } from "../../filters/traverse";
 
 /** Convert a PTableColumnId to a SpecQueryExpression reference. */
 function columnIdToExpr(col: PTableColumnId): SpecQueryExpression {
@@ -177,21 +180,37 @@ export function createPlDataTableV2<A, U>(
     ...fullColumns.map((c) => ({ type: "column", id: c.id }) satisfies PTableColumnIdColumn),
   ];
   const fullColumnsIdsSet = new Set(fullColumnsIds.map((c) => canonicalizeJson<PTableColumnId>(c)));
-  const isValidColumnId = (id: PTableColumnId): boolean =>
-    fullColumnsIdsSet.has(canonicalizeJson<PTableColumnId>(id));
+  const isValidColumnId = (id: string): boolean =>
+    fullColumnsIdsSet.has(id as CanonicalizedJson<PTableColumnId>);
+
+  // -- Filtering validation --
+  const stateFilters = tableStateNormalized.pTableParams.filters;
+  const opsFilters = ops?.filters ?? null;
+  const filters: null | PlDataTableFilters =
+    stateFilters != null && opsFilters != null
+      ? { type: "and", filters: [stateFilters, opsFilters] }
+      : (stateFilters ?? opsFilters);
+  const filterColumns = filters ? collectFilterSpecColumns(filters) : [];
+  const firstInvalidFilterColumn = filterColumns.find((col) => !isValidColumnId(col));
+  if (firstInvalidFilterColumn)
+    throw new Error(
+      `Invalid filter column ${firstInvalidFilterColumn}: column reference does not match the table columns`,
+    );
 
-  const coreJoinType = ops?.coreJoinType ?? "full";
-  const filters = tableStateNormalized.pTableParams.filters;
+  // -- Sorting validation --
   const sorting: PTableSorting[] = uniqueBy(
     [...tableStateNormalized.pTableParams.sorting, ...(ops?.sorting ?? [])],
     (s) => canonicalizeJson<PTableColumnId>(s.column),
-  ).filter((s) => {
-    const valid = isValidColumnId(s.column);
-    if (!valid)
-      ctx.logWarn(`Sorting ${JSON.stringify(s)} does not match provided columns, skipping`);
-    return valid;
-  });
+  );
+  const firstInvalidSortingColumn = sorting.find(
+    (s) => !isValidColumnId(canonicalizeJson<PTableColumnId>(s.column)),
+  );
+  if (firstInvalidSortingColumn)
+    throw new Error(
+      `Invalid sorting column ${JSON.stringify(firstInvalidSortingColumn.column)}: column reference does not match the table columns`,
+    );
 
+  const coreJoinType = ops?.coreJoinType ?? "full";
   const fullDef = createPTableDef({
     columns,
     labelColumns: fullLabelColumns,
@@ -200,6 +219,7 @@ export function createPlDataTableV2<A, U>(
     sorting,
     coreColumnPredicate: ops?.coreColumnPredicate,
   });
+
   const fullHandle = ctx.createPTableV2(fullDef);
   if (!fullHandle) return undefined;
 
@@ -227,12 +247,22 @@ export function createPlDataTableV2<A, U>(
     coreColumns.forEach((c) => hiddenColumns.delete(c));
   }
 
-  // Sorting changes the order of result rows — preserve sorted columns from being hidden
+  // Preserve sorted columns from being hidden
   sorting
     .map((s) => s.column)
     .filter((c): c is PTableColumnIdColumn => c.type === "column")
     .forEach((c) => hiddenColumns.delete(c.id));
 
+  // Preserve filter columns from being hidden
+  if (filters) {
+    collectFilterSpecColumns(filters)
+      .flatMap((c) => {
+        const obj = parseJson(c);
+        return obj.type === "column" ? [obj.id] : [];
+      })
+      .forEach((c) => hiddenColumns.delete(c));
+  }
+
   const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
   const visibleLabelColumns = getMatchingLabelColumns(
     visibleColumns.map(getColumnIdAndSpec),
@@ -251,13 +281,14 @@ export function createPlDataTableV2<A, U>(
     coreColumnPredicate,
   });
   const visibleHandle = ctx.createPTableV2(visibleDef);
+
   if (!visibleHandle) return undefined;
 
   return {
     sourceId: tableStateNormalized.pTableParams.sourceId,
     fullTableHandle: fullHandle,
     visibleTableHandle: visibleHandle,
-  } satisfies PlDataTableModel;
+  } as PlDataTableModel;
 }
 
 /** Create sheet entries for PlDataTable */

package/src/components/PlDataTable/v5.ts

@@ -5,12 +5,13 @@ import type {
   ListOptionBase,
   PObjectId,
   PTableColumnSpec,
-  PTableRecordFilter,
   PTableSorting,
   PColumnIdAndSpec,
   PTableHandle,
+  RootFilterSpec,
+  PTableColumnId,
 } from "@milaboratories/pl-model-common";
-import type { FilterSpec, FilterSpecLeaf } from "../../filters";
+import type { FilterSpecLeaf } from "../../filters";
 
 export type PlTableColumnId = {
   /** Original column spec */
@@ -61,10 +62,10 @@ export type PlDataTableSheetState = {
 };
 
 /** Tree-based filter state compatible with PlAdvancedFilter's RootFilter */
-export type PlDataTableFilters = FilterSpec<FilterSpecLeaf<string>>;
-export type PlDataTableFiltersWithMeta = FilterSpec<
-  FilterSpecLeaf<string>,
-  { id: number; isExpanded?: boolean }
+export type PlDataTableFilters = RootFilterSpec<FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>>;
+export type PlDataTableFiltersWithMeta = RootFilterSpec<
+  FilterSpecLeaf<CanonicalizedJson<PTableColumnId>>,
+  { id: number; isExpanded?: boolean; source?: "table-filter" | "table-search" }
 >;
 
 export type PlDataTableStateV2CacheEntry = {
@@ -76,6 +77,8 @@ export type PlDataTableStateV2CacheEntry = {
   sheetsState: PlDataTableSheetState[];
   /** Filters state (tree-based, compatible with PlAdvancedFilter) */
   filtersState: null | PlDataTableFiltersWithMeta;
+  /** Fast search string */
+  searchString?: string;
 };
 
 export type PTableParamsV2 =
@@ -113,7 +116,7 @@ export type PlDataTableModel = {
 
 export type CreatePlDataTableOps = {
   /** Filters for columns and non-partitioned axes */
-  filters?: PTableRecordFilter[];
+  filters?: PlDataTableFilters;
 
   /** Sorting to columns hidden from user */
   sorting?: PTableSorting[];

package/src/filters/converters/filterToQuery.ts

@@ -6,34 +6,42 @@ import type {
   SingleAxisSelector,
   SpecQueryExpression,
 } from "@milaboratories/pl-model-common";
+import { traverseFilterSpec } from "../traverse";
 
 /** 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 };
+  return parsed.type === "axis"
+    ? { type: "axisRef", value: parsed.id as SingleAxisSelector }
+    : { type: "columnRef", value: parsed.id };
 }
 
 /** Converts a FilterSpec tree into a SpecQueryExpression. */
-export function filterSpecToSpecQueryExpr(
-  filter: FilterSpec<FilterSpecLeaf<string>>,
+export function filterSpecToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(
+  filter: FilterSpec<Leaf>,
 ): SpecQueryExpression {
-  switch (filter.type) {
-    case "and":
-    case "or": {
-      const inputs = filter.filters
-        .filter((f) => f.type !== undefined)
-        .map(filterSpecToSpecQueryExpr);
+  return traverseFilterSpec(filter, {
+    leaf: leafToSpecQueryExpr,
+    and: (inputs) => {
       if (inputs.length === 0) {
-        throw new Error(`${filter.type.toUpperCase()} filter requires at least one operand`);
+        throw new Error("AND filter requires at least one operand");
       }
-      return { type: filter.type, input: inputs };
-    }
-    case "not":
-      return { type: "not", input: filterSpecToSpecQueryExpr(filter.filter) };
+      return { type: "and", input: inputs };
+    },
+    or: (inputs) => {
+      if (inputs.length === 0) {
+        throw new Error("OR filter requires at least one operand");
+      }
+      return { type: "or", input: inputs };
+    },
+    not: (input) => ({ type: "not", input }),
+  });
+}
 
+function leafToSpecQueryExpr<Leaf extends FilterSpecLeaf<string>>(
+  filter: Leaf,
+): SpecQueryExpression {
+  switch (filter.type) {
     case "patternEquals":
       return {
         type: "stringEquals",

package/src/filters/converters/filterUiToExpressionImpl.ts

@@ -1,4 +1,5 @@
 import { assertNever } from "@milaboratories/pl-model-common";
+import type { FilterSpecLeaf } from "@milaboratories/pl-model-common";
 import {
   and,
   col,
@@ -9,135 +10,90 @@ import {
   type ExpressionImpl,
 } from "@milaboratories/ptabler-expression-js";
 import type { FilterSpec } from "../types";
+import { traverseFilterSpec } from "../traverse";
 
 export function convertFilterUiToExpressionImpl(value: FilterSpec): ExpressionImpl {
-  if (value.type === "or") {
-    const expressions = value.filters
-      .filter((f) => f.type !== undefined)
-      .map(convertFilterUiToExpressionImpl);
-    if (expressions.length === 0) {
-      throw new Error("OR filter requires at least one operand");
-    }
-    return or(...expressions);
-  }
-
-  if (value.type === "and") {
-    const expressions = value.filters
-      .filter((f) => f.type !== undefined)
-      .map(convertFilterUiToExpressionImpl);
-    if (expressions.length === 0) {
-      throw new Error("AND filter requires at least one operand");
-    }
-    return and(...expressions);
-  }
-
-  if (value.type === "not") {
-    return convertFilterUiToExpressionImpl(value.filter).not();
-  }
-
-  if (value.type === "isNA") {
-    return col(value.column).isNull();
-  }
-
-  if (value.type === "isNotNA") {
-    return col(value.column).isNotNull();
-  }
-
-  if (value.type === "patternEquals") {
-    return col(value.column).eq(lit(value.value));
-  }
-
-  if (value.type === "patternNotEquals") {
-    return col(value.column).neq(lit(value.value));
-  }
-
-  if (value.type === "patternContainSubsequence") {
-    return col(value.column).strContains(value.value, false, true);
-  }
-
-  if (value.type === "patternNotContainSubsequence") {
-    return col(value.column).strContains(value.value, false, true).not();
-  }
-
-  if (value.type === "equal") {
-    return col(value.column).eq(lit(value.x));
-  }
-
-  if (value.type === "notEqual") {
-    return col(value.column).neq(lit(value.x));
-  }
-
-  if (value.type === "lessThan") {
-    return col(value.column).lt(lit(value.x));
-  }
-
-  if (value.type === "greaterThan") {
-    return col(value.column).gt(lit(value.x));
-  }
-
-  if (value.type === "lessThanOrEqual") {
-    return col(value.column).le(lit(value.x));
-  }
-
-  if (value.type === "greaterThanOrEqual") {
-    return col(value.column).ge(lit(value.x));
-  }
-
-  if (value.type === "equalToColumn") {
-    return col(value.column).eq(col(value.rhs));
-  }
-
-  if (value.type === "greaterThanColumn") {
-    if (value.minDiff !== undefined && value.minDiff !== 0) {
-      return col(value.column).plus(lit(value.minDiff)).gt(col(value.rhs));
-    }
-    return col(value.column).gt(col(value.rhs));
-  }
-
-  if (value.type === "lessThanColumn") {
-    if (value.minDiff !== undefined && value.minDiff !== 0) {
-      return col(value.column).plus(lit(value.minDiff)).lt(col(value.rhs));
-    }
-    return col(value.column).lt(col(value.rhs));
-  }
-
-  if (value.type === "greaterThanColumnOrEqual") {
-    if (value.minDiff !== undefined && value.minDiff !== 0) {
-      return col(value.column).plus(lit(value.minDiff)).ge(col(value.rhs));
-    }
-    return col(value.column).ge(col(value.rhs));
-  }
-
-  if (value.type === "lessThanColumnOrEqual") {
-    if (value.minDiff !== undefined && value.minDiff !== 0) {
-      return col(value.column).plus(lit(value.minDiff)).le(col(value.rhs));
-    }
-    return col(value.column).le(col(value.rhs));
-  }
-
-  if (value.type === "topN") {
-    return rank(col(value.column), true).over([]).le(lit(value.n));
-  }
-
-  if (value.type === "bottomN") {
-    return rank(col(value.column), false).over([]).le(lit(value.n));
-  }
-
-  if (
-    value.type === "patternMatchesRegularExpression" ||
-    value.type === "patternFuzzyContainSubsequence" ||
-    value.type === "inSet" ||
-    value.type === "notInSet" ||
-    value.type === "ifNa"
-  ) {
-    throw new Error("Not implemented filter type: " + value.type);
-  }
+  return traverseFilterSpec(value, {
+    leaf: leafToExpressionImpl,
+    and: (expressions) => {
+      if (expressions.length === 0) {
+        throw new Error("AND filter requires at least one operand");
+      }
+      return and(...expressions);
+    },
+    or: (expressions) => {
+      if (expressions.length === 0) {
+        throw new Error("OR filter requires at least one operand");
+      }
+      return or(...expressions);
+    },
+    not: (result) => result.not(),
+  });
+}
 
-  if (value.type === undefined) {
-    throw new Error("Filter type is undefined, this should not happen");
+function leafToExpressionImpl(value: FilterSpecLeaf): ExpressionImpl {
+  switch (value.type) {
+    case "isNA":
+      return col(value.column).isNull();
+    case "isNotNA":
+      return col(value.column).isNotNull();
+    case "patternEquals":
+      return col(value.column).eq(lit(value.value));
+    case "patternNotEquals":
+      return col(value.column).neq(lit(value.value));
+    case "patternContainSubsequence":
+      return col(value.column).strContains(value.value, false, true);
+    case "patternNotContainSubsequence":
+      return col(value.column).strContains(value.value, false, true).not();
+    case "equal":
+      return col(value.column).eq(lit(value.x));
+    case "notEqual":
+      return col(value.column).neq(lit(value.x));
+    case "lessThan":
+      return col(value.column).lt(lit(value.x));
+    case "greaterThan":
+      return col(value.column).gt(lit(value.x));
+    case "lessThanOrEqual":
+      return col(value.column).le(lit(value.x));
+    case "greaterThanOrEqual":
+      return col(value.column).ge(lit(value.x));
+    case "equalToColumn":
+      return col(value.column).eq(col(value.rhs));
+    case "greaterThanColumn":
+      if (value.minDiff !== undefined && value.minDiff !== 0) {
+        return col(value.column).plus(lit(value.minDiff)).gt(col(value.rhs));
+      }
+      return col(value.column).gt(col(value.rhs));
+    case "lessThanColumn":
+      if (value.minDiff !== undefined && value.minDiff !== 0) {
+        return col(value.column).plus(lit(value.minDiff)).lt(col(value.rhs));
+      }
+      return col(value.column).lt(col(value.rhs));
+    case "greaterThanColumnOrEqual":
+      if (value.minDiff !== undefined && value.minDiff !== 0) {
+        return col(value.column).plus(lit(value.minDiff)).ge(col(value.rhs));
+      }
+      return col(value.column).ge(col(value.rhs));
+    case "lessThanColumnOrEqual":
+      if (value.minDiff !== undefined && value.minDiff !== 0) {
+        return col(value.column).plus(lit(value.minDiff)).le(col(value.rhs));
+      }
+      return col(value.column).le(col(value.rhs));
+    case "topN":
+      return rank(col(value.column), true).over([]).le(lit(value.n));
+    case "bottomN":
+      return rank(col(value.column), false).over([]).le(lit(value.n));
+    case "patternMatchesRegularExpression":
+    case "patternFuzzyContainSubsequence":
+    case "inSet":
+    case "notInSet":
+    case "ifNa":
+      throw new Error("Not implemented filter type: " + value.type);
+    case undefined:
+      throw new Error("Filter type is undefined, this should not happen");
+    default:
+      assertNever(value);
   }
-
-  assertNever(value);
 }
 
 export function convertFilterUiToExpressions(value: FilterSpec): Expression {

package/src/filters/distill.ts

@@ -1,5 +1,11 @@
 import { DistributiveKeys, UnionToTuples } from "@milaboratories/helpers";
-import { type FilterSpec, type FilterSpecLeaf } from "@milaboratories/pl-model-common";
+import {
+  RootFilterSpec,
+  type FilterSpec,
+  type FilterSpecLeaf,
+} from "@milaboratories/pl-model-common";
+import { traverseFilterSpec } from "./traverse";
+import { InferFilterSpecLeaf } from "@milaboratories/pl-model-common";
 
 /** All possible field names that can appear in any FilterSpecLeaf variant. */
 type FilterSpecLeafKey = DistributiveKeys<FilterSpecLeaf<string>>;
@@ -36,32 +42,30 @@ function distillLeaf(node: Record<string, unknown>): FilterSpecLeaf<string> {
   return result as FilterSpecLeaf<string>;
 }
 
-function distillNode<T extends FilterSpecLeaf<unknown>>(
-  node: FilterSpec<T, unknown, unknown>,
-): FilterSpec<T> | null {
-  switch (node.type) {
-    case "and":
-    case "or": {
-      const filtered = node.filters.map(distillNode).filter((f): f is FilterSpec<T> => f !== null);
-      return filtered.length === 0 ? null : { type: node.type, filters: filtered };
-    }
-    case "not": {
-      const inner = distillNode(node.filter);
-      return inner === null ? null : { type: "not", filter: inner };
-    }
-    default:
-      if (!isFilledLeaf(node)) return null;
-      return distillLeaf(node);
-  }
-}
-
 /**
  * Strips non-FilterSpec metadata (whitelist approach) and removes
  * unfilled leaves (type is undefined or any required field is undefined).
  */
-export function distillFilterSpec<T extends FilterSpecLeaf<unknown>>(
-  filter: null | undefined | FilterSpec<T, unknown, unknown>,
-): null | FilterSpec<T> {
+export function distillFilterSpec<
+  FS extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>,
+  R extends FS extends RootFilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>
+    ? RootFilterSpec<InferFilterSpecLeaf<FS>>
+    : FilterSpec<InferFilterSpecLeaf<FS>>,
+>(filter: null | undefined | FS): null | R {
   if (filter == null) return null;
-  return distillNode(filter);
+  return traverseFilterSpec<FS, null | R>(filter, {
+    leaf: (leaf) => {
+      if (!isFilledLeaf(leaf as Record<string, unknown>)) return null;
+      return distillLeaf(leaf as Record<string, unknown>) as R;
+    },
+    and: (results) => {
+      const filtered = results.filter((f): f is NonNullable<typeof f> => f !== null);
+      return filtered.length === 0 ? null : ({ type: "and", filters: filtered } as R);
+    },
+    or: (results) => {
+      const filtered = results.filter((f): f is NonNullable<typeof f> => f !== null);
+      return filtered.length === 0 ? null : ({ type: "or", filters: filtered } as R);
+    },
+    not: (result) => (result === null ? null : ({ type: "not", filter: result } as R)),
+  });
 }

package/src/filters/traverse.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import type { FilterSpec, FilterSpecLeaf } from "@milaboratories/pl-model-common";
+import { traverseFilterSpec, collectFilterSpecColumns } from "./traverse";
+
+type F = FilterSpec<FilterSpecLeaf<string>>;
+
+const eq1: F = { type: "equal", column: "c1", x: 1 };
+const eq2: F = { type: "equal", column: "c2", x: 2 };
+const gt: F = { type: "greaterThan", column: "c3", x: 10 };
+const empty: F = { type: undefined };
+
+/** Visitor that collects leaf types into a string expression. */
+const toStringVisitor = {
+  leaf: (l: FilterSpecLeaf<unknown>) => l.type ?? "empty",
+  and: (r: string[]) => `(${r.join(" & ")})`,
+  or: (r: string[]) => `(${r.join(" | ")})`,
+  not: (r: string) => `!${r}`,
+};
+
+describe("traverseFilterSpec", () => {
+  it("visits a leaf node", () => {
+    expect(traverseFilterSpec(eq1, toStringVisitor)).toBe("equal");
+  });
+
+  it("visits an and node", () => {
+    const filter: F = { type: "and", filters: [eq1, gt] };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("(equal & greaterThan)");
+  });
+
+  it("visits an or node", () => {
+    const filter: F = { type: "or", filters: [eq1, eq2] };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("(equal | equal)");
+  });
+
+  it("visits a not node", () => {
+    const filter: F = { type: "not", filter: eq1 };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("!equal");
+  });
+
+  it("handles nested structure", () => {
+    const filter: F = {
+      type: "and",
+      filters: [
+        { type: "not", filter: eq1 },
+        { type: "or", filters: [eq2, gt] },
+      ],
+    };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("(!equal & (equal | greaterThan))");
+  });
+
+  it("skips { type: undefined } entries in and", () => {
+    const filter: F = { type: "and", filters: [empty, eq1, empty] };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("(equal)");
+  });
+
+  it("skips { type: undefined } entries in or", () => {
+    const filter: F = { type: "or", filters: [empty, eq1, empty, eq2] };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("(equal | equal)");
+  });
+
+  it("returns empty and when all children are undefined", () => {
+    const filter: F = { type: "and", filters: [empty, empty] };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("()");
+  });
+
+  it("returns empty or when all children are undefined", () => {
+    const filter: F = { type: "or", filters: [empty] };
+    expect(traverseFilterSpec(filter, toStringVisitor)).toBe("()");
+  });
+
+  it("works with CommonNode/CommonLeaf metadata", () => {
+    type MetaLeaf = FilterSpecLeaf<string>;
+    type MetaFilter = FilterSpec<MetaLeaf, { _id: number }, { _id: number }>;
+
+    const filter: MetaFilter = {
+      type: "and",
+      _id: 1,
+      filters: [
+        { type: "equal", column: "c1", x: 1, _id: 2 },
+        { type: "greaterThan", column: "c2", x: 5, _id: 3 },
+      ],
+    };
+
+    const result = traverseFilterSpec(filter, {
+      leaf: (l) => [l._id],
+      and: (r) => r.flat(),
+      or: (r) => r.flat(),
+      not: (r) => r,
+    });
+
+    expect(result).toEqual([2, 3]);
+  });
+});
+
+describe("collectFilterSpecColumns", () => {
+  it("collects column from a single leaf", () => {
+    expect(collectFilterSpecColumns(eq1)).toEqual(["c1"]);
+  });
+
+  it("collects columns from and", () => {
+    const filter: F = { type: "and", filters: [eq1, eq2, gt] };
+    expect(collectFilterSpecColumns(filter)).toEqual(["c1", "c2", "c3"]);
+  });
+
+  it("collects columns from nested structure", () => {
+    const filter: F = {
+      type: "or",
+      filters: [
+        { type: "not", filter: eq1 },
+        { type: "and", filters: [eq2, gt] },
+      ],
+    };
+    expect(collectFilterSpecColumns(filter)).toEqual(["c1", "c2", "c3"]);
+  });
+
+  it("collects rhs fields", () => {
+    const filter: F = { type: "greaterThanColumn", column: "c1", rhs: "c2" };
+    expect(collectFilterSpecColumns(filter)).toEqual(["c1", "c2"]);
+  });
+
+  it("skips { type: undefined } entries", () => {
+    const filter: F = { type: "and", filters: [empty, eq1, empty] };
+    expect(collectFilterSpecColumns(filter)).toEqual(["c1"]);
+  });
+
+  it("returns empty array for all-empty and", () => {
+    const filter: F = { type: "and", filters: [empty, empty] };
+    expect(collectFilterSpecColumns(filter)).toEqual([]);
+  });
+
+  it("returns empty array for empty leaf", () => {
+    expect(collectFilterSpecColumns(empty)).toEqual([]);
+  });
+});