Add JS wrappers for filter and filters (#31700)

Fixes #31673

frontend/src/metabase-lib/filter.ts

+import * as ML from "cljs/metabase.lib.js";
+
+import type {
+  BooleanExpression,
+  ColumnMetadata,
+  ColumnWithOperators,
+  ExpressionArg,
+  ExternalOp,
+  FilterOperator,
+  Query,
+} from "./types";
+
+export function filterableColumns(
+  query: Query,
+  stageIndex: number,
+): ColumnWithOperators[] {
+  return ML.filterable_columns(query, stageIndex);
+}
+
+export function filterableColumnOperators(
+  filterableColumn: ColumnWithOperators,
+): FilterOperator[] {
+  return ML.filterable_column_operators(filterableColumn);
+}
+
+export function filterClause(
+  filterOperator: FilterOperator,
+  column: ColumnMetadata,
+  ...args: ExpressionArg[]
+): ExternalOp {
+  return ML.filter_clause(filterOperator, column, ...args);
+}
+
+export function filter(
+  query: Query,
+  stageIndex: number,
+  booleanExpression: ExternalOp,
+): Query {
+  return ML.filter(query, stageIndex, booleanExpression);
+}
+
+export function filters(query: Query, stageIndex: number): BooleanExpression[] {
+  return ML.filters(query, stageIndex);
+}

frontend/src/metabase-lib/types.ts

@@ -29,12 +29,20 @@ export type Clause = BreakoutClause | OrderByClause;
 declare const ColumnMetadata: unique symbol;
 export type ColumnMetadata = unknown & { _opaque: typeof ColumnMetadata };
 
+declare const ColumnWithOperators: unique symbol;
+export type ColumnWithOperators = unknown & {
+  _opaque: typeof ColumnWithOperators;
+};
+
 declare const ColumnGroup: unique symbol;
 export type ColumnGroup = unknown & { _opaque: typeof ColumnGroup };
 
 declare const Bucket: unique symbol;
 export type Bucket = unknown & { _opaque: typeof Bucket };
 
+declare const BooleanExpression: unique symbol;
+export type BooleanExpression = unknown & { _opaque: typeof BooleanExpression };
+
 export type TableDisplayInfo = {
   name: string;
   displayName: string;
@@ -95,3 +103,10 @@ export type JoinStrategy =
   | "right-join"
   | "inner-join"
   | "full-join";
+
+export type ExpressionArg =
+  | boolean
+  | number
+  | string
+  | ColumnMetadata
+  | ExternalOp;

frontend/src/metabase-lib/v2.ts

@@ -9,6 +9,7 @@ export * from "./breakout";
 export * from "./fields";
 export * from "./limit";
 export * from "./order_by";
+export * from "./filter";
 export * from "./join";
 export * from "./query";
 export * from "./temporal_bucket";

src/metabase/lib/js.cljs

 (ns metabase.lib.js
   "JavaScript-friendly interface to the entire Metabase lib? This stuff will probably change a bit as MLv2 evolves."
+  (:refer-clojure
+   :exclude
+   [filter])
   (:require
    [medley.core :as m]
    [metabase.lib.convert :as convert]
@@ -373,12 +376,9 @@
 
 (defn ^:export filterable-columns
   "Get the available filterable columns for the stage with `stage-number` of
-  the query `a-query`.
-  If `stage-number` is omitted, the last stage is used."
-  ([a-query]
-   (filterable-columns a-query -1))
-  ([a-query stage-number]
-   (to-array (lib.core/filterable-columns a-query stage-number))))
+  the query `a-query`."
+  [a-query stage-number]
+  (to-array (lib.core/filterable-columns a-query stage-number)))
 
 (defn ^:export filterable-column-operators
   "Returns the operators for which `filterable-column` is applicable."
@@ -391,6 +391,19 @@
   [filter-operator column & args]
   (apply lib.core/filter-clause filter-operator column args))
 
+(defn ^:export filter
+  "Sets `boolean-expression` as a filter on `query`."
+  [a-query stage-number boolean-expression]
+  (lib.core/filter a-query stage-number (js->clj boolean-expression :keywordize-keys true)))
+
+(defn ^:export filters
+  "Returns the current filters in stage with `stage-number` of `query`.
+  Logicaly, the filter attached to the query is the conjunction of the expressions
+  in the returned list. If the returned list is empty, then there is no filter
+  attached to the query."
+  [a-query stage-number]
+  (to-array (lib.core/filters a-query stage-number)))
+
 (defn ^:export fields
   "Get the current `:fields` in a query. Unlike the lib core version, this will return an empty sequence if `:fields` is
   not specified rather than `nil` for JS-friendliness."