[MLv2] js wrappers for remove and replace clause (#29775)

* WIP Initial commit, not sure of difference between Clause and Field

* Finish wrappers for remove-clause and replace-clause

frontend/src/metabase-lib/order_by.ts

@@ -19,3 +19,11 @@ declare function OrderByFn(
 ): Query;
 
 export const orderBy: typeof OrderByFn = ML.order_by;
+
+export function orderByClause(
+  query: Query,
+  stageNumber: number,
+  field: Field,
+): Field {
+  return ML.order_by_clause(query, stageNumber, field);
+}

frontend/src/metabase-lib/order_by.unit.spec.ts

@@ -59,4 +59,51 @@ describe("order by", () => {
       expect(ML.displayName(nextQuery, orderBys[0])).toBe("Title ascending");
     });
   });
+
+  describe("replace order by", () => {
+    const query = createQuery();
+
+    it("should update the query", () => {
+      const columns = ML.orderableColumns(query);
+      const productTitle = columns.find(
+        column => column.id === SAMPLE_DATABASE.PRODUCTS.TITLE.id,
+      );
+
+      const productCategory = columns.find(
+        column => column.id === SAMPLE_DATABASE.PRODUCTS.CATEGORY.id,
+      );
+      const orderedQuery = ML.orderBy(query, productTitle as Field);
+      const orderBys = ML.orderBys(orderedQuery);
+
+      expect(orderBys).toHaveLength(1);
+      const nextQuery = ML.replaceClause(
+        orderedQuery,
+        orderBys[0],
+        ML.orderByClause(orderedQuery, -1, productCategory as Field) as Field,
+      );
+      const nextOrderBys = ML.orderBys(nextQuery);
+      expect(ML.displayName(nextQuery, nextOrderBys[0])).toBe(
+        "Category ascending",
+      );
+      expect(orderBys[0]).not.toEqual(nextOrderBys[0]);
+    });
+  });
+
+  describe("remove order by", () => {
+    const query = createQuery();
+
+    it("should update the query", () => {
+      const columns = ML.orderableColumns(query);
+      const productTitle = columns.find(
+        column => column.id === SAMPLE_DATABASE.PRODUCTS.TITLE.id,
+      );
+
+      const orderedQuery = ML.orderBy(query, productTitle as Field);
+      const orderBys = ML.orderBys(orderedQuery);
+      expect(orderBys).toHaveLength(1);
+
+      const nextQuery = ML.removeClause(orderedQuery, orderBys[0]);
+      expect(ML.orderBys(nextQuery)).toHaveLength(0);
+    });
+  });
 });

frontend/src/metabase-lib/query.ts

 import * as ML from "cljs/metabase.lib.js";
-import type { DatabaseId, DatasetQuery } from "metabase-types/api";
-import type { MetadataProvider, Query } from "./types";
+import type { DatabaseId, DatasetQuery, Field } from "metabase-types/api";
+import type { Clause, MetadataProvider, Query } from "./types";
 
 export function fromLegacyQuery(
   databaseId: DatabaseId,
@@ -17,3 +17,26 @@ export function toLegacyQuery(query: Query): DatasetQuery {
 export function suggestedName(query: Query): string {
   return ML.suggestedName(query);
 }
+
+declare function RemoveClauseFn(query: Query, targetClause: Clause): Query;
+declare function RemoveClauseFn(
+  query: Query,
+  stageIndex: number,
+  targetClause: Clause,
+): Query;
+
+export const removeClause: typeof RemoveClauseFn = ML.remove_clause;
+
+declare function ReplaceClauseFn(
+  query: Query,
+  targetClause: Clause,
+  newClause: Field,
+): Query;
+declare function ReplaceClauseFn(
+  query: Query,
+  stageIndex: number,
+  targetClause: Clause,
+  newClause: Field,
+): Query;
+
+export const replaceClause: typeof ReplaceClauseFn = ML.replace_clause;

src/metabase/lib/js.cljs

@@ -104,6 +104,11 @@
    (-> (lib.order-by/orderable-columns a-query stage-number)
        (clj->js :keyword-fn u/qualified-name))))
 
+(defn ^:export order-by-clause
+  "Create an order-by clause independently of a query, e.g. for `replace` or whatever."
+  [a-query stage-number x]
+  (lib.order-by/order-by-clause a-query stage-number (lib.normalize/normalize (js->clj x :keywordize-keys true))))
+
 (defn ^:export order-by
   "Add an `order-by` clause to `a-query`. Returns updated query."
   ([a-query x]
@@ -128,3 +133,22 @@
    (some-> (lib.order-by/order-bys a-query stage-number)
            not-empty
            to-array)))
+
+(defn ^:export remove-clause
+  "Removes the `target-clause` in the filter of the `query`."
+  ([a-query clause]
+   (remove-clause a-query -1 clause))
+  ([a-query stage-number clause]
+   (lib.query/remove-clause
+     a-query stage-number
+     (lib.normalize/normalize (js->clj clause :keywordize-keys true)))))
+
+(defn ^:export replace-clause
+  "Replaces the `target-clause` with `new-clause` in the `query` stage."
+  ([a-query target-clause new-clause]
+   (replace-clause a-query -1 target-clause new-clause))
+  ([a-query stage-number target-clause new-clause]
+   (lib.query/replace-clause
+     a-query stage-number
+     (lib.normalize/normalize (js->clj target-clause :keywordize-keys true))
+     (lib.normalize/normalize (js->clj new-clause :keywordize-keys true)))))

src/metabase/lib/order_by.cljc

@@ -90,7 +90,7 @@
      (lib.util/update-query-stage query stage-number update :order-by (fn [order-bys]
                                                                         (conj (vec order-bys) new-order-by))))))
 
-(mu/defn ^:export order-bys :- [:maybe [:sequential ::lib.schema.order-by/order-by]]
+(mu/defn order-bys :- [:maybe [:sequential ::lib.schema.order-by/order-by]]
   "Get the order-by clauses in a query."
   ([query :- ::lib.schema/query]
    (order-bys query -1))

src/metabase/lib/query.cljc

@@ -14,7 +14,7 @@
    [metabase.util.malli :as mu]))
 
 (mu/defn replace-clause :- :metabase.lib.schema/query
-  "Replaces the `target-clause` with `new-clase` in the `query` stage."
+  "Replaces the `target-clause` with `new-clause` in the `query` stage."
   ([query :- :metabase.lib.schema/query
     target-clause
     new-clause]