@platforma-sdk/model 1.54.9 → 1.54.10

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([]);
+  });
+});

package/src/filters/traverse.ts

@@ -0,0 +1,64 @@
+import type { FilterSpecLeaf, FilterSpecNode } from "@milaboratories/pl-model-common";
+
+/**
+ * Recursively traverses a FilterSpec tree bottom-up, applying visitor callbacks.
+ *
+ * Entries with `{ type: undefined }` inside `and`/`or` arrays are skipped
+ * (these represent unfilled filter slots in the UI).
+ *
+ * Traversal order:
+ * 1. Recurse into child filters (`and`/`or`/`not`)
+ * 2. Apply the corresponding visitor callback with already-traversed children
+ * 3. For leaf nodes, call `leaf` directly
+ */
+export function traverseFilterSpec<Leaf extends FilterSpecLeaf<unknown>, CommonNode, CommonLeaf, R>(
+  filter: FilterSpecNode<Leaf, CommonNode, CommonLeaf>,
+  visitor: {
+    /** Handle a leaf filter node. */
+    leaf: (leaf: CommonLeaf & Leaf) => R;
+    /** Handle an AND node after children have been traversed. */
+    and: (results: R[]) => R;
+    /** Handle an OR node after children have been traversed. */
+    or: (results: R[]) => R;
+    /** Handle a NOT node after the inner filter has been traversed. */
+    not: (result: R) => R;
+  },
+): R {
+  switch (filter.type) {
+    case "and":
+      return visitor.and(
+        filter.filters
+          .filter((f) => f.type !== undefined)
+          .map((f) => traverseFilterSpec(f, visitor)),
+      );
+    case "or":
+      return visitor.or(
+        filter.filters
+          .filter((f) => f.type !== undefined)
+          .map((f) => traverseFilterSpec(f, visitor)),
+      );
+    case "not":
+      return visitor.not(traverseFilterSpec(filter.filter, visitor));
+    default:
+      return visitor.leaf(filter as CommonLeaf & Leaf);
+  }
+}
+
+/** Collects all column references (`column` and `rhs` fields) from filter leaves. */
+export function collectFilterSpecColumns<
+  Leaf extends FilterSpecLeaf<unknown>,
+  CommonNode,
+  CommonLeaf,
+>(filter: FilterSpecNode<Leaf, CommonNode, CommonLeaf>): string[] {
+  return traverseFilterSpec(filter, {
+    leaf: (leaf) => {
+      const cols: string[] = [];
+      if ("column" in leaf && leaf.column !== undefined) cols.push(leaf.column as string);
+      if ("rhs" in leaf && leaf.rhs !== undefined) cols.push(leaf.rhs as string);
+      return cols;
+    },
+    and: (results) => results.flat(),
+    or: (results) => results.flat(),
+    not: (result) => result,
+  });
+}

package/src/pframe_utils/querySpec.ts

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

package/src/render/api.ts

@@ -28,6 +28,7 @@ import type {
 } from "@milaboratories/pl-model-common";
 import {
   AnchoredIdDeriver,
+  collectSpecQueryColumns,
   ensurePColumn,
   extractAllColumns,
   isDataInfo,
@@ -62,7 +63,6 @@ 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 { collectQueryColumns } from "@milaboratories/pl-model-common";
 
 /**
  * Helper function to match domain objects
@@ -682,7 +682,7 @@ export abstract class RenderCtxBase<Args, Data> {
   }
 
   public createPTableV2(def: PTableDefV2<PColumn<PColumnDataUniversal>>): PTableHandle | undefined {
-    const columns = collectQueryColumns(def.query);
+    const columns = collectSpecQueryColumns(def.query);
     this.verifyInlineAndExplicitColumnsSupport(columns);
     if (!allPColumnsReady(columns)) return undefined;
     return this.ctx.createPTableV2(mapPTableDefV2(def, (po) => transformPColumnData(po)));