@platforma-sdk/model 1.54.10 → 1.54.13

package/src/filters/traverse.ts

@@ -1,4 +1,24 @@
-import type { FilterSpecLeaf, FilterSpecNode } from "@milaboratories/pl-model-common";
+import type {
+  FilterSpec,
+  FilterSpecLeaf,
+  FilterSpecNode,
+  InferFilterSpecLeafColumn,
+} from "@milaboratories/pl-model-common";
+import type {
+  InferFilterSpecCommonLeaf,
+  InferFilterSpecLeaf,
+} from "@milaboratories/pl-model-common";
+
+export type FilterSpecVisitor<LeafArg, R> = {
+  /** Handle a leaf filter node. */
+  leaf: (leaf: LeafArg) => 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;
+};
 
 /**
  * Recursively traverses a FilterSpec tree bottom-up, applying visitor callbacks.
@@ -11,50 +31,50 @@ import type { FilterSpecLeaf, FilterSpecNode } from "@milaboratories/pl-model-co
  * 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;
-  },
+export function traverseFilterSpec<
+  F extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>,
+  R,
+>(
+  filter: F,
+  visitor: FilterSpecVisitor<InferFilterSpecCommonLeaf<F> & InferFilterSpecLeaf<F>, R>,
+): R {
+  return traverseFilterSpecImpl(filter, visitor as FilterSpecVisitor<unknown, R>);
+}
+/** Internal implementation with simple generics for clean recursion. */
+function traverseFilterSpecImpl<R>(
+  filter: FilterSpecNode<FilterSpecLeaf<unknown>, unknown, unknown>,
+  visitor: FilterSpecVisitor<unknown, R>,
 ): R {
   switch (filter.type) {
     case "and":
       return visitor.and(
         filter.filters
           .filter((f) => f.type !== undefined)
-          .map((f) => traverseFilterSpec(f, visitor)),
+          .map((f) => traverseFilterSpecImpl(f, visitor)),
       );
     case "or":
       return visitor.or(
         filter.filters
           .filter((f) => f.type !== undefined)
-          .map((f) => traverseFilterSpec(f, visitor)),
+          .map((f) => traverseFilterSpecImpl(f, visitor)),
       );
     case "not":
-      return visitor.not(traverseFilterSpec(filter.filter, visitor));
+      return visitor.not(traverseFilterSpecImpl(filter.filter, visitor));
     default:
-      return visitor.leaf(filter as CommonLeaf & Leaf);
+      return visitor.leaf(filter);
   }
 }
 
 /** 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[] {
+  F extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>,
+  R extends InferFilterSpecLeafColumn<F> = InferFilterSpecLeafColumn<F>,
+>(filter: F): R[] {
   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);
+      const cols: R[] = [];
+      if ("column" in leaf && leaf.column !== undefined) cols.push(leaf.column as R);
+      if ("rhs" in leaf && leaf.rhs !== undefined) cols.push(leaf.rhs as R);
       return cols;
     },
     and: (results) => results.flat(),