Remove a bit of dead code

.clj-kondo/babashka/fs/config.edn

@@ -0,0 +1 @@
+{:lint-as {babashka.fs/with-temp-dir clojure.core/let}}

.clj-kondo/babashka/sci/config.edn

@@ -0,0 +1 @@
+{:hooks {:macroexpand {sci.core/copy-ns sci.core/copy-ns}}}

.clj-kondo/babashka/sci/sci/core.clj

@@ -0,0 +1,9 @@
+(ns sci.core)
+
+(defmacro copy-ns
+  ([ns-sym sci-ns]
+   `(copy-ns ~ns-sym ~sci-ns nil))
+  ([ns-sym sci-ns opts]
+   `[(quote ~ns-sym)
+     ~sci-ns
+     (quote ~opts)]))

.clj-kondo/better-cond/better-cond/better_cond/core.clj

@@ -0,0 +1,145 @@
+(ns better-cond.core
+  "A clj-kondo hook to allow linting of better-cond `cond` macro.
+  This supports better-cond version 2.0.0+.
+
+  To use in a project, change the namespace to hooks.better-cond,
+  put this code in file .clj-kondo/hooks/better_cond.clj, and include
+  a config.edn entry in the :hooks key like:
+
+    :hooks {:analyze-call {better-cond.core/cond hooks.better-cond/cond}}
+
+  Note that the expansion of :when-let and :when-some forms currently
+  takes a shortcut that *would* lead to incorrect values in some
+  cases of restructuring during actual expansion/evaluation, e.g.,
+  :when-let [[x y] nil] would not abort the cond, though :when-let
+  [[x y] [nil nil]] would. However, for linting purposes, the current
+  expansion approach works just fine. It seems unnecessary to do the
+  full expansion in these cases for linting purposes, though that could
+  be done if needed."
+  (:refer-clojure :exclude [cond])
+  (:require
+   [clj-kondo.hooks-api :as api]
+   [clojure.string :as str]))
+
+(def better-cond-simple-keys
+  "Special constructs in better cond, either as keywords or symbols.
+  This includes those keys that are simply transformed. Note that
+  :when-let and :when-some are *not* included as better-cond allows
+  multiple bindings but clojure does not. These two must be handled
+  separately."
+  #{:let :when :do
+    'let 'when 'do})
+
+(def better-cond-complex-keys
+  "Special constructs in better cond, either as keywords or symbols.
+  This includes those keys that require a multi-step transformation.
+  For example, :when-let and :when-some get converted to a let
+  wrapping a when, wrapping the continuing cond. Note that clojure
+  does not support multiple bindings in the standard when-let and
+  when-some macros."
+  {:when-let  'identity
+   'when-let  'identity
+   :when-some 'some?
+   'when-some 'some?})
+
+(defn extract-binding-forms
+  [bindings]
+  (keep-indexed #(when (even? %1) %2) bindings))
+
+(defn process-pairs
+  "Transforms a `cond` with the clauses given as a collection of explicit pairs.
+  Handles all the special better-cond constructs as keywords or symbols.
+  Returns a rewrite-clj list-node representing the transformed code."
+  [node-pairs]
+  (loop [[[lhs rhs :as pair] & pairs] node-pairs
+         new-body [(api/token-node 'clojure.core/cond)]] ; Avoid reprocessing the cond with ns here
+    (if pair
+      (let [lhs-sexpr (api/sexpr lhs)]
+        (clojure.core/cond
+          (= 1 (count pair)) ;; better-cond allows single clause for default
+          , (api/list-node (conj new-body (api/keyword-node :else) lhs))
+          (better-cond-simple-keys lhs-sexpr) ;; Handle special better-cond constructs
+          , (api/list-node
+             (conj new-body
+                   (api/keyword-node :else)
+                   (api/list-node [(api/token-node (symbol #_"clojure.core" (name lhs-sexpr)))
+                                   rhs
+                                   (process-pairs pairs)])))
+          (better-cond-complex-keys lhs-sexpr)  ;; Multi stage constructs
+          , (api/list-node
+             (conj new-body
+                   (api/keyword-node :else)
+                   (api/list-node [(api/token-node 'let)
+                                   rhs
+                                   (api/list-node [(api/token-node 'when)
+                                                   (api/list-node    ;; ATTN: shortcut here; fine for linting
+                                                    [(api/token-node 'every?)
+                                                     (api/token-node (better-cond-complex-keys lhs-sexpr))
+                                                     (api/vector-node (->> rhs
+                                                                           api/sexpr
+                                                                           extract-binding-forms
+                                                                           (map api/token-node)))])
+                                                   (process-pairs pairs)])])))
+          :else
+          , (recur pairs (conj new-body lhs rhs))))
+      (api/list-node new-body))))
+
+(defn cond-hook
+  [{:keys [node]}]
+  (let [expr (let [args (rest (:children node))
+                   pairs (partition-all 2 args)]
+               (process-pairs pairs))]
+    {:node (with-meta expr
+             (meta node))}))
+
+(defn process-if-let-pairs [pairs then else]
+  (if (seq pairs)
+    (let [[lhs rhs] (first pairs)]
+      (if (and (api/keyword-node? lhs)
+               (= :let (api/sexpr lhs)))
+        (api/list-node (conj [(api/token-node 'clojure.core/let) rhs
+                              (process-if-let-pairs (next pairs) then else)]))
+        (let [test (api/token-node (gensym "test"))]
+          (api/list-node
+           (conj [(api/token-node 'clojure.core/let) (api/vector-node [test rhs])
+                  (api/list-node [(api/token-node 'if) test
+                                  (api/list-node
+                                   [(api/token-node 'clojure.core/let)
+                                    (api/vector-node [lhs test])
+                                    (process-if-let-pairs (next pairs) then else)])
+                                  else])])))))
+    then))
+
+(defn if-let-hook
+  [{:keys [node]}]
+  (let [expr (let [[binding-vec then else] (rest (:children node))
+                   pairs (partition-all 2 (:children binding-vec))
+                   node (process-if-let-pairs pairs then else)]
+               node)]
+    {:node (with-meta expr
+             (meta node))}))
+
+(defn when-let-hook
+  [{:keys [node]}]
+  (let [expr (let [[binding-vec & body] (rest (:children node))]
+               (api/list-node
+                [(api/token-node 'better-cond.core/if-let)
+                 binding-vec
+                 (api/list-node (list* (api/token-node 'do)
+                                       body))]))]
+    {:node (with-meta expr
+             (meta node))}))
+
+(defn defnc-hook [{:keys [node]}]
+  (let [[defnc-node name-node arg-node & body]
+        (:children node)
+        new-node (api/list-node [(api/token-node (if (str/ends-with? (str defnc-node)
+                                                                     "defnc-")
+                                                   'clojure.core/defn-
+                                                   'clojure.core/defn))
+                                 name-node
+                                 arg-node
+                                 (api/list-node
+                                  (list* (api/token-node 'better-cond.core/cond)
+                                         body))])]
+    {:node new-node}))

.clj-kondo/better-cond/better-cond/config.edn

@@ -0,0 +1,9 @@
+{:hooks
+ {:analyze-call
+  {better-cond.core/cond better-cond.core/cond-hook
+   better-cond.core/defnc better-cond.core/defnc-hook
+   better-cond.core/defnc- better-cond.core/defnc-hook
+   better-cond.core/if-let better-cond.core/if-let-hook
+   better-cond.core/if-some better-cond.core/if-let-hook
+   better-cond.core/when-let better-cond.core/when-let-hook
+   better-cond.core/when-some better-cond.core/when-let-hook}}}

.clj-kondo/com.gfredericks/test.chuck/clj_kondo/com/gfredericks/test/chuck/checking.clj

@@ -0,0 +1,19 @@
+(ns clj-kondo.com.gfredericks.test.chuck.checking
+  (:require
+   [clj-kondo.hooks-api :as api]))
+
+(defn checking
+  [{{:keys [children]} :node}]
+  (let [[_checking desc & opt+bindings+body] children
+        [opts binding-vec & body]             (if (api/vector-node? (first opt+bindings+body))
+                                                (into [(api/map-node {})] opt+bindings+body)
+                                                opt+bindings+body)]
+    (when-not (even? (count (:children binding-vec)))
+      (throw (ex-info "checking requires an even number of bindings" {})))
+    {:node (api/list-node
+            (list*
+             (api/token-node 'let)
+             (api/vector-node (into [(api/token-node (symbol (gensym "_checking-desc"))) desc]
+                                    (:children binding-vec)))
+             opts
+             body))}))

.clj-kondo/com.gfredericks/test.chuck/config.edn

@@ -0,0 +1,4 @@
+{:hooks
+ {:analyze-call
+  {com.gfredericks.test.chuck.clojure-test/checking
+   clj-kondo.com.gfredericks.test.chuck.checking/checking}}}

.clj-kondo/com.github.camsaul/humane-are/config.edn

@@ -0,0 +1,2 @@
+{:lint-as
+ {humane-are.core/are+ clojure.test/are}}

.clj-kondo/com.github.camsaul/toucan2/config.edn

@@ -0,0 +1,39 @@
+{:config-paths
+ ["macros"]
+
+ :lint-as
+ {toucan2.core/build             clojure.core/identity
+  toucan2.core/compile           clojure.core/identity
+  toucan2.query/with-built-query clojure.core/let
+  toucan2.tools.compile/build    clojure.core/identity
+  toucan2.tools.compile/compile  clojure.core/identity}
+
+ :hooks
+ {:analyze-call
+  {toucan2.connection/with-connection                      hooks.toucan2.connection/with-connection
+   toucan2.connection/with-transaction                     hooks.toucan2.connection/with-transaction
+   toucan2.core/with-connection                            hooks.toucan2.connection/with-connection
+   toucan2.core/with-transaction                           hooks.toucan2.connection/with-transaction
+   toucan2.tools.simple-out-transform/define-out-transform hooks.toucan2.tools.simple-out-transform/define-out-transform
+   toucan2.tools.with-temp/with-temp                       hooks.toucan2.tools.with-temp/with-temp}
+
+  :macroexpand
+  {toucan.db/with-call-counting                       macros.toucan2.execute/with-call-count
+   toucan.models/defmodel                             macros.toucan.models/defmodel
+   toucan2.core/define-after-insert                   macros.toucan2.tools.after-insert/define-after-insert
+   toucan2.core/define-after-select                   macros.toucan2.tools.helpers/define-after-select
+   toucan2.core/define-after-update                   macros.toucan2.tools.after-update/define-after-update
+   toucan2.core/define-before-delete                  macros.toucan2.tools.helpers/define-before-delete
+   toucan2.core/define-before-insert                  macros.toucan2.tools.before-insert/define-before-insert
+   toucan2.core/define-before-select                  macros.toucan2.tools.helpers/define-before-select
+   toucan2.core/define-before-update                  macros.toucan2.tools.before-update/define-before-update
+   toucan2.execute/with-call-count                    macros.toucan2.execute/with-call-count
+   toucan2.tools.after-insert/define-after-insert     macros.toucan2.tools.after-insert/define-after-insert
+   toucan2.tools.after-select/define-after-select     macros.toucan2.tools.helpers/define-after-select
+   toucan2.tools.after-update/define-after-update     macros.toucan2.tools.after-update/define-after-update
+   toucan2.tools.before-delete/define-before-delete   macros.toucan2.tools.helpers/define-before-delete
+   toucan2.tools.before-insert/define-before-insert   macros.toucan2.tools.before-insert/define-before-insert
+   toucan2.tools.before-select/define-before-select   macros.toucan2.tools.helpers/define-before-select
+   toucan2.tools.before-update/define-before-update   macros.toucan2.tools.before-update/define-before-update
+   toucan2.tools.default-fields/define-default-fields macros.toucan2.tools.default-fields/define-default-fields
+   toucan2.tools.named-query/define-named-query       macros.toucan2.tools.named-query/define-named-query}}}

.clj-kondo/com.github.camsaul/toucan2/hooks/toucan2/connection.clj

@@ -0,0 +1,14 @@
+(ns hooks.toucan2.connection
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(defn with-connection [{{[_ bindings & body] :children} :node}]
+  (let [[conn-binding connectable] (:children bindings)]
+    {:node (hooks/list-node
+            (list*
+             (hooks/token-node 'let)
+             (hooks/vector-node [conn-binding (or connectable
+                                                  (hooks/token-node 'nil))])
+             body))}))
+
+(defn with-transaction [node]
+  (with-connection node))

.clj-kondo/com.github.camsaul/toucan2/hooks/toucan2/tools/simple_out_transform.clj

@@ -0,0 +1,37 @@
+(ns hooks.toucan2.tools.simple-out-transform
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(defn- ignore-unused-binding [x]
+  (vary-meta x assoc :clj-kondo/ignore [:unused-binding]))
+
+(defn define-out-transform
+  [{{[_define-out-transform dispatch-value {[instance-binding] :children, :as bindings} & body] :children, :as node} :node}]
+  {:node (-> (hooks/list-node
+              [(hooks/token-node 'do)
+               dispatch-value
+               (hooks/list-node
+                (list*
+                 (hooks/token-node 'fn)
+                 (-> (hooks/vector-node
+                      [(ignore-unused-binding (with-meta (hooks/token-node '&query-type)  (meta bindings)))
+                       (ignore-unused-binding (with-meta (hooks/token-node '&model)       (meta bindings)))
+                       instance-binding])
+                     (with-meta (meta bindings)))
+                 body))])
+             (with-meta (meta node)))})
+
+(comment
+  (defn test-define-out-transform []
+    (as-> '(tools.simple-out-transform/define-out-transform [:toucan.query-type/select.instances ::after-select]
+             [instance]
+             (let [wow 1000]
+               ;; don't do after-select if this select is a result of doing something like insert-returning instances
+               (if (isa? &query-type :toucan2.pipeline/select.instances-from-pks)
+                 instance
+                 (after-select instance)))) <>
+        (hooks/parse-string (pr-str <>))
+        (define-out-transform {:node <>})
+        (:node <>)
+        (hooks/sexpr <>)
+        (binding [*print-meta* false #_true]
+          (clojure.pprint/pprint <>)))))

.clj-kondo/com.github.camsaul/toucan2/hooks/toucan2/tools/with_temp.clj

@@ -0,0 +1,22 @@
+(ns hooks.toucan2.tools.with-temp
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(defn with-temp [{{[_with-temp {bindings :children} & body] :children} :node}]
+  (let [bindings* (into
+                   []
+                   (comp (partition-all 3)
+                         (mapcat (fn [[model binding attributes]]
+                                   (let [binding    (or binding (hooks/token-node '_))
+                                         attributes (or attributes (hooks/token-node 'nil))]
+                                     [binding (hooks/list-node
+                                               (list
+                                                (hooks/token-node 'do)
+                                                model
+                                                attributes))]))))
+                   bindings)
+        node*         (hooks/list-node
+                       (list*
+                        (hooks/token-node 'let)
+                        (hooks/vector-node bindings*)
+                        body))]
+    {:node node*}))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan/models.clj

@@ -0,0 +1,5 @@
+(ns macros.toucan.models)
+
+(defmacro defmodel
+  [model _table-name]
+  `(def ~model "Docstring." ~(keyword (name model))))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/common.clj

@@ -0,0 +1,4 @@
+(ns macros.toucan2.common)
+
+(defn ignore-unused [symb]
+  (vary-meta symb assoc :clj-kondo/ignore [:unused-binding]))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/execute.clj

@@ -0,0 +1,6 @@
+(ns macros.toucan2.execute)
+
+(defmacro with-call-count
+  [[call-count-fn-binding] & body]
+  `(let [~call-count-fn-binding (fn [])]
+     ~@body))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/tools/after_insert.clj

@@ -0,0 +1,10 @@
+(ns macros.toucan2.tools.after-insert
+  (:require [macros.toucan2.common :as common]))
+
+(defmacro define-after-insert
+  [model [instance-binding] & body]
+  `(do
+     ~model
+     (fn [~(common/ignore-unused '&model)
+          ~instance-binding]
+       ~@body)))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/tools/after_update.clj

@@ -0,0 +1,10 @@
+(ns macros.toucan2.tools.after-update
+  (:require [macros.toucan2.common :as common]))
+
+(defmacro define-after-update
+  [model [instance-binding] & body]
+  `(do
+     ~model
+     (fn [~(common/ignore-unused '&model)
+          ~instance-binding]
+       ~@body)))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/tools/before_insert.clj

@@ -0,0 +1,10 @@
+(ns macros.toucan2.tools.before-insert
+  (:require [macros.toucan2.common :as common]))
+
+(defmacro define-before-insert
+  [model [instance-binding] & body]
+  `(do
+     ~model
+     (fn [~(common/ignore-unused '&model)
+          ~instance-binding]
+       ~@body)))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/tools/before_update.clj

@@ -0,0 +1,10 @@
+(ns macros.toucan2.tools.before-update
+  (:require [macros.toucan2.common :as common]))
+
+(defmacro define-before-update
+  [model [instance-binding] & body]
+  `(do
+     ~model
+     (fn [~(common/ignore-unused '&model)
+          ~instance-binding]
+       ~@body)))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/tools/default_fields.clj

@@ -0,0 +1,6 @@
+(ns macros.toucan2.tools.default-fields
+  (:require [macros.toucan2.common :as common]))
+
+(defmacro define-default-fields [model & body]
+  `(let [~(common/ignore-unused '&model) ~model]
+     ~@body))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/tools/helpers.clj

@@ -0,0 +1,27 @@
+(ns macros.toucan2.tools.helpers
+  (:require [macros.toucan2.common :as common]))
+
+(defmacro define-before-select [dispatch-value [args-binding] & body]
+  `(do
+     ~dispatch-value
+     (fn [~(common/ignore-unused '&query-type)
+          ~(common/ignore-unused '&model)
+          ~args-binding]
+       ~@body)))
+
+(defmacro define-after-select [model [instance-binding] & body]
+  `(do
+     ~model
+     (fn [~(common/ignore-unused '&query-type)
+          ~(common/ignore-unused '&model)
+          ~(common/ignore-unused '&parsed-args)
+          ~instance-binding]
+       ~@body)))
+
+(defmacro define-before-delete
+  [model [instance-binding] & body]
+  `(do
+     ~model
+     (fn [~(common/ignore-unused '&model)
+          ~instance-binding]
+       ~@body)))

.clj-kondo/com.github.camsaul/toucan2/macros/toucan2/tools/named_query.clj

@@ -0,0 +1,22 @@
+(ns macros.toucan2.tools.named-query
+  (:require [macros.toucan2.common :as common]))
+
+;;; separate function because recursive macroexpansion doesn't seem to work.
+(defn- define-named-query*
+  [query-name query-type model resolved-query]
+  `(do
+     ~query-name
+     ~query-type
+     ~model
+     (fn [~(common/ignore-unused '&query-type)
+          ~(common/ignore-unused '&model)
+          ~(common/ignore-unused '&parsed-args)
+          ~(common/ignore-unused '&unresolved-query)]
+       ~resolved-query)))
+
+(defmacro define-named-query
+  ([query-name resolved-query]
+   (define-named-query* query-name :default :default resolved-query))
+
+  ([query-name query-type model resolved-query]
+   (define-named-query* query-name query-type model resolved-query)))

.clj-kondo/com.github.metabase/hawk/config.edn

@@ -0,0 +1,4 @@
+{:linters
+ {:unresolved-symbol
+  {:exclude
+   [(clojure.test/is [partial= re= schema= =?])]}}}

.clj-kondo/com.github.seancorfield/next.jdbc/config.edn

@@ -0,0 +1,5 @@
+{:hooks
+ {:analyze-call
+  {next.jdbc/with-transaction
+   hooks.com.github.seancorfield.next-jdbc/with-transaction}}
+ :lint-as {next.jdbc/on-connection clojure.core/with-open}}

.clj-kondo/com.github.seancorfield/next.jdbc/hooks/com/github/seancorfield/next_jdbc.clj

@@ -0,0 +1,18 @@
+(ns hooks.com.github.seancorfield.next-jdbc
+  (:require [clj-kondo.hooks-api :as api]))
+
+(defn with-transaction
+  "Expands (with-transaction [tx expr opts] body)
+  to (let [tx expr] opts body) pre clj-kondo examples."
+  [{:keys [:node]}]
+  (let [[binding-vec & body] (rest (:children node))
+        [sym val opts] (:children binding-vec)]
+    (when-not (and sym val)
+      (throw (ex-info "No sym and val provided" {})))
+    (let [new-node (api/list-node
+                    (list*
+                     (api/token-node 'let)
+                     (api/vector-node [sym val])
+                     opts
+                     body))]
+      {:node new-node})))

.clj-kondo/com.github.seancorfield/next.jdbc/hooks/com/github/seancorfield/next_jdbc.clj_kondo

@@ -0,0 +1,18 @@
+(ns hooks.com.github.seancorfield.next-jdbc
+  (:require [clj-kondo.hooks-api :as api]))
+
+(defn with-transaction
+  "Expands (with-transaction [tx expr opts] body)
+  to (let [tx expr] opts body) per clj-kondo examples."
+  [{:keys [:node]}]
+  (let [[binding-vec & body] (rest (:children node))
+        [sym val opts] (:children binding-vec)]
+    (when-not (and sym val)
+      (throw (ex-info "No sym and val provided" {})))
+    (let [new-node (api/list-node
+                    (list*
+                     (api/token-node 'let)
+                     (api/vector-node [sym val])
+                     opts
+                     body))]
+      {:node new-node})))

.clj-kondo/hooks/clojure/test.clj

@@ -0,0 +1,52 @@
+(ns hooks.clojure.test
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(def disallowed-parallel-forms
+  '#{with-redefs
+     clojure.core/with-redefs
+     metabase.test/with-temporary-setting-values
+     mt/with-temporary-setting-values})
+
+(defn warn-about-disallowed-parallel-forms [form]
+  (letfn [(f [form]
+            (when-let [sexpr (and (hooks/token-node? form)
+                                  (hooks/sexpr form))]
+              (when (disallowed-parallel-forms sexpr)
+                (hooks/reg-finding! (assoc (meta form)
+                                           :message (format "%s is not allowed inside a ^:parallel test" sexpr)
+                                           :type :metabase/validate-deftest)))))
+          (walk [form]
+            (f form)
+            (doseq [child (:children form)]
+              (walk child)))]
+    (walk form)))
+
+(defn deftest [{{[_ test-name & body] :children, :as node} :node}]
+  (let [test-metadata     (:meta test-name)
+        metadata-sexprs   (map hooks/sexpr test-metadata)
+        combined-metadata (transduce
+                           (map (fn [x]
+                                  (if (map? x)
+                                    x
+                                    {x true})))
+                           (completing merge)
+                           {}
+                           metadata-sexprs)
+        parallel?     (:parallel combined-metadata)
+        synchronized? (:synchronized combined-metadata)]
+    (when (and parallel? synchronized?)
+      (hooks/reg-finding! (assoc (meta test-name)
+                                 :message "Test should not be marked both ^:parallel and ^:synchronized"
+                                 :type :metabase/validate-deftest)))
+    ;; only when the custom `:metabase/deftest-not-marked-parallel` is enabled: complain if tests are not explicitly
+    ;; marked `^:parallel` or `^:synchronized`. This is mostly to encourage people to mark everything `^:parallel` in
+    ;; places like `metabase.lib` tests unless there is a really good reason not to.
+    (when-not (or parallel? synchronized?)
+      (hooks/reg-finding!
+       (assoc (meta test-name)
+              :message "Test should be marked either ^:parallel or ^:synchronized"
+              :type :metabase/deftest-not-marked-parallel-or-synchronized)))
+    (when parallel?
+      (doseq [form body]
+        (warn-about-disallowed-parallel-forms form))))
+  {:node node})

.clj-kondo/hooks/common.clj

@@ -0,0 +1,293 @@
+(ns hooks.common
+  (:require [clj-kondo.hooks-api :as hooks]
+            [clojure.pprint]))
+
+(defn with-macro-meta
+  "When introducing internal nodes (let, defn, etc) it is important to provide a meta of an existing token
+   as the current version of kondo will use the whole form by default."
+  [new-node hook-node]
+  (with-meta new-node (meta (first (:children hook-node)))))
+
+;;; This stuff is to help debug hooks. Trace a function and it will pretty-print the before & after sexprs.
+;;;
+;;;    (hooks.common/trace #'calculate-bird-scarcity)
+
+(defn- trace* [f]
+  {:pre [(fn? f)]}
+  (fn traced-fn [node]
+    (println \newline)
+    (clojure.pprint/pprint (hooks/sexpr (:node node)))
+    (let [node* (f node)]
+      (println '=>)
+      (clojure.pprint/pprint (hooks/sexpr (:node node*)))
+      node*)))
+
+;;; this doesn't seem to work with SCI. Use [[defn-traced]] instead.
+
+;; (defn trace [varr]
+;;   {:pre [(var? varr)]}
+;;   (when-not (::traced? (meta varr))
+;;     (alter-var-root varr trace*)
+;;     (alter-meta! varr assoc ::traced? true)
+;;     (println "Traced" varr)))
+
+(defmacro defn-traced
+  "Replace a hook [[defn]] with this to trace the before and after sexprs."
+  [fn-name & fn-tail]
+  `(do
+     (defn fn# ~@fn-tail)
+     (def ~fn-name (trace* fn#))))
+
+;;;; Common hook definitions
+
+(defn do*
+  "This is the same idea as [[clojure.core/do]] but doesn't cause Kondo to complain about redundant dos or unused values."
+  [{{[_ & args] :children, :as node} :node}]
+  (let [node* (-> (hooks/list-node
+                   (list*
+                    (with-meta (hooks/token-node 'do) {:clj-kondo/ignore [:redundant-do]})
+                    (for [arg args]
+                      (vary-meta arg update :clj-kondo/ignore #(conj (vec %) :unused-value)))))
+                  (with-meta (meta node)))]
+    {:node node*}))
+
+(defn with-one-binding
+  "Helper for macros that have a shape like
+
+    (my-macro [x]
+      ...)
+
+    =>
+
+    (let [x nil]
+      ...)
+
+  Binding is optional and `_` will be substituted if not supplied."
+  [{{[_ {[x] :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 [(or x (hooks/token-node '_)) (hooks/token-node 'nil)])
+                body))]
+    {:node node*}))
+
+(defn with-two-bindings
+  "Helper for macros that have a shape like
+
+    (my-macro [x y]
+      ...)
+
+    =>
+
+    (let [x nil, y nil]
+      ...)
+
+  All bindings are optional and `_` will be substituted if not supplied."
+  [{{[_ {[x y] :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 [(or x (hooks/token-node '_)) (hooks/token-node 'nil)
+                  (or y (hooks/token-node '_)) (hooks/token-node 'nil)])
+                body))]
+    {:node node*}))
+
+(defn with-three-bindings
+  "Helper for macros that have a shape like
+
+    (my-macro [x y z]
+      ...)
+
+    =>
+
+    (let [x nil, y nil, z nil]
+      ...)
+
+  All bindings are optional and `_` will be substituted if not supplied."
+  [{{[_ {[x y z] :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 [(or x (hooks/token-node '_)) (hooks/token-node 'nil)
+                  (or y (hooks/token-node '_)) (hooks/token-node 'nil)
+                  (or z (hooks/token-node '_)) (hooks/token-node 'nil)])
+                body))]
+    {:node node*}))
+
+(defn with-four-bindings
+  "Helper for macros that have a shape like
+
+    (my-macro [a b c d]
+      ...)
+
+    =>
+
+    (let [a nil, b nil, c nil, d nil]
+      ...)
+
+  All bindings are optional and `_` will be substituted if not supplied."
+  [{{[_ {[a b c d] :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 [(or a (hooks/token-node '_)) (hooks/token-node 'nil)
+                  (or b (hooks/token-node '_)) (hooks/token-node 'nil)
+                  (or c (hooks/token-node '_)) (hooks/token-node 'nil)
+                  (or d (hooks/token-node '_)) (hooks/token-node 'nil)])
+                body))]
+    {:node node*}))
+
+(defn with-one-top-level-binding
+  "Helper for macros that have a shape like
+
+    (my-macro x
+      ...)
+
+    =>
+
+    (let [x nil]
+      ...)"
+  [{{[_ x & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 [x (hooks/token-node 'nil)])
+                body))]
+    {:node node*}))
+
+(defn with-two-top-level-bindings
+  "Helper for macros that have a shape like
+
+    (my-macro x y
+      ...)
+
+    =>
+
+    (let [x nil, y nil]
+      ...)"
+  [{{[_ x y & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 [x (hooks/token-node 'nil)
+                  y (hooks/token-node 'nil)])
+                body))]
+    {:node node*}))
+
+(defn let-one-with-optional-value
+  "This is exactly like [[clojure.core/let]] but the right-hand side of the binding, `value`, is optional, and only one
+  binding can be established.
+
+    (some-macro [x] ...)
+    =>
+    (let [x nil] ...)
+
+    (some-macro [x 100] ...)
+    =>
+    (let [x 100] ...)"
+  [{{[_ {[binding value] :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 [binding (or value (hooks/token-node 'nil))])
+                body))]
+    {:node node*}))
+
+(defn- let-second-inner [body bindings]
+  (let [binding-infos (for [[model {[binding value] :children}] (partition 2 bindings)]
+                        {:model   model
+                         :binding binding
+                         :value   (or value
+                                      (hooks/token-node 'nil))})]
+    (-> (hooks/vector-node
+         [(hooks/vector-node (map :model binding-infos))
+          (-> (hooks/list-node (list* (hooks/token-node `let)
+                                    (hooks/vector-node (mapcat (juxt :binding :value) binding-infos))
+                                    body))
+              (with-meta (meta body)))])
+        (with-meta (meta body)))))
+
+(defn let-second
+  "Helper for macros that have a shape like
+
+    (my-macro x [y]
+    ...)
+
+    where the let is for second arg.
+
+    =>
+
+    (let [y nil]
+    ...)"
+  [{:keys [node]}]
+  (let [[_ first-arg-ref binding+opts & body] (:children node)]
+    {:node (let-second-inner body [first-arg-ref binding+opts])}))
+
+(defn let-with-optional-value-for-last-binding
+  "This is exactly like [[clojure.core/let]] but the right-hand side of the *last* binding, `value`, is optional.
+
+    (some-macro [x] ...)
+    =>
+    (let [x nil] ...)
+
+    (some-macro [x 100] ...)
+    =>
+    (let [x 100] ...)"
+  [{{[_ {bindings :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 (into []
+                       (comp (partition-all 2)
+                             (mapcat (fn [[binding value]]
+                                       [binding (or value (hooks/token-node 'nil))])))
+                       bindings))
+                body))]
+    {:node node*}))
+
+(defn with-ignored-first-arg
+  "For macros like
+
+    (discard-setting-changes [setting-1 setting-2]
+      ...)
+
+    =>
+
+    (do ...)
+
+  where the first arg ought to be ignored for linting purposes."
+  [{{[_ _x & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'do)
+                body))]
+    {:node node*}))
+
+(defn with-used-first-arg
+  "For macros like
+
+    (with-drivers (filter pred? some-drivers)
+      ...)
+
+    =>
+
+    (let [_1234 (filter pred? some-drivers)]
+      ...)
+
+  where the first arg should be linted and appear to be used."
+  [{{[_ arg & body] :children} :node}]
+  (let [node* (hooks/list-node
+                (list*
+                  (hooks/token-node 'let)
+                  (hooks/vector-node [(hooks/token-node (gensym "_"))
+                                      arg])
+                  body))]
+    {:node node*}))

.clj-kondo/hooks/metabase/api/common.clj

@@ -0,0 +1,29 @@
+(ns hooks.metabase.api.common
+  (:require
+   [clj-kondo.hooks-api :as hooks]
+   [clojure.string :as str]
+   [hooks.common :as common]))
+
+(defn route-fn-name
+  "route fn hook"
+  [method route]
+  (let [route (if (vector? route) (first route) route)]
+    (-> (str (name method) route)
+        (str/replace #"/" "_")
+        symbol)))
+
+(defn defendpoint
+  "defendpoint hook"
+  [{:keys [node]}]
+  (let [[method route & body] (rest (:children node))]
+    {:node
+     (hooks/vector-node [;; register usage of compojure core var
+                         (common/with-macro-meta (hooks/token-node (symbol (str "compojure.core")
+                                                                           (str method)))
+                           node)
+                         ;; define function with route-fn-name
+                         (hooks/list-node
+                           (list* (common/with-macro-meta (hooks/token-node 'clojure.core/defn)
+                                    node)
+                                  (route-fn-name (hooks/sexpr method) (hooks/sexpr route))
+                                  body))])}))

.clj-kondo/hooks/metabase/db/schema_migrations_test/impl.clj

@@ -0,0 +1,14 @@
+(ns hooks.metabase.db.schema-migrations-test.impl
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(defn test-migrations
+  [{{[_ migration-range {[binding] :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node `let)
+                (hooks/vector-node
+                 [binding (hooks/list-node (list (hooks/token-node `fn)
+                                                 (hooks/vector-node [])))])
+                migration-range
+                body))]
+    {:node node*}))

.clj-kondo/hooks/metabase/mbql/schemas/macros.clj

@@ -0,0 +1,68 @@
+(ns hooks.metabase.mbql.schemas.macros
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(defn- unwrap-defclause-clause-name
+  "The `clause-name-form` can be either a plain symbol, or a vector like `[var-name mbql-clause-name]`. For the vector
+  form, we are only interested in the `var-name`. For a plain symbol, the two names are the same. Return a token node."
+  [clause-name-form]
+  (-> (if (hooks/vector-node? clause-name-form)
+        (first (:children clause-name-form))
+        clause-name-form)
+      (with-meta (meta clause-name-form))))
+
+(defn- collect-defclause-body-schemas
+  "Collect the argument schemas in the body of a `defclause` form into a vector node.
+
+  The body is a sequence of <argument-name> <argument-schema> pairs. We can ignore the argument names.
+
+  <argument-schema> can optionally be wrapped be `(optional ...)` or `(rest ...)`... we can ignore these."
+  [arg-specs]
+  (hooks/vector-node
+   (for [[_arg-name arg-schema] (partition-all 2 arg-specs)
+         :let                   [arg-schema (if (and (hooks/list-node? arg-schema)
+                                                     ('#{optional rest} (hooks/sexpr (first (:children arg-schema)))))
+                                              (-> (second (:children arg-schema))
+                                                  (with-meta (meta arg-schema)))
+                                              arg-schema)]]
+     arg-schema)))
+
+(defn defclause
+  "e.g.
+
+    (defclause [ag:var var] field-or-expression FieldOrExpressionDef)
+    =>
+    (def ag:var [FieldOrExpressionDef])"
+  [{:keys [node]}]
+  (let [[_defclause clause-name-form & arg-specs] (:children node)]
+    {:node (-> (hooks/list-node
+                (list
+                 (hooks/token-node 'def)
+                 (unwrap-defclause-clause-name clause-name-form)
+                 (hooks/string-node "Docstring.")
+                 (collect-defclause-body-schemas arg-specs)))
+               (with-meta (meta node)))}))
+
+(comment
+  (defn- defclause* [form]
+    (hooks/sexpr
+     (:node
+      (defclause
+        {:node
+         (hooks/parse-string
+          (with-out-str
+            (clojure.pprint/pprint
+             form)))}))))
+
+  (defn- x []
+    (defclause* '(defclause [ag:var var]
+                   field-or-expression FieldOrExpressionDef)))
+  ;; =>
+  (def ag:var "Docstring." [FieldOrExpressionDef])
+
+  (defn- y []
+    (defclause* '(defclause var
+                   x (some-list-schema)
+                   y (optional FieldOrExpressionDef)
+                   z (rest (some-other-schema)))))
+  ;; =>
+  (def var "Docstring." [(some-list-schema) FieldOrExpressionDef (some-other-schema)]))

.clj-kondo/hooks/metabase/models/interface.clj

@@ -0,0 +1,18 @@
+(ns hooks.metabase.models.interface
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(defn define-hydration-method
+  "This is used for both [[metabase.models.interface/define-simple-hydration-method]] and
+  for [[metabase.models.interface/define-batched-hydration-method]]."
+  [{{[_define-simple-hydration-method fn-name hydration-key & fn-tail] :children, :as node} :node}]
+  (let [node (-> (hooks/list-node
+                  (list
+                   (hooks/token-node 'do)
+                   hydration-key
+                   (hooks/list-node
+                    (list*
+                     (hooks/token-node 'defn)
+                     fn-name
+                     fn-tail))))
+                 (with-meta (update (meta node) :clj-kondo/ignore #(hooks/vector-node (cons :clojure-lsp/unused-public-var (:children %))))))]
+    {:node node}))

.clj-kondo/hooks/metabase/models/setting.clj

@@ -0,0 +1,71 @@
+(ns hooks.metabase.models.setting
+  (:require
+   [clj-kondo.hooks-api :as hooks]
+   [hooks.common :as common]))
+
+(defn defsetting
+  "Rewrite a [[metabase.models.defsetting]] form like
+
+    (defsetting my-setting \"Description\" :type :boolean)
+
+  as
+
+    (let [_ \"Description\"
+          _ :type
+          _ :boolean]
+      (defn my-setting \"Docstring.\" [])
+      (defn my-setting! \"Docstring.\" [_value-or-nil]))
+
+  for linting purposes."
+  [{:keys [node]}]
+  (let [[setting-name & args] (rest (:children node))
+        ;; (defn my-setting [] ...)
+        getter-node           (-> (list
+                                   (hooks/token-node 'defn)
+                                   setting-name
+                                   (hooks/string-node "Docstring.")
+                                   (hooks/vector-node []))
+                                  hooks/list-node
+                                  (with-meta (meta node)))
+        ;; (defn my-setting! [_x] ...)
+        setter-node           (-> (list
+                                   (hooks/token-node 'defn)
+                                   (with-meta
+                                     (hooks/token-node (symbol (str (hooks/sexpr setting-name) \!)))
+                                     (meta setting-name))
+                                   (hooks/string-node "Docstring.")
+                                   (hooks/vector-node [(hooks/token-node '_value-or-nil)]))
+                                  hooks/list-node
+                                  (with-meta (update (meta node) :clj-kondo/ignore #(hooks/vector-node (cons :clojure-lsp/unused-public-var (:children %))))))]
+    {:node (-> (list
+                (hooks/token-node 'let)
+                ;; include description and the options map so they can get validated as well.
+                (hooks/vector-node (vec (interleave (repeat (common/with-macro-meta (hooks/token-node '_) node))
+                                                    args)))
+                getter-node
+                setter-node)
+               hooks/list-node
+               (with-meta (meta node)))}))
+
+(comment
+  (defn- defsetting* [form]
+    (hooks/sexpr
+     (:node
+      (defsetting
+        {:node
+         (hooks/parse-string
+          (with-out-str
+            (clojure.pprint/pprint
+             form)))}))))
+
+  (defn- x []
+    (defsetting*
+      '(defsetting active-users-count
+         (deferred-tru "Cached number of active users. Refresh every 5 minutes.")
+         :visibility :admin
+         :type       :integer
+         :default    0
+         :getter     (fn []
+                       (if-not ((requiring-resolve 'metabase.db/db-is-set-up?))
+                         0
+                         (cached-active-users-count)))))))

.clj-kondo/hooks/metabase/public_settings/premium_features.clj

@@ -1,7 +1,6 @@
 (ns hooks.metabase.public-settings.premium-features
   (:require
-   [clj-kondo.hooks-api :as hooks]
-   [hooks.common]))
+   [clj-kondo.hooks-api :as hooks]))
 
 (defn defenterprise [{node :node}]
   (let [[_defenterprise fn-name & args] (:children node)
@@ -27,8 +26,7 @@
                                  fn-name
                                  docstring))
                    fn-tail))
-                 (with-meta (meta node))
-                 hooks.common/add-lsp-ignore-unused-public-var-metadata)))}))
+                 (with-meta (update (meta node) :clj-kondo/ignore #(hooks/vector-node (cons :clojure-lsp/unused-public-var (:children %))))))))}))
 
 (comment
   (defn- defenterprise* [form]

.clj-kondo/hooks/metabase/test/data.clj

@@ -11,10 +11,6 @@
   []
   (not-empty (set (keys (:clj (hooks/ns-analysis 'metabase.test.data.dataset-definitions))))))
 
-(defn- local-def?
-  [ns* sexpr]
-  (= ns* (:ns (hooks/resolve {:name sexpr}))))
-
 (defn- dataset-type
   "`dataset` can be one of:
 
@@ -25,7 +21,7 @@
 
   We can only determine if an unqualified symbol refers to something in the dataset definitions namespace if there are
   cached results available from [[global-dataset-symbols]]."
-  [this-ns dataset]
+  [dataset]
   (let [sexpr       (hooks/sexpr dataset)
         global-defs (global-dataset-symbols)]
     (cond
@@ -35,19 +31,20 @@
       (namespace sexpr)
       :qualified
 
+      (empty? global-defs)
+      :unqualified/unknown
+
       (contains? global-defs sexpr)
       :unqualified/from-dataset-defs-namespace
 
-      (local-def? this-ns sexpr)
-      :unqualified/local-def
-
+      ;; either something defined in the current namespace or let-bound in the current scope.
       :else
-      :unqualified/unknown)))
+      :unqualified/local-def)))
 
 (defn dataset
-  [{{[_ dataset & body] :children} :node this-ns :ns}]
+  [{{[_ dataset & body] :children} :node}]
   (let [noop (constantly nil)
-        body (case (dataset-type this-ns dataset)
+        body (case (dataset-type dataset)
                ;; non-symbol, qualified symbols, and unqualified symbols from the current namespace/let-bound can all
                ;; get converted from something like
                ;;
@@ -142,7 +139,7 @@
     (when-not ((some-fn symbol? nil?) (hooks/sexpr table))
       (hooks/reg-finding! (assoc (meta table)
                                  :message "First arg to mbql-query should be either a table name symbol or nil."
-                                 :type :metabase/mbql-query-first-arg)))
+                                 :type ::mbql-query-first-arg)))
     (let [result (replace-$id-special-tokens query)
           ;; HACK I'm not sure WHY it works but I ran into https://github.com/clj-kondo/clj-kondo/issues/1773 when
           ;; trying to get this working -- for some magical reason wrapping the whole thing in a `do` form seems to fix

.clj-kondo/hooks/metabase/test/util.clj

@@ -0,0 +1,60 @@
+(ns hooks.metabase.test.util
+  (:require [clj-kondo.hooks-api :as hooks]
+            [hooks.common :as common]))
+
+(defn- namespaced-symbol-node? [node]
+  (when (hooks/token-node? node)
+    (let [symb (hooks/sexpr node)]
+      (and (symbol? symb)
+           (namespace symb)))))
+
+(defn with-temporary-setting-values
+  "Rewrite a form like
+
+    (with-temporary-setting-values [x 1, some.ns/y 2]
+      ...)
+
+  as one like
+
+    (let [_ 1, _ some.ns/y, _ 2]
+      ...)
+
+  for analysis purposes. We only need to 'capture' namespaced Setting bindings with a `_` so Kondo considers their
+  namespace to be 'used' and to catch undefined var usage."
+  [{:keys [node]}]
+  (let [{[_ bindings & body] :children} node
+        bindings (if (hooks/vector-node? bindings)
+                   (hooks/vector-node (into []
+                                            (mapcat (fn [[setting-name v]]
+                                                      (concat
+                                                        [(with-meta (hooks/token-node '_) (meta setting-name)) v]
+                                                        ;; if the setting name is namespace-qualified add a `_`
+                                                        ;; entry for it too.
+                                                        (when (namespaced-symbol-node? setting-name)
+                                                          [(with-meta (hooks/token-node '_) (meta setting-name)) setting-name]))))
+                                            (partition 2 (:children bindings))))
+                   bindings)]
+    {:node (-> (list*
+                (hooks/token-node 'let)
+                bindings
+                body)
+               (with-meta (meta body))
+               hooks/list-node
+               (with-meta (meta body)))}))
+
+(defn with-temp-file
+  [{{[_ {bindings :children} & body] :children} :node}]
+  (let [node* (hooks/list-node
+               (list*
+                (hooks/token-node 'let)
+                (hooks/vector-node
+                 (into []
+                       (comp (partition-all 2)
+                             (mapcat (fn [[binding filename]]
+                                       [binding (or (when (and filename
+                                                               (not (nil? (hooks/sexpr filename))))
+                                                      filename)
+                                                    (hooks/string-node "filename"))])))
+                       bindings))
+                body))]
+    {:node node*}))

.clj-kondo/macros/metabase/api/collection_test.clj

@@ -1,7 +1,7 @@
 (ns macros.metabase.api.collection-test
   (:require [macros.common]))
 
-(defmacro with-collection-hierarchy! [bindings & body]
+(defmacro with-collection-hierarchy [bindings & body]
   `(let [~(macros.common/ignore-unused 'a) nil
          ~(macros.common/ignore-unused 'b) nil
          ~(macros.common/ignore-unused 'c) nil
@@ -12,6 +12,6 @@
      ~bindings
      ~@body))
 
-(defmacro with-some-children-of-collection! [collection-or-id-or-nil & body]
+(defmacro with-some-children-of-collection [collection-or-id-or-nil & body]
   `(let [~(macros.common/ignore-unused '&ids) ~collection-or-id-or-nil]
      ~@body))

.clj-kondo/macros/metabase/api/common.clj

@@ -1,7 +1,5 @@
 (ns macros.metabase.api.common)
 
-(defmacro define-routes
-  "Macro for api.common/define-routes"
-  [& args]
+(defmacro define-routes [& args]
   `(do (def ~'routes "docstring" nil)
        ~@args))

.clj-kondo/macros/metabase/api/embed_test.clj

@@ -1,11 +1,11 @@
 (ns macros.metabase.api.embed-test)
 
-(defmacro with-embedding-enabled-and-temp-card-referencing!
+(defmacro with-embedding-enabled-and-temp-card-referencing
   [table-kw field-kw [card-binding] & body]
   `(let [~card-binding [~table-kw ~field-kw]]
      ~@body))
 
-(defmacro with-embedding-enabled-and-temp-dashcard-referencing!
+(defmacro with-embedding-enabled-and-temp-dashcard-referencing
   [table-kw field-kw [dash-binding card-binding dashcard-binding] & body]
   `(let [~dash-binding             [~table-kw ~field-kw]
          ~(or card-binding '_)     nil

.clj-kondo/macros/metabase/api/public_test.clj

@@ -1,11 +1,11 @@
 (ns macros.metabase.api.public-test)
 
-(defmacro with-sharing-enabled-and-temp-card-referencing!
+(defmacro with-sharing-enabled-and-temp-card-referencing
   [table-kw field-kw [card-binding] & body]
   `(let [~card-binding [~table-kw ~field-kw]]
      ~@body))
 
-(defmacro with-sharing-enabled-and-temp-dashcard-referencing!
+(defmacro with-sharing-enabled-and-temp-dashcard-referencing
   [table-kw field-kw [dash-binding card-binding dashcard-binding] & body]
   `(let [~dash-binding             [~table-kw ~field-kw]
          ~(or card-binding '_)     nil

.clj-kondo/macros/metabase/domain_entities/malli.clj

@@ -0,0 +1,16 @@
+(ns macros.metabase.domain-entities.malli)
+
+(defmacro define-getters-and-setters [schema & defs]
+  `(do
+     (comment ~schema) ;; Reference the schema
+     ~@(for [[sym _path] (partition 2 defs)]
+         `(do
+            (defn ~(vary-meta sym
+                              assoc :export true)
+              "docs" [_x#] nil)
+            (defn ~(vary-meta (symbol (str "with-" (name sym)))
+                              assoc :export true)
+              "docs" [x# _new#] x#)
+            (defn ~(vary-meta (symbol (str (name sym) "-js"))
+                              assoc :export true)
+              "docs" [x#] x#)))))

.clj-kondo/macros/metabase/models/query_analysis_test.clj

@@ -1,9 +0,0 @@
-(ns macros.metabase.models.query-analysis-test
-  (:require [macros.common]))
-
-(defmacro with-test-setup [& body]
-  `(let [~(macros.common/ignore-unused 'card-id)  1
-         ~(macros.common/ignore-unused 'table-id) 2
-         ~(macros.common/ignore-unused 'tax-id)   3
-         ~(macros.common/ignore-unused 'total-id) 4]
-     ~@body))

.clj-kondo/macros/metabase/shared/util/namespaces.clj

@@ -0,0 +1,8 @@
+(ns macros.metabase.shared.util.namespaces)
+
+(defmacro import-fn
+  "Kondo macro replacement for [[metabase.shared.util.namespaces/import-fn]]."
+  ([sym]
+   `(def ~(-> sym name symbol) "docstring" ~sym))
+  ([sym name]
+   `(def ~name "docstring" ~sym)))

.clj-kondo/macros/metabase/task/setup/query_analysis_setup.clj

@@ -1,13 +0,0 @@
-(ns macros.metabase.task.setup.query-analysis-setup
-  (:require [macros.common]))
-
-(defmacro with-test-setup!
-  "Set up the data required to test the Query Analysis related tasks"
-  [& body]
-  `(let [~(macros.common/ignore-unused 'c1) 1
-         ~(macros.common/ignore-unused 'c2) 2
-         ~(macros.common/ignore-unused 'c3) 3
-         ~(macros.common/ignore-unused 'c4) 4
-         ~(macros.common/ignore-unused 'archived) 5
-         ~(macros.common/ignore-unused 'invalid) 6]
-     ~@body))

.clj-kondo/macros/metabase/test/persistence.clj

@@ -1,5 +1,5 @@
 (ns macros.metabase.test.persistence)
 
-(defmacro with-persistence-enabled! [[persist-fn-sym] & body]
+(defmacro with-persistence-enabled [[persist-fn-sym] & body]
   `(clojure.core/let [~persist-fn-sym (fn [])]
      ~@body))

.clj-kondo/macros/metabase/test/util.clj

@@ -1,11 +1,11 @@
 (ns macros.metabase.test.util)
 
-(defmacro with-temp-env-var-value! [bindings & body]
+(defmacro with-temp-env-var-value [bindings & body]
   `((constantly nil)
     ~@(map second (partition-all 2 bindings))
     ~@body))
 
 (defmacro with-temporary-raw-setting-values [bindings & body]
   `((constantly nil)
-    ~@(map second (partition-all 2 bindings))
+     ~@(map second (partition-all 2 bindings))
      ~@body))

.clj-kondo/macros/metabase/util/namespaces.clj

@@ -1,8 +0,0 @@
-(ns macros.metabase.util.namespaces)
-
-(defmacro import-fn
-  "Kondo macro replacement for [[metabase.util.namespaces/import-fn]]."
-  ([sym]
-   `(def ~(-> sym name symbol) "docstring" ~sym))
-  ([sym name]
-   `(def ~name "docstring" ~sym)))

.clj-kondo/macros/metabase/xrays/domain_entities/malli.clj

@@ -1,16 +0,0 @@
-(ns macros.metabase.xrays.domain-entities.malli)
-
-(defmacro define-getters-and-setters [schema & defs]
-  `(do
-     (comment ~schema) ;; Reference the schema
-     ~@(for [[sym _path] (partition 2 defs)]
-         `(do
-            (defn ~(vary-meta sym
-                              assoc :export true)
-              "docs" [_x#] nil)
-            (defn ~(vary-meta (symbol (str "with-" (name sym)))
-                              assoc :export true)
-              "docs" [x# _new#] x#)
-            (defn ~(vary-meta (symbol (str (name sym) "-js"))
-                              assoc :export true)
-              "docs" [x#] x#)))))

.clj-kondo/macros/metabase_enterprise/advanced_permissions/api/util_test.clj

@@ -1,6 +0,0 @@
-(ns macros.metabase-enterprise.advanced-permissions.api.util-test
-  (:require [macros.common]))
-
-(defmacro with-impersonations! [impersonations-and-attributes-map & body]
-  `(let [~(macros.common/ignore-unused '&group) ~impersonations-and-attributes-map]
-     ~@body))

.clj-kondo/macros/metabase_enterprise/query_reference_validation/api_test.clj

@@ -1,12 +0,0 @@
-(ns macros.metabase-enterprise.query-reference-validation.api-test
-  (:require [macros.common]))
-
-(defmacro with-test-setup! [& body]
-  `(let [~(macros.common/ignore-unused 'card-1) 1
-         ~(macros.common/ignore-unused 'card-2) 2
-         ~(macros.common/ignore-unused 'card-3) 3
-         ~(macros.common/ignore-unused 'card-4) 4
-         ~(macros.common/ignore-unused 'card-5) 5
-         ~(macros.common/ignore-unused 'coll-2) 100
-         ~(macros.common/ignore-unused 'coll-3) 200]
-     ~@body))

.clj-kondo/macros/metabase_enterprise/sandbox/test_util.clj

@@ -1,6 +1,6 @@
 (ns macros.metabase-enterprise.sandbox.test-util
   (:require [macros.common]))
 
-(defmacro with-gtaps! [gtaps-definition & body]
+(defmacro with-gtaps [gtaps-definition & body]
   `(let [~(macros.common/ignore-unused '&group) ~gtaps-definition]
      ~@body))

.clj-kondo/macros/metabase_enterprise/serialization/test_util.clj

@@ -37,7 +37,6 @@
          ~(macros.common/ignore-unused 'card-id-nested)               nil
          ~(macros.common/ignore-unused 'card-id-nested-query)         nil
          ~(macros.common/ignore-unused 'card-id-native-query)         nil
-         ~(macros.common/ignore-unused 'card-id-pivot-table)          nil
          ~(macros.common/ignore-unused 'dashcard-id)                  nil
          ~(macros.common/ignore-unused 'dashcard-top-level-click-id)  nil
          ~(macros.common/ignore-unused 'dashcard-with-click-actions)  nil

.clj-kondo/methodical/methodical/config.edn

@@ -0,0 +1,14 @@
+{:config-paths ["macros"]
+
+ :lint-as
+ {}
+
+ :hooks
+ {:analyze-call
+  {methodical.core/defmethod   hooks.methodical.macros/defmethod
+   methodical.core/defmulti    hooks.methodical.macros/defmulti
+   methodical.macros/defmethod hooks.methodical.macros/defmethod
+   methodical.macros/defmulti  hooks.methodical.macros/defmulti}
+
+  :macroexpand
+  {methodical.impl.combo.operator/defoperator macros.methodical.impl.combo.operator/defoperator}}}

.clj-kondo/methodical/methodical/hooks/methodical/core.clj

@@ -0,0 +1,68 @@
+(ns hooks.methodical.core
+  (:require [clj-kondo.hooks-api :as hooks]))
+
+(defn add-next-method [fn-tail]
+  (if (hooks/vector-node? (first fn-tail))
+    (let [[args & body] fn-tail]
+      (list*
+       (-> (hooks/vector-node
+            (cons (hooks/token-node 'next-method)
+                  (:children args)))
+           (with-meta (meta args)))
+       ;; so Kondo stops complaining about it being unused.
+       (hooks/token-node 'next-method)
+       body))
+    (for [list-node fn-tail]
+      (hooks/list-node (add-next-method (:children list-node))))))
+
+(defn defmethod
+  [{{[_ multimethod & [first-arg :as args]] :children, :as node} :node}]
+  #_(clojure.pprint/pprint (hooks/sexpr node))
+  (let [[aux-qualifier dispatch-value & fn-tail] (if (#{:before :after :around} (hooks/sexpr first-arg))
+                                                   (cons (hooks/sexpr first-arg) (rest args))
+                                                   (cons nil args))
+        fn-tail                                  (if (contains? #{:around nil} aux-qualifier)
+                                                   (add-next-method fn-tail)
+                                                   fn-tail)
+        result                                   (hooks/list-node
+                                                  (list* (hooks/token-node 'clojure.core/defmethod)
+                                                         multimethod
+                                                         dispatch-value
+                                                         fn-tail))]
+    #_(println "=>")
+    #_(clojure.pprint/pprint (hooks/sexpr result))
+    {:node result}))
+
+(defn defmulti
+  [{{[_ multimethod-name & args] :children, :as node} :node}]
+  #_(clojure.pprint/pprint (hooks/sexpr node))
+  (let [[docstring & args]         (if (hooks/string-node? (first args))
+                                     args
+                                     (cons nil args))
+        [attribute-map & args]     (if (hooks/map-node? (first args))
+                                     args
+                                     (cons nil args))
+        ;; if there wasn't a positional dispatch function arg passed just use (constantly nil) so Kondo won't complain
+        [dispatch-fn & kv-options] (if (odd? (count args))
+                                     args
+                                     (cons (hooks/list-node
+                                            (list
+                                             (hooks/token-node 'clojure.core/constantly)
+                                             (hooks/token-node 'nil)))
+                                           args))]
+    (let [defmulti-form (hooks/list-node
+                         (filter
+                          some?
+                          [(hooks/token-node 'clojure.core/defmulti)
+                           multimethod-name
+                           docstring
+                           attribute-map
+                           dispatch-fn]))
+          result   (hooks/list-node
+                    (list*
+                     (hooks/token-node 'do)
+                     defmulti-form
+                     kv-options))]
+      #_(println "=>")
+      #_(clojure.pprint/pprint (hooks/sexpr result))
+      {:node result})))

.clj-kondo/methodical/methodical/hooks/methodical/macros.clj

@@ -0,0 +1,185 @@
+(ns hooks.methodical.macros
+  (:refer-clojure :exclude [defmulti defmethod])
+  (:require
+   [clj-kondo.hooks-api :as hooks]))
+
+;;; The code below is basically simulating the spec for parsing defmethod args without using spec. It uses a basic
+;;; backtracking algorithm to achieve a similar result. Parsing defmethod args is kinda complicated.
+;;;
+;;; Unfortunately this is hardcoded to `:before`, `:after`, and `:around` as the only allowed qualifiers for now... at
+;;; some point in the future we'll have to figure out how to fix this and support other qualifiers too.
+
+(defn- bindings-vector? [x]
+  (and (hooks/vector-node? x)
+       (every? (some-fn hooks/token-node?
+                        hooks/map-node?
+                        hooks/vector-node?)
+               (:children x))))
+
+(defn- single-arity-fn-tail? [args]
+  (bindings-vector? (first args)))
+
+(defn- n-arity-fn-tail? [args]
+  (and (seq args)
+       (every? (fn [x]
+                 (and (hooks/list-node? x)
+                      (single-arity-fn-tail? (:children x))))
+               args)))
+
+(defn- fn-tail? [args]
+  (or (single-arity-fn-tail? args)
+      (n-arity-fn-tail? args)))
+
+(defn- qualifier? [x]
+  (and (hooks/keyword-node? x)
+       (#{:before :after :around} (hooks/sexpr x))))
+
+(defn- dispatch-value?
+  "A dispatch value can be anything except for qualifier keyword or a list that looks like part of a n-arity function tail
+  e.g. `([x] x)`."
+  [x]
+  (and (not (qualifier? x))
+       (or (not (hooks/list-node? x))
+           (not (single-arity-fn-tail? (:children x))))))
+
+(defonce ^:private backtrack (Exception.))
+
+(defn- parse-defmethod-args
+  ([unparsed]
+   (let [parses (atom [])]
+     (try
+       (parse-defmethod-args parses {} unparsed)
+       (catch Exception _
+         (when (zero? (count @parses))
+           (throw (ex-info (format "Unable to parse defmethod args: %s" (pr-str (mapv hooks/sexpr unparsed)))
+                           {:args (mapv hooks/sexpr unparsed)})))
+         (when (> (count @parses) 1)
+           (throw (ex-info (format "Ambiguous defmethod args: %s" (pr-str (mapv hooks/sexpr unparsed)))
+                           {:args (mapv hooks/sexpr unparsed)
+                            :parses @parses})))
+         (first @parses)))))
+
+  ([parses parsed unparsed]
+   (cond
+     (and (not (contains? parsed :qualifier))
+          (qualifier? (first unparsed)))
+     (try
+       (parse-defmethod-args parses (assoc parsed :qualifier (first unparsed)) (rest unparsed))
+       (catch Exception _
+         (parse-defmethod-args parses (assoc parsed :qualifier nil) unparsed)))
+
+     (and (not (contains? parsed :dispatch-value))
+          (dispatch-value? (first unparsed)))
+     (parse-defmethod-args parses (assoc parsed :dispatch-value (first unparsed)) (rest unparsed))
+
+     (not (contains? parsed :dispatch-value))
+     (throw backtrack)
+
+     (and (not (contains? parsed :unique-key))
+          (:qualifier parsed)           ; can only have unique keys for aux methods
+          (not (hooks/string-node? (first unparsed)))
+          (not (hooks/list-node? (first unparsed)))
+          (not (hooks/vector-node? (first unparsed))))
+     (try
+       (parse-defmethod-args parses (assoc parsed :unique-key (first unparsed)) (rest unparsed))
+       (catch Exception _
+         (parse-defmethod-args parses (assoc parsed :unique-key nil) unparsed)))
+
+     (and (not (contains? parsed :docstring))
+          (hooks/string-node? (first unparsed)))
+     (try
+       (parse-defmethod-args parses (assoc parsed :docstring (first unparsed)) (rest unparsed))
+       (catch Exception _
+         (parse-defmethod-args parses (assoc parsed :docstring nil) unparsed)))
+
+     (fn-tail? unparsed)
+     (do
+       (swap! parses conj (assoc parsed :fn-tail unparsed))
+       (throw backtrack))
+
+     :else
+     (throw backtrack))))
+
+(defn defmethod
+  [{{[_ multimethod & args] :children, :as node} :node}]
+  (#_println)
+  #_(clojure.pprint/pprint (hooks/sexpr node))
+  (let [parsed (parse-defmethod-args args)]
+    #_(doseq [[k v] parsed]
+        (println \newline k '=> (pr-str (some-> v hooks/sexpr))))
+    (let [fn-tail     (:fn-tail parsed)
+          other-stuff (dissoc parsed :fn-tail)
+          result      (hooks/list-node
+                       (concat
+                        [(hooks/token-node 'do)
+                         multimethod]
+                        (filter some? (vals other-stuff))
+                        [(-> (hooks/list-node
+                              (list*
+                               (hooks/token-node 'fn)
+                               (hooks/token-node (if (contains? #{nil :around} (some-> (:qualifier parsed) hooks/sexpr))
+                                                   'next-method
+                                                   '__FN__NAME__THAT__YOU__CANNOT__REFER__TO__))
+                               fn-tail))
+                             (vary-meta update :clj-kondo/ignore conj :redundant-fn-wrapper))]))]
+      #_(println "=>")
+      #_(clojure.pprint/pprint (hooks/sexpr result))
+      {:node result})))
+
+;;; this stuff is for debugging things to make sure we didn't do something dumb
+(comment
+  (defn defmethod* [form]
+    (binding [*print-meta* true]
+      (clojure.pprint/pprint
+       (hooks/sexpr (:node (defmethod {:node (hooks/parse-string (str form))}))))))
+
+  (defmethod* '(defmethod mf :second [& _] 2))
+
+  (defmethod* '(m/defmethod multi-arity :k
+                 ([x]
+                  {:x x})
+                 ([x y]
+                  {:x x, :y y})))
+
+  (defmethod* '(m/defmethod mf1 :docstring
+                 "Docstring"
+                 [_x]))
+
+  (defmethod* '(m/defmethod mf1 :around :dispatch-value
+                 "Docstring"
+                 [x]
+                 (next-method x))))
+
+(defn defmulti
+  [{{[_ multimethod-name & args] :children, :as node} :node}]
+  #_(clojure.pprint/pprint (hooks/sexpr node))
+  (let [[docstring & args]         (if (hooks/string-node? (first args))
+                                     args
+                                     (cons nil args))
+        [attribute-map & args]     (if (hooks/map-node? (first args))
+                                     args
+                                     (cons nil args))
+        ;; if there wasn't a positional dispatch function arg passed just use (constantly nil) so Kondo won't complain
+        [dispatch-fn & kv-options] (if (odd? (count args))
+                                     args
+                                     (cons (hooks/list-node
+                                            (list
+                                             (hooks/token-node 'clojure.core/constantly)
+                                             (hooks/token-node 'nil)))
+                                           args))]
+    (let [defmulti-form (hooks/list-node
+                         (filter
+                          some?
+                          [(hooks/token-node 'clojure.core/defmulti)
+                           multimethod-name
+                           docstring
+                           attribute-map
+                           dispatch-fn]))
+          result   (hooks/list-node
+                    (list*
+                     (hooks/token-node 'do)
+                     defmulti-form
+                     kv-options))]
+      #_(println "=>")
+      #_(clojure.pprint/pprint (hooks/sexpr result))
+      {:node result})))

.clj-kondo/methodical/methodical/macros/methodical/impl/combo/operator.clj

@@ -0,0 +1,7 @@
+(ns macros.methodical.impl.combo.operator)
+
+;; not exactly what actually happens but this is close enough to be able to lint it
+(defmacro defoperator [operator-name [methods-binding invoke-binding] & body]
+  `(defmethod methodical.impl.combo.operator/operator ~(keyword operator-name)
+     [~methods-binding ~invoke-binding]
+     ~@body))

.clj-kondo/metosin/malli/config.edn

@@ -0,0 +1,2 @@
+{:lint-as {malli.experimental/defn schema.core/defn}
+ :linters {:unresolved-symbol {:exclude [(malli.core/=>)]}}}

.clj-kondo/potemkin/potemkin/config.edn

@@ -0,0 +1,62 @@
+{:lint-as {potemkin.collections/compile-if      clojure.core/if
+           potemkin.collections/reify-map-type  clojure.core/reify
+           potemkin.collections/def-map-type    clj-kondo.lint-as/def-catch-all
+           potemkin.collections/def-derived-map clj-kondo.lint-as/def-catch-all
+
+           potemkin.types/reify+                clojure.core/reify
+           potemkin.types/defprotocol+          clojure.core/defprotocol
+           potemkin.types/deftype+              clojure.core/deftype
+           potemkin.types/defrecord+            clojure.core/defrecord
+           potemkin.types/definterface+         clojure.core/defprotocol
+           potemkin.types/extend-protocol+      clojure.core/extend-protocol
+           potemkin.types/def-abstract-type     clj-kondo.lint-as/def-catch-all
+
+           potemkin.utils/doit                  clojure.core/doseq
+           potemkin.utils/doary                 clojure.core/doseq
+           potemkin.utils/condp-case            clojure.core/condp
+           potemkin.utils/fast-bound-fn         clojure.core/bound-fn
+
+           potemkin.walk/prewalk                clojure.walk/prewalk
+           potemkin.walk/postwalk               clojure.walk/postwalk
+           potemkin.walk/walk                   clojure.walk/walk
+
+           ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+           ;;;; top-level from import-vars
+           ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+           ;; Have hooks
+           ;;potemkin/import-fn potemkin.namespaces/import-fn
+           ;;potemkin/import-macro potemkin.namespaces/import-macro
+           ;;potemkin/import-def potemkin.namespaces/import-def
+
+           ;; Internal, not transitive
+           ;;potemkin/unify-gensyms               potemkin.macros/unify-gensyms
+           ;;potemkin/normalize-gensyms           potemkin.macros/normalize-gensyms
+           ;;potemkin/equivalent?                 potemkin.macros/equivalent?
+
+           potemkin/condp-case                  clojure.core/condp
+           potemkin/doit                        potemkin.utils/doit
+           potemkin/doary                       potemkin.utils/doary
+
+           potemkin/def-abstract-type           clj-kondo.lint-as/def-catch-all
+           potemkin/reify+                      clojure.core/reify
+           potemkin/defprotocol+                clojure.core/defprotocol
+           potemkin/deftype+                    clojure.core/deftype
+           potemkin/defrecord+                  clojure.core/defrecord
+           potemkin/definterface+               clojure.core/defprotocol
+           potemkin/extend-protocol+            clojure.core/extend-protocol
+
+           potemkin/reify-map-type              clojure.core/reify
+           potemkin/def-derived-map             clj-kondo.lint-as/def-catch-all
+           potemkin/def-map-type                clj-kondo.lint-as/def-catch-all}
+
+ ;; leave import-vars alone, kondo special-cases it
+ :hooks   {:macroexpand {#_#_potemkin.namespaces/import-vars potemkin.namespaces/import-vars
+                         potemkin.namespaces/import-fn    potemkin.namespaces/import-fn
+                         potemkin.namespaces/import-macro potemkin.namespaces/import-macro
+                         potemkin.namespaces/import-def   potemkin.namespaces/import-def
+
+                         #_#_potemkin/import-vars potemkin.namespaces/import-vars
+                         potemkin/import-fn               potemkin.namespaces/import-fn
+                         potemkin/import-macro            potemkin.namespaces/import-macro
+                         potemkin/import-def              potemkin.namespaces/import-def}}}

.clj-kondo/potemkin/potemkin/potemkin/namespaces.clj

@@ -0,0 +1,56 @@
+(ns potemkin.namespaces
+  (:require [clj-kondo.hooks-api :as api]))
+
+(defn import-macro*
+  ([sym]
+   `(def ~(-> sym name symbol) ~sym))
+  ([sym name]
+   `(def ~name ~sym)))
+
+(defmacro import-fn
+  ([sym]
+   (import-macro* sym))
+  ([sym name]
+   (import-macro* sym name)))
+
+(defmacro import-macro
+  ([sym]
+   (import-macro* sym))
+  ([sym name]
+   (import-macro* sym name)))
+
+(defmacro import-def
+  ([sym]
+   (import-macro* sym))
+  ([sym name]
+   (import-macro* sym name)))
+
+#_
+(defmacro import-vars
+  "Imports a list of vars from other namespaces."
+  [& syms]
+  (let [unravel (fn unravel [x]
+                  (if (sequential? x)
+                    (->> x
+                         rest
+                         (mapcat unravel)
+                         (map
+                           #(symbol
+                              (str (first x)
+                                   (when-let [n (namespace %)]
+                                     (str "." n)))
+                              (name %))))
+                    [x]))
+        syms (mapcat unravel syms)
+        result `(do
+                  ~@(map
+                      (fn [sym]
+                        (let [vr (resolve sym)
+                              m (meta vr)]
+                          (cond
+                            (nil? vr) `(throw (ex-info (format "`%s` does not exist" '~sym) {}))
+                            (:macro m) `(def ~(-> sym name symbol) ~sym)
+                            (:arglists m) `(def ~(-> sym name symbol) ~sym)
+                            :else `(def ~(-> sym name symbol) ~sym))))
+                      syms))]
+    result))

.clj-kondo/prismatic/schema/config.edn

@@ -0,0 +1 @@
+{:lint-as {schema.test/deftest clojure.test/deftest}}

.clj-kondo/src/hooks/clojure/core.clj

@@ -1,329 +0,0 @@
-(ns hooks.clojure.core
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [clojure.string :as str]
-   [hooks.common]))
-
-;;; TODO -- seems silly to maintain different blacklists and whitelists here than we use for the deftest `^:parallel`
-;;; checker... those lists live in the Clj Kondo config file
-(def ^:private symbols-allowed-in-fns-not-ending-in-an-exclamation-point
-  '#{;; these toucan methods might actually set global values if it's used outside of a transaction,
-     ;; but since mt/with-temp runs in a transaction, so we'll ignore them in this case.
-     toucan2.core/delete!
-     toucan2.core/update!
-     toucan2.core/insert!
-     toucan2.core/insert-returning-instance!
-     toucan2.core/insert-returning-instances!
-     toucan2.core/insert-returning-pk!
-     toucan2.core/insert-returning-pks!
-     clojure.core.async/<!!
-     clojure.core.async/>!!
-     clojure.core.async/alts!!
-     clojure.core.async/close!
-     clojure.core.async/poll!
-     clojure.core.memoize/memo-clear!
-     clojure.core/conj!
-     clojure.core/persistent!
-     clojure.core/reset!
-     clojure.core/swap!
-     clojure.core/volatile!
-     clojure.core/vreset!
-     clojure.core/vswap!
-     clojure.java.jdbc/execute!
-     methodical.core/add-aux-method-with-unique-key!
-     methodical.core/remove-aux-method-with-unique-key!
-     next.jdbc/execute!
-
-     ;; Definitely thread safe
-     metabase.test.util.dynamic-redefs/patch-vars!
-
-     ;; TODO: most of these symbols shouldn't be here, we should go through them and
-     ;; find the functions/macros that use them and make sure their names end with !
-     ;; best way to do this is try remove each of these and rely on kondo output to find places where it's used
-     clojure.test/grant-collection-perms!
-     clojure.test/grant-collection-perms-fn!
-     clojure.test/grant-perms-fn!
-     clojure.test/purge-old-entries!
-     clojure.test/revoke-collection-perms!
-     clojure.test/save-results!
-     metabase-enterprise.advanced-permissions.models.permissions/update-db-download-permissions!
-     metabase-enterprise.internal-user/install-internal-user!
-     metabase-enterprise.sso.integrations.saml-test/call-with-login-attributes-cleared!
-     metabase.actions/perform-action!
-     metabase.analytics.snowplow-test/fake-track-event-impl!
-     metabase.analytics.snowplow/track-event-impl!
-     metabase.api.public-test/add-card-to-dashboard!
-     metabase.cmd.dump-to-h2/dump-to-h2!
-     metabase.cmd.load-from-h2/load-from-h2!
-     metabase.core/ensure-audit-db-installed!
-     metabase.db.schema-migrations-test.impl/run-migrations-in-range!
-     metabase.db.setup/migrate!
-     metabase.db.setup/setup-db!
-     metabase.db/migrate!
-     metabase.db/setup-db!
-     metabase.driver.mongo-test/create-database-from-row-maps!
-     metabase.driver.postgres-test/create-enums-db!
-     metabase.driver.postgres-test/drop-if-exists-and-create-db!
-     metabase.driver.sql-jdbc.execute/execute-statement!
-     metabase.email-test/reset-inbox!
-     metabase.email/send-email!
-     metabase.models.action/insert!
-     metabase.models.collection.graph-test/clear-graph-revisions!
-     metabase.models.collection.graph-test/do-with-n-temp-users-with-personal-collections!
-     metabase.models.field-values/create-or-update-full-field-values!
-     metabase.models.model-index/add-values!
-     metabase.models.moderation-review/create-review!
-     metabase.models.on-demand-test/add-dashcard-with-parameter-mapping!
-     metabase.models.permissions/grant-application-permissions!
-     metabase.models.permissions/grant-collection-read-permissions!
-     metabase.models.permissions/grant-collection-readwrite-permissions!
-     metabase.models.permissions/grant-full-data-permissions!
-     metabase.models.permissions/grant-native-readwrite-permissions!
-     metabase.models.permissions/grant-permissions!
-     metabase.models.permissions/revoke-application-permissions!
-     metabase.models.permissions/revoke-data-perms!
-     metabase.models.permissions/update-data-perms-graph!
-     metabase.models.permissions/update-group-permissions!
-     metabase.models.persisted-info/ready-database!
-     metabase.models.setting-test/test-user-local-allowed-setting!
-     metabase.models.setting-test/test-user-local-only-setting!
-     metabase.models.setting.cache/restore-cache!
-     metabase.models.setting/set!
-     metabase.models.setting/validate-settings-formatting!
-     metabase.permissions.test-util/with-restored-perms!
-     metabase.pulse.send/send-notifications!
-     metabase.pulse.send/send-pulse!
-     metabase.query-processor.streaming.interface/begin!
-     metabase.query-processor.streaming.interface/finish!
-     metabase.query-processor.streaming.interface/write-row!
-     metabase.sample-data/try-to-extract-sample-database!
-     metabase.setup/create-token!
-     metabase.sync.sync-metadata.fields.sync-metadata/update-field-metadata-if-needed!
-     metabase.sync.sync-metadata/sync-db-metadata!
-     metabase.sync.util-test/sync-database!
-     metabase.sync.util/store-sync-summary!
-     metabase.sync/sync-database!
-     metabase.task.index-values/job-init!
-     metabase.task.persist-refresh/job-init!
-     metabase.task.persist-refresh/refresh-tables!
-     metabase.task.persist-refresh/schedule-persistence-for-database!
-     metabase.task/delete-task!
-     metabase.test.data.bigquery-cloud-sdk/execute!
-     metabase.test.data.impl/copy-db-tables-and-fields!
-     metabase.test.data.impl/get-or-create-database!
-     metabase.test.data.impl/get-or-create-default-dataset!
-     metabase.test.data.impl.get-or-create/set-test-db-permissions!
-     metabase.test.data.interface/create-db!
-     metabase.test.data.interface/destroy-db!
-     metabase.test.data.oracle/create-user!
-     metabase.test.data.oracle/drop-user!
-     metabase.test.data.sql-jdbc.load-data/make-insert!
-     metabase.test.data.users/clear-cached-session-tokens!
-     metabase.test.initialize/do-initialization!
-     metabase.test.initialize/initialize-if-needed!
-     metabase.test.integrations.ldap/start-ldap-server!
-     metabase.test.util.log/ensure-unique-logger!
-     metabase.test.util.log/set-ns-log-level!
-     metabase.test.util/do-with-temp-env-var-value!
-     metabase.test.util/restore-raw-setting!
-     metabase.test.util/upsert-raw-setting!
-     metabase.test/initialize-if-needed!
-     metabase.test/test-helpers-set-global-values!
-     metabase.test/with-temp-env-var-value!
-     metabase.upload-test/set-local-infile!
-     metabase.util.files/create-dir-if-not-exists!
-     metabase.util.ssh-test/start-mock-servers!
-     metabase.util.ssh-test/stop-mock-servers!})
-
-(defn- end-with-exclamation?
-  [s]
-  (str/ends-with? s "!"))
-
-(defn- explicitly-safe? [qualified-symbol]
-  (contains? symbols-allowed-in-fns-not-ending-in-an-exclamation-point qualified-symbol))
-
-(defn- explicitly-unsafe? [config qualified-symbol]
-  (contains? (get-in config [:linters :metabase/validate-deftest :parallel/unsafe]) qualified-symbol))
-
-(defn- unsafe? [config qualified-symbol]
-  (and (or (end-with-exclamation? qualified-symbol)
-           (explicitly-unsafe? config qualified-symbol))
-       (not (explicitly-safe? qualified-symbol))))
-
-(defn- non-thread-safe-form-should-end-with-exclamation*
-  [{[defn-or-defmacro form-name] :children, :as node} config]
-  (when-not (and (:string-value form-name)
-                 (end-with-exclamation? (:string-value form-name)))
-    (letfn [(walk [f form]
-              (f form)
-              (doseq [child (:children form)]
-                (walk f child)))
-            (check-node [form]
-              (when-let [qualified-symbol (hooks.common/node->qualified-symbol form)]
-                (when (unsafe? config qualified-symbol)
-                  (hooks/reg-finding!
-                   (assoc (meta form-name)
-                          :message (format "The name of this %s should end with `!` because it contains calls to non thread safe form `%s`. [:metabase/test-helpers-use-non-thread-safe-functions]"
-                                           (:string-value defn-or-defmacro) qualified-symbol)
-                          :type :metabase/test-helpers-use-non-thread-safe-functions)))))]
-      (walk check-node node))
-    node))
-
-(defn non-thread-safe-form-should-end-with-exclamation
-  "Used to ensure defn and defmacro in test namespace to have name ending with `!` if it's non-thread-safe.
-  A function or a macro can be defined as 'not thread safe' when their funciton name ends with a `!`.
-
-  Only used in tests to identify thread-safe/non-thread-safe test helpers. See #37126"
-  [{:keys [node cljc lang config]}]
-  (when (or (not cljc)
-            (= lang :clj))
-    (non-thread-safe-form-should-end-with-exclamation* node config))
-  {:node node})
-
-(comment
-  (require '[clj-kondo.core :as clj-kondo])
-  (def form (str '(defmacro a
-                    [x]
-                    `(fun-call x))))
-
-  (def form "(defmacro a
-           [x]
-           `(some! ~x))")
-
-  (def form "(defun f
-           [x]
-           (let [g! (fn [] 1)]
-           (g!)))")
-
-  (str (hooks/parse-string form))
-  (hooks/sexpr (hooks/parse-string form))
-
-  (binding [hooks/*reload* true]
-    (-> form
-        (with-in-str (clj-kondo/run! {:lint ["-"]}))
-        :findings))
-
-  (do (non-thread-safe-form-should-end-with-exclamation* (hooks/parse-string form)) nil))
-
-(defn- ns-form-node->require-node [ns-form-node]
-  (some (fn [node]
-          (when (and (hooks/list-node? node)
-                     (let [first-child (first (:children node))]
-                       (and (hooks/keyword-node? first-child)
-                            (= (hooks/sexpr first-child) :require))))
-            node))
-        (:children ns-form-node)))
-
-(defn- lint-require-shapes [ns-form-node]
-  (doseq [node (-> ns-form-node
-                   ns-form-node->require-node
-                   :children
-                   rest)]
-    (cond
-      (not (hooks/vector-node? node))
-      (hooks/reg-finding! (assoc (meta node)
-                                 :message "All :required namespaces should be wrapped in vectors [:metabase/require-shape-checker]"
-                                 :type    :metabase/require-shape-checker))
-
-      (hooks/vector-node? (second (:children node)))
-      (hooks/reg-finding! (assoc (meta node)
-                                 :message "Don't use prefix forms inside :require [:metabase/require-shape-checker]"
-                                 :type    :metabase/require-shape-checker)))))
-
-(defn- require-node->namespace-symb-nodes [require-node]
-  (let [[_ns & args] (:children require-node)]
-    (into []
-          ;; prefixed namespace forms are NOT SUPPORTED!!!!!!!!1
-          (keep (fn [node]
-                  (cond
-                    (hooks/vector-node? node)
-                    ;; propagate the metadata attached to this vector in case there's a `:clj-kondo/ignore` form.
-                    (let [symbol-node (first (:children node))]
-                      (hooks.common/merge-ignored-linters symbol-node require-node node))
-
-                    ;; this should also be dead code since we require requires to be vectors
-                    (hooks/token-node? node)
-                    (hooks.common/merge-ignored-linters node require-node)
-
-                    :else
-                    (printf "Don't know how to figure out what namespace is being required in %s\n" (pr-str node)))))
-          args)))
-
-(defn- ns-form-node->ns-symb [ns-form-node]
-  (some-> (some (fn [node]
-                  (when (and (hooks/token-node? node)
-                             (not= (hooks/sexpr node) 'ns))
-                    node))
-                (:children ns-form-node))
-          hooks/sexpr))
-
-(defn- module
-  "E.g.
-
-    (module 'metabase.qp.middleware.wow) => 'metabase.qp"
-  [ns-symb]
-  (some-> (re-find #"^metabase\.[^.]+" (str ns-symb)) symbol))
-
-(defn- ignored-namespace? [ns-symb config]
-  (some
-   (fn [pattern-str]
-     (re-find (re-pattern pattern-str) (str ns-symb)))
-   (:ignored-namespace-patterns config)))
-
-(defn- module-api-namespaces
-  "Set API namespaces for a given module. `:any` means you can use anything, there are no API namespaces for this
-  module (yet). If unspecified, the default is just the namespace with the same name as the module e.g.
-  `metabase.db`."
-  [module config]
-  (let [module-config (get-in config [:api-namespaces module])]
-    (cond
-      (= module-config :any)
-      nil
-
-      (set? module-config)
-      module-config
-
-      :else
-      #{module})))
-
-(defn- lint-modules [ns-form-node config]
-  (let [ns-symb (ns-form-node->ns-symb ns-form-node)]
-    (when-not (ignored-namespace? ns-symb config)
-      (when-let [current-module (module ns-symb)]
-        (let [allowed-modules               (get-in config [:allowed-modules current-module])
-              required-namespace-symb-nodes (-> ns-form-node
-                                                ns-form-node->require-node
-                                                require-node->namespace-symb-nodes)]
-          (doseq [node  required-namespace-symb-nodes
-                  :when (not (contains? (hooks.common/ignored-linters node) :metabase/ns-module-checker))
-                  :let  [required-namespace (hooks/sexpr node)
-                         required-module    (module required-namespace)]
-                  ;; ignore stuff not in a module i.e. non-Metabase stuff.
-                  :when required-module
-                  :let  [in-current-module? (= required-module current-module)]
-                  :when (not in-current-module?)
-                  :let  [allowed-module?           (or (= allowed-modules :any)
-                                                       (contains? (set allowed-modules) required-module))
-                         module-api-namespaces     (module-api-namespaces required-module config)
-                         allowed-module-namespace? (or (empty? module-api-namespaces)
-                                                       (contains? module-api-namespaces required-namespace))]]
-            (when-let [error (cond
-                               (not allowed-module?)
-                               (format "Module %s should not be used in the %s module. [:metabase/ns-module-checker :allowed-modules %s]"
-                                       required-module
-                                       current-module
-                                       current-module)
-
-                               (not allowed-module-namespace?)
-                               (format "Namespace %s is not an allowed external API namespace for the %s module. [:metabase/ns-module-checker :api-namespaces %s]"
-                                       required-namespace
-                                       required-module
-                                       required-module))]
-              (hooks/reg-finding! (assoc (meta node)
-                                         :message error
-                                         :type    :metabase/ns-module-checker)))))))))
-
-(defn lint-ns [x]
-  (lint-require-shapes (:node x))
-  (lint-modules (:node x) (get-in x [:config :linters :metabase/ns-module-checker]))
-  x)

.clj-kondo/src/hooks/clojure/test.clj

@@ -1,156 +0,0 @@
-(ns hooks.clojure.test
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [clojure.string :as str]
-   [hooks.common]))
-
-(defn- warn-about-disallowed-parallel-forms [form config]
-  (letfn [(error! [form message]
-            (hooks/reg-finding! (assoc (meta form)
-                                       :message message
-                                       :type :metabase/validate-deftest)))
-          (f [form]
-            (when-let [qualified-symbol (hooks.common/node->qualified-symbol form)]
-              (cond
-                (contains? (:parallel/unsafe config) qualified-symbol)
-                (error! form (format "%s is not allowed inside a ^:parallel test or test fixture [:metabase/validate-deftest]" qualified-symbol))
-
-                (and (not (contains? (:parallel/safe config) qualified-symbol))
-                     (str/ends-with? (name qualified-symbol) "!"))
-                (error! form (format "destructive functions like %s are not allowed inside a ^:parallel test or test fixture. If this should be allowed, add it to the whitelist in the Kondo config file [:metabase/validate-deftest]"
-                                     qualified-symbol)))))
-          (walk [form]
-            (f form)
-            (doseq [child (:children form)]
-              (walk child)))]
-    (walk form)))
-
-(defn- deftest-check-parallel
-  "1. Check if test is marked ^:parallel / ^:synchronized correctly
-   2. Make sure disallowed forms are not used in ^:parallel tests"
-  [{[_ test-name & body] :children, :as _node} config]
-  (let [test-metadata     (:meta test-name)
-        metadata-sexprs   (map hooks/sexpr test-metadata)
-        combined-metadata (transduce
-                           (map (fn [x]
-                                  (if (map? x)
-                                    x
-                                    {x true})))
-                           (completing merge)
-                           {}
-                           metadata-sexprs)
-        parallel?     (:parallel combined-metadata)
-        synchronized? (:synchronized combined-metadata)]
-    (when (and parallel? synchronized?)
-      (hooks/reg-finding! (assoc (meta test-name)
-                                 :message "Test should not be marked both ^:parallel and ^:synchronized"
-                                 :type :metabase/validate-deftest)))
-    ;; only when the custom `:metabase/deftest-not-marked-parallel-or-synchronized` is enabled: complain if tests are
-    ;; not explicitly marked `^:parallel` or `^:synchronized`. This is mostly to encourage people to mark everything
-    ;; `^:parallel` in places like `metabase.lib` tests unless there is a really good reason not to.
-    (when-not (or parallel? synchronized?)
-      (hooks/reg-finding!
-       (assoc (meta test-name)
-              :message "Test should be marked either ^:parallel or ^:synchronized"
-              :type :metabase/deftest-not-marked-parallel-or-synchronized)))
-    (when parallel?
-      (doseq [form body]
-        (warn-about-disallowed-parallel-forms form config)))))
-
-(defn- deftest-check-not-horrifically-long
-  [node {:keys [max-length], :as _config}]
-  (let [{:keys [row end-row]} (meta node)]
-    (when (and row end-row)
-      (let [num-lines (- end-row row)]
-        (when (and max-length
-                   (>= num-lines max-length))
-          (hooks/reg-finding! (assoc (meta node)
-                                     :message (str (format "This test is horrifically long, it's %d lines! 😱 " num-lines)
-                                                   "Do you really want to try to debug it if it fails? 💀 "
-                                                   "Split it up into smaller tests! 🥰")
-                                     :type :metabase/i-like-making-cams-eyes-bleed-with-horrifically-long-tests)))))))
-
-(defn- ignore? [node error-type]
-  (contains? (hooks.common/ignored-linters node) error-type))
-
-(defn deftest-check-no-driver-keywords [node {:keys [drivers], :as _config}]
-  ;; fail fast after we see the first error, where we see one hardcoded driver name there are likely several more and we
-  ;; don't need multiple warnings for a single test.
-  (letfn [(f [node]
-            (when (and (hooks/keyword-node? node)
-                       (set? drivers)
-                       (contains? drivers (hooks/sexpr node)))
-              (hooks/reg-finding! (assoc (meta node)
-                                         :message (format "Do not hardcode driver name %s in driver tests! [:metabase/disallow-hardcoded-driver-names-in-tests]"
-                                                          (hooks/sexpr node))
-                                         :type    :metabase/disallow-hardcoded-driver-names-in-tests))
-              ::error))
-          (walk [node]
-            (cond
-              (ignore? node :metabase/disallow-hardcoded-driver-names-in-tests)
-              nil
-
-              (= (f node) ::error)
-              ::error
-
-              :else
-              (reduce
-               (fn [_acc child]
-                 (when (= (walk child) ::error)
-                   (reduced ::error)))
-               nil
-               (:children node))))]
-    (walk node)))
-
-(defn deftest [{:keys [node cljc lang config]}]
-  ;; run [[deftest-check-parallel]] only once... if this is a `.cljc` file only run it for the `:clj` analysis, no point
-  ;; in running it twice.
-  (when (or (not cljc)
-            (= lang :clj))
-    (deftest-check-parallel node (get-in config [:linters :metabase/validate-deftest])))
-  (deftest-check-not-horrifically-long node (get-in config [:linters :metabase/i-like-making-cams-eyes-bleed-with-horrifically-long-tests]))
-  (deftest-check-no-driver-keywords node (get-in config [:linters :metabase/disallow-hardcoded-driver-names-in-tests]))
-  {:node node})
-
-;;; this is a hacky way to determine whether these namespaces are required in the `ns` form or not... basically `:ns`
-;;; will come back as `nil` if they are not.
-(defn- approximately-equal-ns-required? []
-  (= (:ns (hooks/resolve {:name 'metabase.test-runner.assert-exprs.approximately-equal/=?-report}))
-     'metabase.test-runner.assert-exprs.approximately-equal))
-
-(defn- malli-equals-ns-required? []
-  (= (:ns (hooks/resolve {:name 'metabase.test-runner.assert-exprs.malli-equals/malli=-report}))
-     'metabase.test-runner.assert-exprs.malli-equals))
-
-(defn- warn-about-missing-test-expr-requires-in-cljs [{:keys [children], :as _is-node}]
-  (let [[_is assertion-node] children]
-    (when (hooks/list-node? assertion-node)
-      (let [[assertion-symb-node] (:children assertion-node)]
-        (when (hooks/token-node? assertion-symb-node)
-          (let [assertion-symb-token (hooks/sexpr assertion-symb-node)
-                warn!                (fn [ns-to-require]
-                                       (hooks/reg-finding!
-                                        (assoc (meta assertion-symb-node)
-                                               :message (format "You must require %s to use %s in ClojureScript"
-                                                                ns-to-require
-                                                                assertion-symb-token)
-                                               :type :metabase/missing-test-expr-requires-in-cljs)))]
-            (condp = assertion-symb-token
-              '=?
-              (when-not (approximately-equal-ns-required?)
-                (warn! 'metabase.test-runner.assert-exprs.approximately-equal))
-
-              'malli=
-              (when-not (malli-equals-ns-required?)
-                (warn! 'metabase.test-runner.assert-exprs.malli-equals))
-
-              nil)))))))
-
-(defn is [{:keys [node lang]}]
-  (when (= lang :cljs)
-    (warn-about-missing-test-expr-requires-in-cljs node))
-  {:node node})
-
-(defn use-fixtures [{:keys [node config]}]
-  (warn-about-disallowed-parallel-forms node config)
-  {:node node})

.clj-kondo/src/hooks/common.clj

@@ -1,537 +0,0 @@
-(ns hooks.common
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [clojure.pprint]
-   [clojure.set :as set]))
-
-(defn with-macro-meta
-  "When introducing internal nodes (let, defn, etc) it is important to provide a meta of an existing token
-   as the current version of kondo will use the whole form by default."
-  [new-node hook-node]
-  (with-meta new-node (meta (first (:children hook-node)))))
-
-;;; Kondo stores information about ignored linters as rewrite-clj forms matching how they are specified in the code, so
-;;; either
-;;;
-;;;    <vector-node [<token-node :discouraged-namespace>]>
-;;;
-;;; or
-;;;
-;;;    <token-node :discouraged-namespace>
-;;;
-;;; these are stored in
-;;;
-;;;     (-> node meta :clj-kondo/ignore :linters).
-;;;
-;;; These are not a convenient shape(s) to work with, so the next few functions abstract that shape out and work with a
-;;; set of keywords like
-;;;
-;;;    #{:discouraged-namespace}
-;;;
-;;; instead.
-
-(defn- unwrap-ignored-linters [linters]
-  (cond
-    (or (hooks/vector-node? linters)
-        (hooks/list-node? linters))
-    (into #{}
-          (map hooks/sexpr)
-          (:children linters))
-
-    (hooks/keyword-node? linters)
-    #{(hooks/sexpr linters)}
-
-    (and (set? linters)
-         (every? keyword? linters))
-    linters
-
-    (and (sequential? linters)
-         (every? keyword? linters))
-    (into #{} linters)
-
-    (keyword? linters)
-    #{linters}))
-
-(defn- wrap-ignored-linters [linters]
-  (hooks/vector-node (mapv hooks/keyword-node linters)))
-
-(defn ignored-linters
-  "Return a set of keywords all ignored linters associated with a node by looking at its metadata."
-  [node]
-  (or (some-> node meta :clj-kondo/ignore :linters unwrap-ignored-linters)
-      ;; deal with the old pre-2024.09 shape mentioned in https://github.com/clj-kondo/clj-kondo/issues/2414
-      (some-> node :meta first hooks/sexpr :clj-kondo/ignore unwrap-ignored-linters)))
-
-(defn update-ignored-linters
-  "Update the `:clj-kondo/ignore` linters in `node`'s metadata. `linters` should be a set of keywords."
-  [node f & args]
-  (letfn [(apply-f [linters]
-            (apply f linters args))
-          (update-linters [linters]
-            (-> (or (unwrap-ignored-linters linters)
-                    #{})
-                apply-f
-                wrap-ignored-linters))]
-    (vary-meta node update-in [:clj-kondo/ignore :linters] update-linters)))
-
-(defn merge-ignored-linters
-  "Merge the ignored linters from `source-nodes` into `node`. You can use this to propagate
-  ignored linters from parent nodes to child nodes."
-  [node & source-nodes]
-  (if-let [linters (not-empty (transduce (map ignored-linters) set/union #{} source-nodes))]
-    (update-ignored-linters node set/union linters)
-    node))
-
-;;; This stuff is to help debug hooks. Trace a function and it will pretty-print the before & after sexprs.
-;;;
-;;;    (hooks.common/trace #'calculate-bird-scarcity)
-
-#_{:clj-kondo/ignore [:discouraged-var]}
-(defn- trace* [f]
-  {:pre [(fn? f)]}
-  (fn traced-fn [node]
-    (println \newline)
-    (clojure.pprint/pprint (hooks/sexpr (:node node)))
-    (let [node* (f node)]
-      (println '=>)
-      (clojure.pprint/pprint (hooks/sexpr (:node node*)))
-      node*)))
-
-;;; this doesn't seem to work with SCI. Use [[defn-traced]] instead.
-
-;; (defn trace [varr]
-;;   {:pre [(var? varr)]}
-;;   (when-not (::traced? (meta varr))
-;;     (alter-var-root varr trace*)
-;;     (alter-meta! varr assoc ::traced? true)
-;;     (println "Traced" varr)))
-
-(defmacro defn-traced
-  "Replace a hook [[defn]] with this to trace the before and after sexprs."
-  [fn-name & fn-tail]
-  `(do
-     (defn fn# ~@fn-tail)
-     (def ~fn-name (trace* fn#))))
-
-;;;; Common hook definitions
-
-(defn do*
-  "This is the same idea as [[clojure.core/do]] but doesn't cause Kondo to complain about redundant dos or unused
-  values."
-  [{{[_ & args] :children, :as node} :node}]
-  (let [node* (-> (hooks/list-node
-                   (list*
-                    (update-ignored-linters (hooks/token-node 'do) conj :redundant-do)
-                    (for [arg args]
-                      (update-ignored-linters arg conj :unused-value))))
-                  (with-meta (meta node)))]
-    {:node node*}))
-
-(defn with-one-binding
-  "Helper for macros that have a shape like
-
-    (my-macro [x]
-      ...)
-
-    =>
-
-    (let [x nil]
-      ...)
-
-  Binding is optional and `_` will be substituted if not supplied."
-  [{{[_ {[x] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or x (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-two-bindings
-  "Helper for macros that have a shape like
-
-    (my-macro [x y]
-      ...)
-
-    =>
-
-    (let [x nil, y nil]
-      ...)
-
-  All bindings are optional and `_` will be substituted if not supplied."
-  [{{[_ {[x y] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or x (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or y (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-three-bindings
-  "Helper for macros that have a shape like
-
-    (my-macro [x y z]
-      ...)
-
-    =>
-
-    (let [x nil, y nil, z nil]
-      ...)
-
-  All bindings are optional and `_` will be substituted if not supplied."
-  [{{[_ {[x y z] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or x (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or y (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or z (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-four-bindings
-  "Helper for macros that have a shape like
-
-    (my-macro [a b c d]
-      ...)
-
-    =>
-
-    (let [a nil, b nil, c nil, d nil]
-      ...)
-
-  All bindings are optional and `_` will be substituted if not supplied."
-  [{{[_ {[a b c d] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or a (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or b (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or c (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or d (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-five-bindings
-  "Helper for macros that have a shape like
-
-    (my-macro [a b c d e]
-      ...)
-
-    =>
-
-    (let [a nil, b nil, c nil, d nil, e nil]
-      ...)
-
-  All bindings are optional and `_` will be substituted if not supplied."
-  [{{[_ {[a b c d e] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or a (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or b (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or c (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or d (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or e (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-six-bindings
-  "Helper for macros that have a shape like
-
-    (my-macro [a b c d e f]
-      ...)
-
-    =>
-
-    (let [a nil, b nil, c nil, d nil, e nil, f nil]
-      ...)
-
-  All bindings are optional and `_` will be substituted if not supplied."
-  [{{[_ {[a b c d e f] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or a (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or b (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or c (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or d (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or e (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or f (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-seven-bindings
-  "Helper for macros that have a shape like
-
-    (my-macro [a b c d e f g]
-      ...)
-
-    =>
-
-    (let [a nil, b nil, c nil, d nil, e nil, f nil, g nil]
-      ...)
-
-  All bindings are optional and `_` will be substituted if not supplied."
-  [{{[_ {[a b c d e f g] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or a (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or b (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or c (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or d (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or e (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or f (hooks/token-node '_)) (hooks/token-node 'nil)
-                  (or g (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-one-top-level-binding
-  "Helper for macros that have a shape like
-
-    (my-macro x
-      ...)
-
-    =>
-
-    (let [x nil]
-      ...)"
-  [{{[_ x & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [x (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn with-two-top-level-bindings
-  "Helper for macros that have a shape like
-
-    (my-macro x y
-      ...)
-
-    =>
-
-    (let [x nil, y nil]
-      ...)"
-  [{{[_ x y & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [x (hooks/token-node 'nil)
-                  y (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn let-one-with-optional-value
-  "This is exactly like [[clojure.core/let]] but the right-hand side of the binding, `value`, is optional, and only one
-  binding can be established.
-
-    (some-macro [x] ...)
-    =>
-    (let [x nil] ...)
-
-    (some-macro [x 100] ...)
-    =>
-    (let [x 100] ...)"
-  [{{[_ {[binding value] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [binding (or value (hooks/token-node 'nil))])
-                body))]
-    {:node node*}))
-
-(defn- let-second-inner [body bindings]
-  (let [binding-infos (for [[model {[binding value] :children}] (partition 2 bindings)]
-                        {:model   model
-                         :binding binding
-                         :value   (or value
-                                      (hooks/token-node 'nil))})]
-    (-> (hooks/vector-node
-         [(hooks/vector-node (map :model binding-infos))
-          (-> (hooks/list-node (list* (hooks/token-node `let)
-                                      (hooks/vector-node (mapcat (juxt :binding :value) binding-infos))
-                                      body))
-              (with-meta (meta body)))])
-        (with-meta (meta body)))))
-
-(defn let-second
-  "Helper for macros that have a shape like
-
-    (my-macro x [y]
-    ...)
-
-    where the let is for second arg.
-
-    =>
-
-    (let [y nil]
-    ...)"
-  [{:keys [node]}]
-  (let [[_ first-arg-ref binding+opts & body] (:children node)]
-    {:node (let-second-inner body [first-arg-ref binding+opts])}))
-
-(defn let-with-optional-value-for-last-binding
-  "This is exactly like [[clojure.core/let]] but the right-hand side of the *last* binding, `value`, is optional.
-
-    (some-macro [x] ...)
-    =>
-    (let [x nil] ...)
-
-    (some-macro [x 100] ...)
-    =>
-    (let [x 100] ...)"
-  [{{[_ {bindings :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 (into []
-                       (comp (partition-all 2)
-                             (mapcat (fn [[binding value]]
-                                       [binding (or value (hooks/token-node 'nil))])))
-                       bindings))
-                body))]
-    {:node node*}))
-
-(defn with-ignored-first-arg
-  "For macros like
-
-    (discard-setting-changes [setting-1 setting-2]
-      ...)
-
-    =>
-
-    (do ...)
-
-  where the first arg ought to be ignored for linting purposes."
-  [{{[_ _x & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'do)
-                body))]
-    {:node node*}))
-
-(defn with-used-first-arg
-  "For macros like
-
-    (with-drivers (filter pred? some-drivers)
-      ...)
-
-    =>
-
-    (let [_1234 (filter pred? some-drivers)]
-      ...)
-
-  where the first arg should be linted and appear to be used."
-  [{{[_ arg & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node [(hooks/token-node (gensym "_"))
-                                    arg])
-                body))]
-    {:node node*}))
-
-(defn with-used-first-two-args
-  "For macros like
-
-    (with-limit-and-offset limit offset
-      ...)
-
-    =>
-
-    (let [_123 limit
-         [_456 offset]
-      ...)
-
-  where the first arg should be linted and appear to be used."
-  [{{[_ x y & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node [(hooks/token-node (gensym "_")) x
-                                    (hooks/token-node (gensym "_")) y])
-                body))]
-    {:node node*}))
-
-(defn with-vec-first-binding
-  "For macros like
-
-    (with-temp-file [binding \"temp.txt\" \"content\"]
-      (slurp binding))
-
-    =>
-    (let [binding nil]
-      (slurp binding))
-
-    where the first arg is a vector of bindings."
-  [{{[_ {[x & _args] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [(or x (hooks/token-node '_)) (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))
-
-(defn node->qualified-symbol
-  "If the node is a symbol, return it as a qualified symbol if it's not already. Otherwise return nil."
-  [node]
-  (try
-    (when (hooks/token-node? node)
-      (let [sexpr (hooks/sexpr node)]
-        (when (symbol? sexpr)
-          (let [resolved (hooks/resolve {:name sexpr})]
-            (cond
-              (and resolved (:ns resolved))
-              (symbol (name (:ns resolved)) (name (:name resolved)))
-
-             ;; if it wasn't resolved but is still qualified it's probably using the full namespace name rather than an
-             ;; alias.
-              (qualified-symbol? sexpr)
-              sexpr)))))
-    ;; some symbols like `*count/Integer` aren't resolvable.
-    (catch Exception _
-      nil)))
-
-(defn format-string-specifier-count
-  "Number of things like `%s` in a format string, not counting newlines (`%n`) or escaped percent signs (`%%`). For
-  checking the number of args to something that takes a format string."
-  [format-string]
-  (count (re-seq #"(?<!%)%(?![%n])" format-string)))
-
-(comment
-  ;; should be 1
-  (format-string-specifier-count "%s %%")
-
-  ;; should be 2
-  (format-string-specifier-count "%s %%%n%s")
-
-  ;; should be 0
-  (format-string-specifier-count "%n%%%%")
-
-  ;; should be 1
-  (format-string-specifier-count "%-02d"))
-
-(defn add-lsp-ignore-unused-public-var-metadata
-  "Add
-
-    ^{:clj-kondo/ignore [:clojure-lsp/unused-public-var]}
-
-  metadata to a node to suppress LSP warnings."
-  [node]
-  (update-ignored-linters node conj :clojure-lsp/unused-public-var))

.clj-kondo/src/hooks/metabase/api/automagic_dashboards_test.clj

@@ -1,28 +0,0 @@
-(ns hooks.metabase.api.automagic-dashboards-test
-  (:require [clj-kondo.hooks-api :as hooks]))
-
-(comment
-
-  (def input (hooks/parse-string
-              "(with-indexed-model! [{:keys [model model-index model-index-value]}
-                                     {:query :some-query}]
-                  :foo :bar :body)"))
-
-  (println (hooks/sexpr input))
-
-  (let [f (load-file ".clj-kondo/hooks/metabase/api/automagic_dashboards_test.clj")]
-    (f {:node input})))
-
-(defn with-indexed-model!
-  [{node :node}]
-  (let [[_macro-call binding-and-query-info & body] (:children node)
-        [binding query-info] (:children binding-and-query-info)
-        node* (hooks/list-node
-               [(hooks/token-node 'do-with-indexed-model!)
-                query-info
-                (hooks/list-node
-                 (list* (hooks/token-node 'fn)
-                        (hooks/vector-node [binding])
-                        body))])]
-    #_(println (hooks/sexpr node*))
-    {:node node*}))

.clj-kondo/src/hooks/metabase/api/common.clj

@@ -1,32 +0,0 @@
-(ns hooks.metabase.api.common
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [clojure.string :as str]
-   [hooks.common]))
-
-(defn route-fn-name
-  "route fn hook"
-  [method route]
-  (let [route (if (vector? route) (first route) route)]
-    (-> (str (name method) route)
-        (str/replace #"/" "_")
-        symbol)))
-
-(defn defendpoint
-  [arg]
-  (letfn [(update-defendpoint [node]
-            (let [[_defendpoint method route & body] (:children node)]
-              (-> (api/list-node
-                   (list
-                    (api/token-node 'do)
-                    (-> (api/token-node (symbol "compojure.core" (str (api/sexpr method))))
-                        (with-meta (meta method)))
-                    (api/list-node
-                     (list*
-                      (api/token-node 'clojure.core/defn)
-                      (-> (api/token-node (route-fn-name (api/sexpr method) (api/sexpr route)))
-                          (with-meta (meta route)))
-                      body))))
-                  (with-meta (meta node))
-                  hooks.common/add-lsp-ignore-unused-public-var-metadata)))]
-    (update arg :node update-defendpoint)))

.clj-kondo/src/hooks/metabase/channel/template/handlebars_helper.clj

@@ -1,25 +0,0 @@
-(ns hooks.metabase.channel.template.handlebars-helper
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [hooks.common]))
-
-(defn defhelper
-  "defhelper hook"
-  [{:keys [node]}]
-  (let [[_ helper-name description argvec & body] (:children node)
-        helper-fn-name (symbol (str (hooks/sexpr helper-name) "*"))]
-    {:node (-> (hooks/list-node
-                (list (hooks/token-node 'do)
-                      (hooks/list-node
-                       (list (hooks/token-node 'defn)
-                             (hooks/token-node helper-fn-name)
-                             description
-                             argvec
-                             (hooks/list-node body)))
-                      (hooks/list-node
-                       (list (hooks/token-node 'defn)
-                             helper-name
-                             description
-                             argvec
-                             (hooks/list-node body)))))
-               (with-meta (meta node)))}))

.clj-kondo/src/hooks/metabase/db/schema_migrations_test/impl.clj

@@ -1,14 +0,0 @@
-(ns hooks.metabase.db.schema-migrations-test.impl
-  (:require [clj-kondo.hooks-api :as hooks]))
-
-(defn test-migrations
-  [{{[_ migration-range {[binding] :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node `let)
-                (hooks/vector-node
-                 [binding (hooks/list-node (list (hooks/token-node `fn)
-                                                 (hooks/vector-node [(hooks/token-node '&) (hooks/token-node '_args)])))])
-                migration-range
-                body))]
-    {:node node*}))

.clj-kondo/src/hooks/metabase/driver.clj

@@ -1,18 +0,0 @@
-(ns hooks.metabase.driver
-  (:require
-   [clj-kondo.hooks-api :as api]))
-
-(defn register!
-  "Register the driver keyword so LSP can jump to it."
-  [x]
-  (letfn [(update-driver-keyword [k]
-            (api/reg-keyword! k 'metabase.driver/register!))
-          (update-children [[_register! k :as children]]
-            (if (api/keyword-node? k)
-              (update (vec children) 1 update-driver-keyword)
-              children))
-          (update-node [node]
-            (if (api/list-node? node)
-              (update node :children update-children)
-              node))]
-    (update x :node update-node)))

.clj-kondo/src/hooks/metabase/legacy_mbql/schemas/macros.clj

@@ -1,69 +0,0 @@
-(ns hooks.metabase.legacy-mbql.schemas.macros
-  (:require
-   [clj-kondo.hooks-api :as hooks]))
-
-(defn- unwrap-defclause-clause-name
-  "The `clause-name-form` can be either a plain symbol, or a vector like `[var-name mbql-clause-name]`. For the vector
-  form, we are only interested in the `var-name`. For a plain symbol, the two names are the same. Return a token node."
-  [clause-name-form]
-  (-> (if (hooks/vector-node? clause-name-form)
-        (first (:children clause-name-form))
-        clause-name-form)
-      (with-meta (meta clause-name-form))))
-
-(defn- collect-defclause-body-schemas
-  "Collect the argument schemas in the body of a `defclause` form into a vector node.
-
-  The body is a sequence of <argument-name> <argument-schema> pairs. We can ignore the argument names.
-
-  <argument-schema> can optionally be wrapped be `(optional ...)` or `(rest ...)`... we can ignore these."
-  [arg-specs]
-  (hooks/vector-node
-   (for [[_arg-name arg-schema] (partition-all 2 arg-specs)
-         :let                   [arg-schema (if (and (hooks/list-node? arg-schema)
-                                                     ('#{optional rest} (hooks/sexpr (first (:children arg-schema)))))
-                                              (-> (second (:children arg-schema))
-                                                  (with-meta (meta arg-schema)))
-                                              arg-schema)]]
-     arg-schema)))
-
-(defn defclause
-  "e.g.
-
-    (defclause [ag:var var] field-or-expression FieldOrExpressionDef)
-    =>
-    (def ag:var [FieldOrExpressionDef])"
-  [{:keys [node]}]
-  (let [[_defclause clause-name-form & arg-specs] (:children node)]
-    {:node (-> (hooks/list-node
-                (list
-                 (hooks/token-node 'def)
-                 (unwrap-defclause-clause-name clause-name-form)
-                 (hooks/string-node "Docstring.")
-                 (collect-defclause-body-schemas arg-specs)))
-               (with-meta (meta node)))}))
-
-(comment
-  (defn- defclause* [form]
-    (hooks/sexpr
-     (:node
-      (defclause
-        {:node
-         (hooks/parse-string
-          (with-out-str
-            (clojure.pprint/pprint
-             form)))}))))
-
-  (defn- x []
-    (defclause* '(defclause [ag:var var]
-                   field-or-expression FieldOrExpressionDef)))
-  ;; =>
-  (def ag:var "Docstring." [FieldOrExpressionDef])
-
-  (defn- y []
-    (defclause* '(defclause var
-                   x (some-list-schema)
-                   y (optional FieldOrExpressionDef)
-                   z (rest (some-other-schema)))))
-  ;; =>
-  (def var "Docstring." [(some-list-schema) FieldOrExpressionDef (some-other-schema)]))

.clj-kondo/src/hooks/metabase/lib/schema/mbql_clause.clj

@@ -1,21 +0,0 @@
-(ns hooks.metabase.lib.schema.mbql-clause
-  (:require
-   [clj-kondo.hooks-api :as api]))
-
-(defn define-mbql-clause
-  "Register the schema keyword so LSP can jump to it."
-  [x]
-  (letfn [(update-def-keyword [k]
-            (-> (api/keyword-node (keyword "mbql.clause" (name (api/sexpr k))))
-                (with-meta (meta k))
-                (api/reg-keyword! 'metabase.lib.schema.mbql-clause/define-mbql-clause)))
-          (update-children [[_def k :as children]]
-            (if (api/keyword-node? k)
-              (update (vec children) 1 update-def-keyword)
-              children))
-          (update-node [node]
-            (if (api/list-node? node)
-              (-> (api/list-node (update-children (:children node)))
-                  (with-meta (meta node)))
-              node))]
-    (update x :node update-node)))

.clj-kondo/src/hooks/metabase/lib/test_util/macros.clj

@@ -1,12 +0,0 @@
-(ns hooks.metabase.lib.test-util.macros
-  (:require [clj-kondo.hooks-api :as hooks]))
-
-(defn with-testing-against-standard-queries [{{[_ & args] :children} :node}]
-  (let [[query-sym & body] args
-        node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 [query-sym (hooks/token-node 'nil)])
-                body))]
-    {:node node*}))

.clj-kondo/src/hooks/metabase/models/interface.clj

@@ -1,21 +0,0 @@
-(ns hooks.metabase.models.interface
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [hooks.common]))
-
-(defn define-hydration-method
-  "This is used for both [[metabase.models.interface/define-simple-hydration-method]] and
-  for [[metabase.models.interface/define-batched-hydration-method]]."
-  [{{[_define-simple-hydration-method fn-name hydration-key & fn-tail] :children, :as node} :node}]
-  (let [node (-> (hooks/list-node
-                  (list
-                   (hooks/token-node 'do)
-                   hydration-key
-                   (hooks/list-node
-                    (list*
-                     (hooks/token-node 'defn)
-                     fn-name
-                     fn-tail))))
-                 (with-meta (meta node))
-                 hooks.common/add-lsp-ignore-unused-public-var-metadata)]
-    {:node node}))

.clj-kondo/src/hooks/metabase/models/setting.clj

@@ -1,267 +0,0 @@
-(ns hooks.metabase.models.setting
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [hooks.common :as common]))
-
-(def ^:private ignored-implicit-export?
-  '#{active-users-count
-     admin-email
-     analytics-uuid
-     anon-tracking-enabled
-     api-key
-     attachment-table-row-limit
-     audit-max-retention-days
-     bcc-enabled?
-     breakout-bin-width
-     check-for-updates
-     cloud-gateway-ips
-     config-from-file-sync-databases
-     custom-homepage
-     custom-homepage-dashboard
-     database-enable-actions
-     deprecation-notice-version
-     dismissed-custom-dashboard-toast
-     dismissed-onboarding-sidebar-link
-     email-configured?
-     email-from-address
-     email-from-name
-     email-reply-to
-     email-smtp-host
-     email-smtp-password
-     email-smtp-port
-     email-smtp-security
-     email-smtp-username
-     embedding-app-origin
-     embedding-secret-key
-     enable-password-login
-     enable-public-sharing
-     enable-query-caching
-     engines
-     enum-cardinality-threshold
-     follow-up-email-sent
-     google-auth-auto-create-accounts-domain
-     google-auth-client-id
-     google-auth-configured
-     google-auth-enabled
-     has-sample-database?
-     has-user-setup
-     help-link
-     help-link-custom-destination
-     instance-creation
-     is-hosted?
-     is-metabot-enabled
-     jdbc-data-warehouse-max-connection-pool-size
-     jdbc-data-warehouse-unreturned-connection-timeout-seconds
-     jwt-attribute-email
-     jwt-attribute-firstname
-     jwt-attribute-groups
-     jwt-attribute-lastname
-     jwt-configured
-     jwt-enabled
-     jwt-group-mappings
-     jwt-group-sync
-     jwt-identity-provider-uri
-     jwt-user-provisioning-enabled?
-     jwt-shared-secret
-     last-acknowledged-version
-     last-used-native-database-id
-     ldap-attribute-email
-     ldap-attribute-firstname
-     ldap-attribute-lastname
-     ldap-bind-dn
-     ldap-configured?
-     ldap-enabled
-     ldap-group-base
-     ldap-group-mappings
-     ldap-group-membership-filter
-     ldap-group-sync
-     ldap-host
-     ldap-password
-     ldap-port
-     ldap-user-provisioning-enabled?
-     ldap-security
-     ldap-sync-user-attributes
-     ldap-sync-user-attributes-blacklist
-     ldap-user-base
-     ldap-user-filter
-     load-analytics-content
-     map-tile-server-url
-     metabot-default-embedding-model
-     metabot-feedback-url
-     metabot-get-prompt-templates-url
-     metabot-prompt-generator-token-limit
-     multi-setting-read-only
-     notebook-native-preview-shown
-     notebook-native-preview-sidebar-width
-     notification-link-base-url
-     num-metabot-choices
-     openai-api-key
-     openai-available-models
-     openai-model
-     openai-organization
-     other-sso-enabled?
-     password-complexity
-     persist-models-enabled
-     persisted-model-refresh-cron-schedule
-     premium-embedding-token
-     prometheus-server-port
-     query-caching-max-kb
-     query-caching-max-ttl
-     query-caching-min-ttl
-     query-caching-ttl-ratio
-     redirect-all-requests-to-https
-     reset-token-ttl-hours
-     retired-setting
-     retry-initial-interval
-     retry-max-attempts
-     retry-max-interval-millis
-     retry-multiplier
-     retry-randomization-factor
-     saml-application-name
-     saml-attribute-email
-     saml-attribute-firstname
-     saml-attribute-group
-     saml-attribute-lastname
-     saml-configured
-     saml-enabled
-     saml-group-mappings
-     saml-group-sync
-     saml-identity-provider-certificate
-     saml-identity-provider-issuer
-     saml-identity-provider-uri
-     saml-keystore-alias
-     saml-keystore-password
-     saml-keystore-path
-     saml-user-provisioning-enabled?
-     send-email-on-first-login-from-new-device
-     send-new-sso-user-admin-email?
-     session-cookie-samesite
-     session-cookies
-     session-timeout
-     setup-token
-     show-database-syncing-modal
-     show-metabase-links
-     site-url
-     site-uuid
-     site-uuid-for-premium-features-token-checks
-     site-uuid-for-unsubscribing-url
-     site-uuid-for-version-info-fetching
-     slack-app-token
-     slack-cached-channels-and-usernames
-     slack-channels-and-usernames-last-updated
-     slack-files-channel
-     slack-token
-     slack-token-valid?
-     snowplow-available
-     snowplow-enabled
-     snowplow-url
-     sql-jdbc-fetch-size
-     ssh-heartbeat-interval-sec
-     ssl-certificate-public-key
-     startup-time-millis
-     token-features
-     token-status
-     toucan-name
-     trial-banner-dismissal-timestamp
-     uncached-setting
-     user-visibility
-     version
-     version-info
-     version-info-last-checked})
-
-(defn- defsetting-lint [node setting-name docstring options-list]
-  (let [anon-binding (common/with-macro-meta (hooks/token-node '_) node)
-        ;; (defn my-setting [] ...)
-        getter-node (-> (list
-                         (hooks/token-node 'defn)
-                         setting-name
-                         (hooks/string-node "Docstring.")
-                         (hooks/vector-node []))
-                        hooks/list-node
-                        (with-meta (meta node)))
-        ;; (defn my-setting! [_x] ...)
-        setter-node (-> (list
-                         (hooks/token-node 'defn)
-                         (with-meta
-                          (hooks/token-node (symbol (str (hooks/sexpr setting-name) \!)))
-                          (meta setting-name))
-                         (hooks/string-node "Docstring.")
-                         (hooks/vector-node [(hooks/token-node '_value-or-nil)]))
-                        hooks/list-node
-                        (with-meta (meta node))
-                        common/add-lsp-ignore-unused-public-var-metadata)]
-
-    (when (nil? (second (drop-while (comp not #{[:k :export?]} first) options-list)))
-      (when-not (contains? ignored-implicit-export? (:value setting-name))
-        (hooks/reg-finding! (assoc (meta node)
-                                   :message "Setting definition must provide an explicit value for :export? indicating whether the setting should be exported or not with serialization."
-                                   :type :metabase/defsetting-must-specify-export))))
-
-    {:node (-> (list
-                (hooks/token-node 'let)
-                 ;; include description and the options map so they can get validated as well.
-                (hooks/vector-node
-                 [anon-binding docstring
-                  anon-binding (hooks/map-node options-list)])
-                getter-node
-                setter-node)
-               hooks/list-node
-               (with-meta (meta node)))}))
-
-(defn defsetting
-  "Rewrite a [[metabase.models.defsetting]] form like
-
-    (defsetting my-setting \"Description\" :type :boolean)
-
-  as
-
-    (let [_ \"Description\"
-          _ {:type :boolean}]
-      (defn my-setting \"Docstring.\" [])
-      (defn my-setting! \"Docstring.\" [_value-or-nil]))
-
-  for linting purposes."
-  [{:keys [node]}]
-  (let [[setting-name docstring & options] (rest (:children node))]
-    (defsetting-lint node setting-name docstring options)))
-
-(defn define-multi-setting
-  "Rewrite a [[metabase.models.define-multi-setting]] form like
-
-    (defsetting my-setting \"Description\" :key :type :boolean)
-
-  as
-
-    (let [_ \"Description\"
-          _ {:type :boolean, :multi-thunk :key}]
-      (defn my-setting \"Docstring.\" [])
-      (defn my-setting! \"Docstring.\" [_value-or-nil]))
-
-  for linting purposes."
-  [{:keys [node]}]
-  (let [[setting-name docstring thunk & options] (rest (:children node))]
-    (defsetting-lint node setting-name docstring (concat options [(hooks/token-node :multi-thunk) thunk]))))
-
-(comment
-  (defn- defsetting* [form]
-    (hooks/sexpr
-     (:node
-      (defsetting
-        {:node
-         (hooks/parse-string
-          (with-out-str
-            #_{:clj-kondo/ignore [:unresolved-namespace]}
-            (clojure.pprint/pprint
-             form)))}))))
-
-  (defn x []
-    (defsetting*
-      '(defsetting active-users-count
-         (deferred-tru "Cached number of active users. Refresh every 5 minutes.")
-         :visibility :admin
-         :type       :integer
-         :default    0
-         :getter     (fn []
-                       (if-not ((requiring-resolve 'metabase.db/db-is-set-up?))
-                         0
-                         (cached-active-users-count)))))))

.clj-kondo/src/hooks/metabase/test/data/datasets.clj

@@ -1,58 +0,0 @@
-(ns hooks.metabase.test.data.datasets
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [clojure.set :as set]
-   [hooks.common]))
-
-(defn- only-core-drivers?
-  "Whether we're for sure only testing against the 'core' drivers that are also app DB types: `:postgres`, `:mysql`, or
-  `:h2`. Tests like these are ok to mark `:mb/once` or `:mb/driver-tests` since we always run the full test suite
-  against app DB drivers anyway."
-  [node]
-  (let [drivers (hooks/sexpr (second (:children node)))
-        drivers (cond
-                  (keyword? drivers) #{drivers}
-                  (set? drivers)     drivers
-                  :else              nil)]
-    (when drivers
-      (empty? (set/difference drivers #{:h2 :mysql :postgres})))))
-
-(defn- validate-mb-once [x]
-  (when (:mb/once (meta (:ns x)))
-    (hooks/reg-finding!
-     (assoc (meta (:ns x))
-            :message (str "You should not use test-driver or test-drivers in a namespace marked ^:mb/once"
-                          " [:metabase/validate-mb-once]")
-            :type :metabase/validate-mb-once))))
-
-(defn- validate-mb-driver-tests [x]
-  (when-not (:mb/driver-tests (meta (:ns x)))
-    (hooks/reg-finding!
-     (assoc (meta (:ns x))
-            :message (str "Namespaces that run driver tests (test-driver or test-drivers) should be marked"
-                          " ^:mb/driver-tests [:metabase/validate-mb-driver-tests]")
-            :type :metabase/validate-mb-driver-tests))))
-
-(defn- validate-ns-tags [x]
-  (when-not (only-core-drivers? (:node x))
-    (validate-mb-once x)
-    (validate-mb-driver-tests x)))
-
-(defn test-drivers [x]
-  (validate-ns-tags x)
-  (letfn [(update-node [node]
-            (let [[test-drivers drivers-expr & body] (:children node)]
-              (-> (hooks/list-node
-                   (list*
-                    (hooks/token-node 'do)
-                    test-drivers
-                    (-> drivers-expr
-                        (hooks.common/update-ignored-linters conj :unused-value))
-                    body))
-                  (with-meta (meta node)))))]
-    (update x :node update-node)))
-
-(defn test-driver
-  "We can use the same hook for `test-driver` as we use for `test-drivers`."
-  [x]
-  (test-drivers x))

.clj-kondo/src/hooks/metabase/test/util.clj

@@ -1,60 +0,0 @@
-(ns hooks.metabase.test.util
-  (:require [clj-kondo.hooks-api :as hooks]
-            [hooks.common :as common]))
-
-(defn- namespaced-symbol-node? [node]
-  (when (hooks/token-node? node)
-    (let [symb (hooks/sexpr node)]
-      (and (symbol? symb)
-           (namespace symb)))))
-
-(defn with-temporary-setting-values
-  "Rewrite a form like
-
-    (with-temporary-setting-values [x 1, some.ns/y 2]
-      ...)
-
-  as one like
-
-    (let [_ 1, _ some.ns/y, _ 2]
-      ...)
-
-  for analysis purposes. We only need to 'capture' namespaced Setting bindings with a `_` so Kondo considers their
-  namespace to be 'used' and to catch undefined var usage."
-  [{:keys [node]}]
-  (let [{[_ bindings & body] :children} node
-        bindings (if (hooks/vector-node? bindings)
-                   (hooks/vector-node (into []
-                                            (mapcat (fn [[setting-name v]]
-                                                      (concat
-                                                       [(with-meta (hooks/token-node '_) (meta setting-name)) v]
-                                                        ;; if the setting name is namespace-qualified add a `_`
-                                                        ;; entry for it too.
-                                                       (when (namespaced-symbol-node? setting-name)
-                                                         [(with-meta (hooks/token-node '_) (meta setting-name)) setting-name]))))
-                                            (partition 2 (:children bindings))))
-                   bindings)]
-    {:node (-> (list*
-                (hooks/token-node 'let)
-                bindings
-                body)
-               (with-meta (meta body))
-               hooks/list-node
-               (with-meta (meta body)))}))
-
-(defn with-temp-file
-  [{{[_ {bindings :children} & body] :children} :node}]
-  (let [node* (hooks/list-node
-               (list*
-                (hooks/token-node 'let)
-                (hooks/vector-node
-                 (into []
-                       (comp (partition-all 2)
-                             (mapcat (fn [[binding filename]]
-                                       [binding (or (when (and filename
-                                                               (not (nil? (hooks/sexpr filename))))
-                                                      filename)
-                                                    (hooks/string-node "filename"))])))
-                       bindings))
-                body))]
-    {:node node*}))

.clj-kondo/src/hooks/metabase/util.clj

@@ -1,31 +0,0 @@
-(ns hooks.metabase.util
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [hooks.common]))
-
-(defn format-color [{:keys [node], :as x}]
-  (let [[_format-color _color format-string-node & args] (:children node)]
-    (when (api/string-node? format-string-node)
-      (let [expected-arg-count (hooks.common/format-string-specifier-count (api/sexpr format-string-node))
-            actual-arg-count   (count args)]
-        (when-not (= expected-arg-count actual-arg-count)
-          (api/reg-finding! (assoc (meta node)
-                                   :message (format "metabase.util/format-color format string expects %d arguments instead of %d."
-                                                    expected-arg-count
-                                                    actual-arg-count)
-                                   :type :format))))))
-  x)
-
-(defn case-enum
-  "Lint `(case-enum ...)` like `(condp = ...)`."
-  [x]
-  (letfn [(update-node [node]
-            (let [[_case-enum x & more] (:children node)]
-              (-> (api/list-node
-                   (list*
-                    (api/token-node 'clojure.core/condp)
-                    (api/token-node 'clojure.core/=)
-                    x
-                    more))
-                  (with-meta (meta node)))))]
-    (update x :node update-node)))

.clj-kondo/src/hooks/metabase/util/log.clj

@@ -1,124 +0,0 @@
-(ns hooks.metabase.util.log
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [clojure.string :as str]
-   [clojure.walk :as walk]
-   [hooks.common]))
-
-;;;; Checks for both log + logf
-
-(defn- disallow-i18n [node]
-  (walk/postwalk
-   (fn [x]
-     (when-let [qualified-symbol (hooks.common/node->qualified-symbol x)]
-       (when (and (= (namespace qualified-symbol) "metabase.util.i18n")
-                  (or (str/includes? (name qualified-symbol) "tru")
-                      (str/includes? (name qualified-symbol) "trs")))
-         (api/reg-finding! (assoc (meta x)
-                                  :message "do not i18n the logs!"
-                                  :type :metabase/validate-logging)))))
-   node))
-
-(defn- check-position-of-exception-arg
-  "Tell people to do (info e \"whatever\") instead of (info \"whatever\" e)."
-  [node]
-  (let [[f _first-arg & args] (:children node)]
-    (doseq [arg args]
-      (when (and (api/token-node? arg)
-                 (= (api/sexpr arg) 'e))
-        (api/reg-finding! (assoc (meta arg)
-                                 :message (format "pass exceptions as the first arg to %s" (api/sexpr f))
-                                 :type :metabase/validate-logging))))))
-
-(defn- common-checks [node]
-  (check-position-of-exception-arg node)
-  (disallow-i18n node))
-
-(defn- check-for-i18n-format-specifiers
-  "Make sure people aren't using things like {0} in their log messages."
-  [node string-node]
-  (when (re-find #"\{\d+\}" (api/sexpr string-node))
-    (api/reg-finding! (assoc (meta node)
-                             :message "this looks like an i18n format string. Don't use identifiers like {0} in logging."
-                             :type :metabase/validate-logging))))
-
-;;; log only
-
-(defn- check-not-format-string
-  "Make sure we're not using something like log/trace with a format string."
-  [{[f] :children, :as node} string-node]
-  (when (pos? (hooks.common/format-string-specifier-count (api/sexpr string-node)))
-    (api/reg-finding! (assoc (meta node)
-                             :message (format "%s used with a format string, use %s instead."
-                                              (api/sexpr f)
-                                              (str (api/sexpr f) "f"))
-                             :type :metabase/validate-logging))))
-
-(defn- format-node? [node]
-  (when (api/list-node? node)
-    (let [[x] (:children node)]
-      (and (api/token-node? x)
-           (or (= (hooks.common/node->qualified-symbol x) 'clojure.core/format)
-               (= (api/sexpr x) 'format))))))
-
-(defn- warn-against-log+format-instead-of-logf
-  "Tell people to use things like infof instead of info + format."
-  [{[f] :children, :as node} [x :as args]]
-  (when (and (= (count args) 1)
-             (api/list-node? x))
-    (when (format-node? x)
-      (api/reg-finding! (assoc (meta node)
-                               :message (format "Use %s instead of %s + format"
-                                                (str (api/sexpr f) "f")
-                                                (api/sexpr f))
-                               :type :metabase/validate-logging)))))
-
-(defn info
-  "Valid log, debug, etc."
-  [{:keys [node], :as x}]
-  (common-checks node)
-  (let [[_f & args]         (:children node)
-        [_e & [x :as args]] (if (and (api/token-node? (first args))
-                                     (or (api/string-node? (second args))
-                                         (format-node? (second args))))
-                              args
-                              (cons nil args))]
-    (when (api/string-node? x)
-      (check-for-i18n-format-specifiers node x)
-      (check-not-format-string node x))
-    (warn-against-log+format-instead-of-logf node args))
-  x)
-
-;;;; logf only
-
-(defn- check-format-string-arg-count
-  "Make sure the number of args passed to something like tracef match the number of format string specifiers."
-  [{[f] :children, :as node} format-string args]
-  (let [expected-arg-count (hooks.common/format-string-specifier-count (api/sexpr format-string))
-        actual-arg-count   (count args)]
-    (when (zero? expected-arg-count)
-      (api/reg-finding! (assoc (meta node)
-                               :message (format "Don't use %s with no format string arguments, use %s instead."
-                                                (api/sexpr f)
-                                                (str/replace (str (api/sexpr f)) #"f$" ""))
-                               :type :metabase/validate-logging)))
-    (when-not (= expected-arg-count actual-arg-count)
-      (api/reg-finding! (assoc (meta node)
-                               :message (format "log format string expects %d arguments instead of %d."
-                                                expected-arg-count
-                                                actual-arg-count)
-                               :type :metabase/validate-logging)))))
-
-(defn infof
-  "Valid logf, debugf, etc."
-  [{:keys [node], :as x}]
-  (common-checks node)
-  (let [[_f & args]               (:children node)
-        [_e format-string & args] (if (api/string-node? (first args))
-                                    (cons nil args)
-                                    args)]
-    ;; TODO -- maybe we can error if you did not pass a format string, e.g. (log/infof 1 2) is obviously incorrect.
-    (when (api/string-node? format-string)
-      (check-for-i18n-format-specifiers node format-string)
-      (check-format-string-arg-count node format-string args)))
-  x)

.clj-kondo/src/hooks/metabase/util/log/capture.clj

@@ -1,26 +0,0 @@
-(ns hooks.metabase.util.log.capture
-  (:require
-   [clj-kondo.hooks-api :as api]))
-
-(defn with-log-messages-for-level [x]
-  (letfn [(update-binding [[lhs-node _rhs-node]]
-            [lhs-node (api/list-node
-                       (list
-                        (api/token-node 'clojure.core/fn)
-                        (api/vector-node [])))])
-          (update-bindings [bindings-node]
-            (-> (api/vector-node
-                 (into []
-                       (comp (partition-all 2)
-                             (mapcat update-binding))
-                       (:children bindings-node)))
-                (with-meta (meta bindings-node))))
-          (update-node [node]
-            (let [[_with-log-messages-for-level bindings & body] (:children node)]
-              (-> (api/list-node
-                   (list*
-                    (api/token-node 'clojure.core/let)
-                    (update-bindings bindings)
-                    body))
-                  (with-meta (meta node)))))]
-    (update x :node update-node)))

.clj-kondo/src/hooks/metabase/util/malli/registry.clj

@@ -1,20 +0,0 @@
-(ns hooks.metabase.util.malli.registry
-  (:refer-clojure :exclude [def])
-  (:require
-   [clj-kondo.hooks-api :as api]))
-
-(defn def
-  "Register the schema keyword so LSP can jump to it."
-  [x]
-  (letfn [(update-def-keyword [k]
-            (api/reg-keyword! k 'metabase.util.malli.registry/def))
-          (update-children [[_def k :as children]]
-            (if (api/keyword-node? k)
-              (update (vec children) 1 update-def-keyword)
-              children))
-          (update-node [node]
-            (if (api/list-node? node)
-              (-> (api/list-node (update-children (:children node)))
-                  (with-meta (meta node)))
-              node))]
-    (update x :node update-node)))

.clj-kondo/test.clj

@@ -0,0 +1,10 @@
+(ns test
+  (:require [metabase.query-processor.streaming :as streaming]
+            [toucan.models :as models]))
+
+(models/defmodel Card :foo)
+
+(map->Card {:foo 1})
+(map->CardInstance {:foo 1})
+
+(streaming/streaming-response [x 1 (inc x)])

.clj-kondo/test/hooks/clojure/core_test.clj

@@ -1,54 +0,0 @@
-(ns hooks.clojure.core-test
-  (:require
-   [clj-kondo.hooks-api :as hooks]
-   [clojure.test :refer :all]
-   [hooks.clojure.core]))
-
-(deftest module-checker-allowed-modules-test
-  (let [findings (atom [])]
-    (with-redefs [hooks/reg-finding! (fn [node]
-                                       (swap! findings conj node))]
-      (hooks.clojure.core/lint-ns
-       {:node     (hooks/parse-string "
-(ns metabase.api.search
-  (:require
-   [metabase.request.core :as request]
-   [metabase.task :as task]))")
-        :config '{:linters {:metabase/ns-module-checker {:allowed-modules {metabase.api #{metabase.request}}
-                                                         :api-namespaces  {metabase.request #{metabase.request.core}}}}}})
-      (is (=? [{:message (str "Module metabase.task should not be used in the metabase.api module."
-                              " [:metabase/ns-module-checker :allowed-modules metabase.api]")
-                :type :metabase/ns-module-checker}]
-              @findings)))))
-
-(deftest module-checker-api-namespaces-test
-  (let [findings (atom [])]
-    (with-redefs [hooks/reg-finding! (fn [node]
-                                       (swap! findings conj node))]
-      (hooks.clojure.core/lint-ns
-       {:node     (hooks/parse-string "
-(ns metabase.api.search
-  (:require
-   [metabase.search.config :as search.config]
-   [metabase.search.core :as search]))")
-        :config '{:linters {:metabase/ns-module-checker {:allowed-modules {metabase.api #{metabase.search}}
-                                                         :api-namespaces  {metabase.search #{metabase.search.core}}}}}})
-      (is (=? [{:message (str "Namespace metabase.search.config is not an allowed external API namespace for the"
-                              " metabase.search module. [:metabase/ns-module-checker :api-namespaces metabase.search]")
-                :type :metabase/ns-module-checker}]
-              @findings)))))
-
-(deftest module-checker-api-namespaces-ignore-test
-  (let [findings (atom [])]
-    (with-redefs [hooks/reg-finding! (fn [node]
-                                       (swap! findings conj node))]
-      (hooks.clojure.core/lint-ns
-       {:node     (hooks/parse-string "
-(ns metabase.api.search
-  (:require
-   ^{:clj-kondo/ignore [:metabase/ns-module-checker]}
-   [metabase.search.config :as search.config]
-   [metabase.search.core :as search]))")
-        :config '{:linters {:metabase/ns-module-checker {:allowed-modules {metabase.api #{metabase.search}}
-                                                         :api-namespaces  {metabase.search #{metabase.search.core}}}}}})
-      (is (empty? @findings)))))

.clj-kondo/test/hooks/clojure/test_test.clj

@@ -1,55 +0,0 @@
-(ns hooks.clojure.test-test
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [clj-kondo.impl.utils]
-   [clojure.edn :as edn]
-   [clojure.test :refer :all]
-   [hooks.clojure.test]))
-
-(set! *warn-on-reflection* true)
-
-(defn- deftest-warnings
-  [form]
-  (binding [clj-kondo.impl.utils/*ctx* {:config     {:linters {:metabase/disallow-hardcoded-driver-names-in-tests {:level :warning}}}
-                                        :ignores    (atom nil)
-                                        :findings   (atom [])
-                                        :namespaces (atom {})}]
-    (hooks.clojure.test/deftest {:node   (api/parse-string form)
-                                 :config {:linters
-                                          {:metabase/disallow-hardcoded-driver-names-in-tests
-                                           {:drivers
-                                            #{:athena}}}}})
-    (mapv :message @(:findings clj-kondo.impl.utils/*ctx*))))
-
-(deftest ^:parallel disallow-hardcoded-driver-names-in-tests-test
-  (is (= []
-         (deftest-warnings
-           "(mt/test-drivers (mt/normal-drivers)
-              (do-something))")))
-  (is (= ["Do not hardcode driver name :athena in driver tests! [:metabase/disallow-hardcoded-driver-names-in-tests]"]
-         (deftest-warnings
-           "(mt/test-drivers (mt/normal-drivers)
-              (when-not (= driver/*driver* :athena)
-                (do-something)))")))
-  (testing "make sure :clj-kondo/ignore is propagated correctly"
-    (is (= []
-           (deftest-warnings
-             "(mt/test-drivers (mt/normal-drivers)
-                #_{:clj-kondo/ignore [:metabase/disallow-hardcoded-driver-names-in-tests]}
-                (when-not (= driver/*driver* :athena)
-                  (do-something)))")))))
-
-(deftest ^:parallel check-driver-keywords-test
-  (testing "Make sure we keep hooks.clojure.test/driver-keywords up to date"
-    (let [driver-keywords (-> (slurp ".clj-kondo/config.edn")
-                              edn/read-string
-                              (get-in [:linters :metabase/disallow-hardcoded-driver-names-in-tests :drivers]))
-          driver-modules (->> (slurp "modules/drivers/deps.edn")
-                              edn/read-string
-                              :deps
-                              vals
-                              (keep (comp keyword :local/root))
-                              (into #{}))]
-      (doseq [driver driver-modules]
-        (is (contains? driver-keywords driver)
-            (format "hooks.clojure.test/driver-keywords should contain %s, please add it" driver))))))

.clj-kondo/test/hooks/common_test.clj

@@ -1,48 +0,0 @@
-(ns ^:mb/once hooks.common-test
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [clj-kondo.impl.utils]
-   [clojure.test :refer :all]
-   [hooks.common]))
-
-(deftest ^:parallel ignored-linters-test
-  (doseq [ignored [":metabase/ns-module-checker"
-                   "[:metabase/ns-module-checker]"
-                   "(:metabase/ns-module-checker)"]
-          prefix ["#_"
-                  "^"]
-          :let [s (format "%s{:clj-kondo/ignore %s} [metabase.search.config :as search.config]"
-                          prefix
-                          ignored)]]
-    (testing (pr-str s)
-      (is (= #{:metabase/ns-module-checker}
-             (hooks.common/ignored-linters (api/parse-string s)))))))
-
-(deftest ^:parallel merge-ignored-linters-test
-  (let [node-1  (api/parse-string "#_{:clj-kondo/ignore [:a]} [:a]")
-        node-2  (api/parse-string "#_{:clj-kondo/ignore [:b]} [:b]")
-        node-3  (api/parse-string "#_{:clj-kondo/ignore [:c]} [:c]")
-        node-1' (hooks.common/merge-ignored-linters node-1 node-2 node-3)]
-    (is (= #{:a :b :c}
-           (hooks.common/ignored-linters node-1')))
-    (testing "Updated metadata should match the shape Kondo expects"
-      (is (=? {:clj-kondo/ignore {:linters api/vector-node?}}
-              (meta node-1')))
-      (let [children (-> node-1' meta :clj-kondo/ignore :linters :children)]
-        (is (= (count children) 3))
-        (is (every? api/keyword-node? children))
-        (is (= [:a :b :c]
-               (sort (map api/sexpr children))))))))
-
-(deftest ^:parallel node->qualified-symbol-test
-  (binding [clj-kondo.impl.utils/*ctx* {:namespaces (atom nil)}]
-    (is (= 'metabase.util.i18n/tru
-           (hooks.common/node->qualified-symbol (api/parse-string "metabase.util.i18n/tru"))))))
-
-(deftest ^:parallel node->qualified-symbol-test-2
-  (binding [clj-kondo.impl.utils/*ctx* {:namespaces (atom {:clj {:clj '{hooks.common-test {:qualify-ns {i18n metabase.util.i18n}}}}})
-                                        :lang       :clj
-                                        :base-lang  :clj
-                                        :ns         {:name 'hooks.common-test}}]
-    (is (= 'metabase.util.i18n/tru
-           (hooks.common/node->qualified-symbol (api/parse-string "i18n/tru"))))))

.clj-kondo/test/hooks/metabase/api/common_test.clj

@@ -1,35 +0,0 @@
-(ns hooks.metabase.api.common-test
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [clojure.test :refer :all]
-   [hooks.metabase.api.common]))
-
-(deftest ^:parallel defendpoint-test
-  (is (= '(do
-            compojure.core/POST
-            (clojure.core/defn
-              POST_:id_copy
-              "Copy a `Card`, with the new name 'Copy of _name_'"
-              [id]
-              {id [:maybe ms/PositiveInt]}
-              (let [orig-card (api/read-check Card id)
-                    new-name (str (trs "Copy of ") (:name orig-card))
-                    new-card (assoc orig-card :name new-name)]
-                (-> (card/create-card! new-card @api/*current-user*)
-                    hydrate-card-details
-                    (assoc :last-edit-info (last-edit/edit-information-for-user @api/*current-user*))))))
-         (-> {:node (-> '(api/defendpoint POST "/:id/copy"
-                           "Copy a `Card`, with the new name 'Copy of _name_'"
-                           [id]
-                           {id [:maybe ms/PositiveInt]}
-                           (let [orig-card (api/read-check Card id)
-                                 new-name  (str (trs "Copy of ") (:name orig-card))
-                                 new-card  (assoc orig-card :name new-name)]
-                             (-> (card/create-card! new-card @api/*current-user*)
-                                 hydrate-card-details
-                                 (assoc :last-edit-info (last-edit/edit-information-for-user @api/*current-user*)))))
-                        pr-str
-                        api/parse-string)}
-             hooks.metabase.api.common/defendpoint
-             :node
-             api/sexpr))))

.clj-kondo/test/hooks/metabase/util/log/capture_test.clj

@@ -1,19 +0,0 @@
-(ns hooks.metabase.util.log.capture-test
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [clojure.test :refer :all]
-   [hooks.metabase.util.log.capture]))
-
-(deftest ^:parallel with-log-messages-for-level-test
-  (is (= '(clojure.core/let [messages-1 (clojure.core/fn [])
-                             messages-2 (clojure.core/fn [])]
-            (concat (messages-1)
-                    (messages-2)))
-         (-> (hooks.metabase.util.log.capture/with-log-messages-for-level
-               {:node (-> '(with-log-messages-for-level [messages-1 [my.namespace :debug]
-                                                         messages-2 :info]
-                             (concat (messages-1) (messages-2)))
-                          pr-str
-                          api/parse-string)})
-             :node
-             api/sexpr))))

.clj-kondo/test/hooks/metabase/util/log_test.clj

@@ -1,77 +0,0 @@
-(ns ^:mb/once hooks.metabase.util.log-test
-  (:require
-   [clj-kondo.hooks-api :as api]
-   [clj-kondo.impl.utils]
-   [clojure.string :as str]
-   [clojure.test :refer :all]
-   [hooks.metabase.util.log]))
-
-(defn- warnings
-  [form]
-  (let [f (if (str/ends-with? (name (first form)) "f")
-            hooks.metabase.util.log/infof
-            hooks.metabase.util.log/info)]
-    (binding [clj-kondo.impl.utils/*ctx* {:config     {:linters {:metabase/validate-logging {:level :warning}}}
-                                          :ignores    (atom nil)
-                                          :findings   (atom [])
-                                          :namespaces (atom {})}]
-      (f {:node (api/parse-string (pr-str form))})
-      (mapv :message @(:findings clj-kondo.impl.utils/*ctx*)))))
-
-(deftest ^:parallel warn-on-missing-format-args-test
-  (testing "should fail, missing a format arg"
-    (are [form] (= ["log format string expects 1 arguments instead of 0."]
-                   (warnings (quote form)))
-      (metabase.util.log/warnf "Migration lock was acquired after %d retries.")
-      (metabase.util.log/warnf e "Migration lock was acquired after %d retries."))))
-
-(deftest ^:parallel warn-on-too-many-format-args-test-1
-  (testing "should fail, too many format args"
-    (are [form] (= ["log format string expects 1 arguments instead of 2."]
-                   (warnings (quote form)))
-      (metabase.util.log/warnf "Migration lock was acquired after %d retries." 1 2)
-      (metabase.util.log/warnf e "Migration lock was acquired after %d retries." 1 2))))
-
-(deftest ^:parallel warn-on-too-many-format-args-test-2
-  (testing "should fail, too many format args"
-    (are [form] (= ["this looks like an i18n format string. Don't use identifiers like {0} in logging."
-                    "Don't use metabase.util.log/warnf with no format string arguments, use metabase.util.log/warn instead."
-                    "log format string expects 0 arguments instead of 1."]
-                   (warnings (quote form)))
-      (metabase.util.log/warnf "Migration lock was acquired after {0} retries." 1)
-      (metabase.util.log/warnf e "Migration lock was acquired after {0} retries." 1))))
-
-(deftest ^:parallel warn-on-format-args-without-logf-test
-  (testing "should fail, has format args but is warn rather than warnf"
-    (are [form] (= ["metabase.util.log/warn used with a format string, use metabase.util.log/warnf instead."]
-                   (warnings (quote form)))
-      (metabase.util.log/warn "Migration lock was acquired after %d retries." 1)
-      (metabase.util.log/warn e "Migration lock was acquired after %d retries." 1))))
-
-(deftest ^:parallel warn-on-format-without-logf-test
-  (testing "should fail, has format args but is warn rather than warnf"
-    (are [form] (= ["Use metabase.util.log/warnf instead of metabase.util.log/warn + format"]
-                   (warnings (quote form)))
-      (metabase.util.log/warn (format "Migration lock was acquired after %d retries." 1))
-      (metabase.util.log/warn e (format "Migration lock was acquired after %d retries." 1)))))
-
-(deftest ^:parallel warn-on-logf-with-no-format-args-test
-  (testing "should fail, has format args but is warn rather than warnf"
-    (are [form] (= ["Don't use metabase.util.log/warnf with no format string arguments, use metabase.util.log/warn instead."]
-                   (warnings (quote form)))
-      (metabase.util.log/warnf "Migration lock cleared.")
-      (metabase.util.log/warnf e "Migration lock cleared."))))
-
-(deftest ^:parallel warn-on-i18n-test-1
-  (testing "should fail -- should not use i18n/tru or i18n/trs"
-    (are [form] (= ["do not i18n the logs!"]
-                   (warnings (quote form)))
-      (metabase.util.log/warnf (metabase.util.i18n/tru "Migration lock was acquired after {0} retries." 1))
-      (metabase.util.log/warnf e (metabase.util.i18n/tru "Migration lock was acquired after {0} retries." 1)))))
-
-(deftest ^:parallel warn-on-i18n-test-2
-  (testing "should fail -- should not use i18n/tru or i18n/trs"
-    (are [form] (= ["do not i18n the logs!"]
-                   (warnings (quote form)))
-      (metabase.util.log/warn (metabase.util.i18n/trs "Migration lock was acquired after {0} retries." 1))
-      (metabase.util.log/warn e (metabase.util.i18n/trs "Migration lock was acquired after {0} retries." 1)))))

.cljfmt.edn

@@ -1,348 +0,0 @@
-;; Cljfmt config. See https://github.com/weavejester/cljfmt#formatting-options
-{:sort-ns-references?
- true
-
- :function-arguments-indentation
- :community
-
- :parallel?
- true
-
- :paths
- ["src"
-  "test"
-  "enterprise/backend"
-  "bin/build"
-  "bin/lint-migrations-file"
-  "bin/release-list"
-  "modules/drivers"
-  ".clj-kondo/src"
-  ".clj-kondo/test"
-  #_"dev"]
-
- ;; See https://github.com/weavejester/cljfmt/blob/master/cljfmt/resources/cljfmt/indents/clojure.clj for the default
- ;; definitions
- ;;
- ;;    [[:block 0]]
- ;;             ^ number of special args
- ;;
- ;; `:block` indentation means format with all arguments indented 2 spaces except for the 'special' arguments which
- ;; normally are supposed to go on the first line. e.g. `let` gets [[:block 1]] because it has one 'special' arg.
- ;;
- ;;    [[:inner 0]]
- ;;             ^ depth
- ;;    [[:inner 2 0]]
- ;;               ^ argument index to restrict this rule to
- ;;
- ;; `:inner` indentation is like `:defn` indentation. `[[:inner 0]]` (default for `defn`) means all arguments at depth
- ;; zero get indented 2 spaces if not on the first line regardless of number of elements on the first line.
- :extra-indents
- {;; clojure.core stuff
-  fn*                                                                                  [[:inner 0]]
-  let*                                                                                 [[:block 1]]
-  with-meta                                                                            [[:default]]
-  ;; library stuff. Libraries that specify their own `:style/indent` specs are included in the section after this
-  ;; since it is generated automatically.
-  clojure.core.logic/fresh                                                             [[:block 1]]
-  clojure.core.logic/matcha                                                            [[:block 1]]
-  clojure.core.logic/run                                                               [[:block 2]]
-  clojure.core.match/match                                                             [[:block 1]]
-  clojure.test.check.properties/for-all                                                [[:block 1]]
-  clojure.test.check.properties/for-all*                                               [[:block 1]]
-  clojure.test.check/quick-check                                                       [[:block 1]]
-  clojure.tools.macro/macrolet                                                         [[:block 1] [:inner 2 0]]
-  clojurewerkz.quartzite.jobs/build                                                    [[:default]]
-  clojurewerkz.quartzite.jobs/with-description                                         [[:default]]
-  clojurewerkz.quartzite.jobs/with-identity                                            [[:default]]
-  clojurewerkz.quartzite.schedule.cron/schedule                                        [[:default]]
-  clojurewerkz.quartzite.schedule.cron/with-misfire-handling-instruction-do-nothing    [[:default]]
-  clojurewerkz.quartzite.triggers/build                                                [[:default]]
-  clojurewerkz.quartzite.triggers/with-description                                     [[:default]]
-  clojurewerkz.quartzite.triggers/with-identity                                        [[:default]]
-  clojurewerkz.quartzite.triggers/with-priority                                        [[:default]]
-  clojurewerkz.quartzite.triggers/with-schedule                                        [[:default]]
-  def-map-type                                                                         [[:block 2] [:inner 1]]
-  defprotocol+                                                                         [[:block 1] [:inner 1]]
-  defrecord+                                                                           [[:block 2] [:inner 1]]
-  deftype+                                                                             [[:block 2] [:inner 1]]
-  net.cgrand.macrovich/case                                                            [[:block 0]]
-  potemkin.namespaces/import-vars                                                      [[:default]]
-  potemkin.types/def-map-type                                                          [[:block 2] [:inner 1]]
-  potemkin.types/defprotocol+                                                          [[:block 1] [:inner 1]]
-  potemkin.types/defrecord+                                                            [[:block 2] [:inner 1]]
-  potemkin.types/deftype+                                                              [[:block 2] [:inner 1]]
-  potemkin/def-map-type                                                                [[:block 2] [:inner 1]]
-  potemkin/defprotocol+                                                                [[:block 1] [:inner 1]]
-  potemkin/defrecord+                                                                  [[:block 2] [:inner 1]]
-  potemkin/deftype+                                                                    [[:block 2] [:inner 1]]
-  potemkin/import-vars                                                                 [[:default]]
-  taoensso.nippy/extend-freeze                                                         [[:inner 0]]
-  taoensso.nippy/extend-thaw                                                           [[:inner 0]]
-  throttle.core/with-throttling                                                        [[:block 1]]
-  ;; the rest of the stuff in this list is generated automatically based on `:style/indent` specs
-  ;; by running [[dev.generate-cljfmt-config/specs]]... use that code to update this list
-  metabase-enterprise.advanced-permissions.api.util-test/with-impersonations!          [[:inner 0]]
-  metabase-enterprise.cache.config-test/with-temp-persist-models                       [[:block 1]]
-  metabase-enterprise.sandbox.test-util/with-gtaps!                                    [[:inner 0]]
-  metabase-enterprise.sandbox.test-util/with-gtaps-for-user!                           [[:inner 0]]
-  metabase-enterprise.sandbox.test-util/with-user-attributes                           [[:block 2]]
-  metabase-enterprise.serialization.test-util/with-dbs                                 [[:inner 0]]
-  metabase-enterprise.serialization.test-util/with-random-dump-dir                     [[:block 1]]
-  metabase-enterprise.serialization.test-util/with-world                               [[:block 0]]
-  metabase-enterprise.sso.integrations.jwt-test/with-users-with-email-deleted          [[:block 1]]
-  metabase-enterprise.test/with-gtaps!                                                 [[:inner 0]]
-  metabase-enterprise.test/with-gtaps-for-user!                                        [[:inner 0]]
-  metabase-enterprise.test/with-user-attributes                                        [[:block 2]]
-  metabase.actions-test/with-actions-test-data-and-actions-permissively-enabled        [[:block 0]]
-  metabase.actions.test-util/with-actions                                              [[:block 1]]
-  metabase.actions.test-util/with-actions-disabled                                     [[:block 0]]
-  metabase.actions.test-util/with-actions-enabled                                      [[:block 0]]
-  metabase.actions.test-util/with-actions-test-data                                    [[:inner 0]]
-  metabase.actions.test-util/with-actions-test-data-and-actions-enabled                [[:block 0]]
-  metabase.actions.test-util/with-actions-test-data-tables                             [[:block 1]]
-  metabase.actions.test-util/with-empty-db                                             [[:inner 0]]
-  metabase.actions.test-util/with-temp-test-data                                       [[:inner 0]]
-  metabase.api.alert-test/with-alert-in-collection                                     [[:block 1]]
-  metabase.api.card-test/with-cards-in-readable-collection                             [[:block 1]]
-  metabase.api.card-test/with-cards-in-writeable-collection                            [[:block 1]]
-  metabase.api.card-test/with-ordered-items                                            [[:inner 0]]
-  metabase.api.card-test/with-temp-native-card!                                        [[:block 1]]
-  metabase.api.card-test/with-temp-native-card-with-params!                            [[:block 1]]
-  metabase.api.collection-test/with-collection-hierarchy                               [[:block 1]]
-  metabase.api.collection-test/with-french-user-and-personal-collection                [[:block 2]]
-  metabase.api.collection-test/with-some-children-of-collection                        [[:block 1]]
-  metabase.api.common/check                                                            [[:default]]
-  metabase.api.common/define-routes                                                    [[:block 0]]
-  metabase.api.common/let-404                                                          [[:block 1]]
-  metabase.api.common.internal/auto-coerce                                             [[:block 1]]
-  metabase.api.common.internal/auto-parse                                              [[:block 1]]
-  metabase.api.common.internal-test/no-route-regexes                                   [[:block 0]]
-  metabase.api.embed-test/do-response-formats                                          [[:block 1]]
-  metabase.api.embed-test/with-embedding-enabled-and-new-secret-key                    [[:block 0]]
-  metabase.api.embed-test/with-embedding-enabled-and-temp-card-referencing             [[:block 3]]
-  metabase.api.embed-test/with-embedding-enabled-and-temp-dashcard-referencing         [[:block 3]]
-  metabase.api.embed-test/with-new-secret-key                                          [[:block 0]]
-  metabase.api.embed-test/with-temp-card                                               [[:block 1]]
-  metabase.api.embed-test/with-temp-dashcard                                           [[:block 1]]
-  metabase.api.preview-embed-test/with-embedding-enabled-and-new-secret-key            [[:block 0]]
-  metabase.api.preview-embed-test/with-new-secret-key                                  [[:block 0]]
-  metabase.api.public-test/with-sharing-enabled-and-temp-card-referencing              [[:block 3]]
-  metabase.api.public-test/with-sharing-enabled-and-temp-dashcard-referencing          [[:block 3]]
-  metabase.api.public-test/with-temp-public-card                                       [[:block 1]]
-  metabase.api.public-test/with-temp-public-dashboard                                  [[:block 1]]
-  metabase.api.public-test/with-temp-public-dashboard-and-card                         [[:block 1]]
-  metabase.api.search-test/do-test-users                                               [[:block 1]]
-  metabase.api.session/http-401-on-error                                               [[:block 0]]
-  metabase.async.streaming-response/streaming-response                                 [[:block 2]]
-  metabase.async.streaming-response-test/with-streaming-response-thread-pool           [[:block 0]]
-  metabase.async.streaming-response-test/with-test-driver-db!                          [[:block 0]]
-  metabase.async.util/cancelable-thread                                                [[:block 0]]
-  metabase.cmd.copy/step                                                               [[:block 1]]
-  metabase.cmd.copy/with-connection-rollback-only                                      [[:block 1]]
-  metabase.cmd.copy/with-disabled-db-constraints                                       [[:block 2]]
-  metabase.config/build-type-case                                                      [[:block 0]]
-  metabase.dashboard-subscription-test/with-link-card-fixture-for-dashboard            [[:block 2]]
-  metabase.db.liquibase/with-liquibase                                                 [[:block 1]]
-  metabase.db.liquibase/with-scope-locked                                              [[:block 1]]
-  metabase.db.schema-migrations-test.impl/test-migrations                              [[:block 2]]
-  metabase.db/with-application-db                                                      [[:inner 0]]
-  metabase.driver.bigquery-cloud-sdk.query-processor/with-temporal-type                [[:default]]
-  metabase.driver.druid.client/DELETE                                                  [[:default]]
-  metabase.driver.druid.client/GET                                                     [[:default]]
-  metabase.driver.druid.client/POST                                                    [[:default]]
-  metabase.driver.druid.query-processor-test/druid-query                               [[:block 0]]
-  metabase.driver.druid.query-processor-test/druid-query-returning-rows                [[:block 0]]
-  metabase.driver.mongo.query-processor/mongo-let                                      [[:block 1]]
-  metabase.driver.sql-jdbc.actions/with-jdbc-transaction                               [[:block 1]]
-  metabase.driver.sql-jdbc.connection/with-connection-spec-for-testing-connection      [[:block 1]]
-  metabase.driver.sql-jdbc.execute.diagnostic/capturing-diagnostic-info                [[:block 1]]
-  metabase.driver.sql.query-processor/apply-top-level-clause                           [[:default]]
-  metabase.driver/with-driver                                                          [[:block 1]]
-  metabase.lib.binning/with-binning                                                    [[:default]]
-  metabase.lib.core/with-binning                                                       [[:default]]
-  metabase.lib.core/with-join-alias                                                    [[:default]]
-  metabase.lib.core/with-join-conditions                                               [[:default]]
-  metabase.lib.join/with-join-alias                                                    [[:default]]
-  metabase.lib.join/with-join-conditions                                               [[:default]]
-  metabase.lib.test-util.macros/$ids                                                   [[:inner 0]]
-  metabase.lib.test-util.macros/mbql-query                                             [[:inner 0]]
-  metabase.lib.util.match/match                                                        [[:inner 0]]
-  metabase.lib.util.match/match-one                                                    [[:inner 0]]
-  metabase.lib.util.match/replace                                                      [[:inner 0]]
-  metabase.lib.util.match/replace-in                                                   [[:inner 0]]
-  metabase.models.collection-test/with-collection-hierarchy                            [[:block 1]]
-  metabase.models.collection-test/with-current-user-perms-for-collections              [[:block 1]]
-  metabase.models.collection-test/with-personal-and-impersonal-collections             [[:block 1]]
-  metabase.models.dashboard-test/with-dash-in-collection                               [[:inner 0]]
-  metabase.models.interface/define-batched-hydration-method                            [[:inner 0]]
-  metabase.models.interface/define-simple-hydration-method                             [[:inner 0]]
-  metabase.models.params.chain-filter-test/with-clean-field-values-for-field           [[:block 1]]
-  metabase.models.params.chain-filter-test/with-fk-field-to-field-remapping            [[:block 0]]
-  metabase.models.params.chain-filter-test/with-human-readable-values-remapping        [[:block 0]]
-  metabase.models.pulse-test/with-dashboard-subscription-in-collection                 [[:block 1]]
-  metabase.models.pulse-test/with-pulse-in-collection                                  [[:inner 0]]
-  metabase.models.setting/defsetting                                                   [[:block 1]]
-  metabase.models.setting.multi-setting/define-multi-setting                           [[:inner 0]]
-  metabase.models.task-history/with-task-history                                       [[:block 1]]
-  metabase.query-processor-test.pipeline-queries-test/pmbql-query                      [[:block 1]]
-  metabase.query-processor-test.pipeline-queries-test/run-pmbql-query                  [[:block 1]]
-  metabase.query-processor.debug/debug>                                                [[:block 0]]
-  metabase.query-processor.error-type/deferror                                         [[:block 1]]
-  metabase.query-processor.middleware.cache-backend.interface/with-cached-results      [[:block 4]]
-  metabase.query-processor.middleware.process-userland-query-test/with-query-execution [[:block 1]]
-  metabase.query-processor.store/cached                                                [[:block 1]]
-  metabase.query-processor.store/with-metadata-provider                                [[:inner 0]]
-  metabase.query-processor.streaming/streaming-response                                [[:block 1]]
-  metabase.query-processor.test-util/format-rows-by                                    [[:default]]
-  metabase.request.core/as-admin                                                       [[:block 0]]
-  metabase.request.core/with-current-request                                           [[:inner 0]]
-  metabase.request.core/with-current-user                                              [[:inner 0]]
-  metabase.request.core/with-limit-and-offset                                          [[:inner 0]]
-  metabase.request.session/as-admin                                                    [[:block 0]]
-  metabase.request.session/with-current-user                                           [[:inner 0]]
-  metabase.sample-data-test/with-temp-sample-database-db                               [[:block 1]]
-  metabase.server.middleware.session/as-admin                                          [[:block 0]]
-  metabase.server.middleware.session/with-current-user                                 [[:inner 0]]
-  metabase.sync.fetch-metadata/log-if-error                                            [[:block 1]]
-  metabase.sync.sync-metadata.fields-test/with-test-db                                 [[:block 0]]
-  metabase.sync.util/do-with-start-and-finish-debug-logging                            [[:default]]
-  metabase.sync.util/sum-for                                                           [[:block 1]]
-  metabase.sync.util/sync-operation                                                    [[:block 3]]
-  metabase.sync.util/with-db-logging-disabled                                          [[:default]]
-  metabase.sync.util/with-duplicate-ops-prevented                                      [[:default]]
-  metabase.sync.util/with-emoji-progress-bar                                           [[:block 1]]
-  metabase.sync.util/with-error-handling                                               [[:block 1]]
-  metabase.sync.util/with-start-and-finish-logging                                     [[:default]]
-  metabase.sync.util/with-start-and-finish-logging*                                    [[:default]]
-  metabase.sync.util/with-sync-events                                                  [[:default]]
-  metabase.test/$ids                                                                   [[:inner 0]]
-  metabase.test/as-admin                                                               [[:inner 0]]
-  metabase.test/dataset                                                                [[:inner 0]]
-  metabase.test/discard-setting-changes                                                [[:block 1]]
-  metabase.test/format-rows-by                                                         [[:default]]
-  metabase.test/let-url                                                                [[:block 1]]
-  metabase.test/mbql-query                                                             [[:inner 0]]
-  metabase.test/native-query                                                           [[:block 0]]
-  metabase.test/query                                                                  [[:block 1]]
-  metabase.test/run-mbql-query                                                         [[:inner 0]]
-  metabase.test/test-driver                                                            [[:inner 0]]
-  metabase.test/test-drivers                                                           [[:inner 0]]
-  metabase.test/test-helpers-set-global-values!                                        [[:block 0]]
-  metabase.test/throw-if-called!                                                       [[:block 1]]
-  metabase.test/with-actions                                                           [[:block 1]]
-  metabase.test/with-actions-disabled                                                  [[:block 0]]
-  metabase.test/with-actions-enabled                                                   [[:block 0]]
-  metabase.test/with-actions-test-data                                                 [[:inner 0]]
-  metabase.test/with-actions-test-data-and-actions-enabled                             [[:block 0]]
-  metabase.test/with-actions-test-data-tables                                          [[:block 1]]
-  metabase.test/with-additional-premium-features                                       [[:block 1]]
-  metabase.test/with-current-user                                                      [[:inner 0]]
-  metabase.test/with-driver                                                            [[:block 1]]
-  metabase.test/with-empty-db                                                          [[:inner 0]]
-  metabase.test/with-empty-h2-app-db                                                   [[:block 0]]
-  metabase.test/with-metadata-provider                                                 [[:inner 0]]
-  metabase.test/with-premium-features                                                  [[:block 1]]
-  metabase.test/with-temp                                                              [[:inner 0]]
-  metabase.test/with-temp-copy-of-db                                                   [[:block 0]]
-  metabase.test/with-temp-scheduler                                                    [[:block 0]]
-  metabase.test/with-temp-test-data                                                    [[:inner 0]]
-  metabase.test/with-temp-vals-in-db                                                   [[:block 3]]
-  metabase.test/with-test-user                                                         [[:inner 0]]
-  metabase.test/with-user-in-groups                                                    [[:inner 0]]
-  metabase.test.data/$ids                                                              [[:inner 0]]
-  metabase.test.data/dataset                                                           [[:inner 0]]
-  metabase.test.data/mbql-query                                                        [[:inner 0]]
-  metabase.test.data/native-query                                                      [[:block 0]]
-  metabase.test.data/query                                                             [[:block 1]]
-  metabase.test.data/run-mbql-query                                                    [[:inner 0]]
-  metabase.test.data/with-empty-h2-app-db                                              [[:block 0]]
-  metabase.test.data/with-temp-copy-of-db                                              [[:block 0]]
-  metabase.test.data.datasets/test-driver                                              [[:inner 0]]
-  metabase.test.data.datasets/test-drivers                                             [[:inner 0]]
-  metabase.test.data.one-off-dbs/with-blank-db                                         [[:block 0]]
-  metabase.test.data.one-off-dbs/with-blueberries-db                                   [[:block 0]]
-  metabase.test.data.users/with-test-user                                              [[:inner 0]]
-  metabase.test.util/discard-setting-changes                                           [[:block 1]]
-  metabase.test.util/let-url                                                           [[:block 1]]
-  metabase.test.util/throw-if-called!                                                  [[:block 1]]
-  metabase.test.util/with-temp-scheduler                                               [[:block 0]]
-  metabase.test.util/with-temp-vals-in-db                                              [[:block 3]]
-  metabase.test.util/with-user-in-groups                                               [[:inner 0]]
-  metabase.test.util.public-settings/with-additional-premium-features                  [[:block 1]]
-  metabase.test.util.public-settings/with-premium-features                             [[:block 1]]
-  metabase.test.util.thread-local/test-helpers-set-global-values!                      [[:block 0]]
-  metabase.timeseries-query-processor-test.util/test-timeseries-drivers                [[:block 0]]
-  metabase.timeseries-query-processor-test/run-mbql-query                              [[:inner 0]]
-  metabase.upload-test/with-upload-table!                                              [[:inner 0]]
-  metabase.upload.types/with-currency                                                  [[:default]]
-  metabase.upload.types/with-parens                                                    [[:default]]
-  metabase.util/auto-retry                                                             [[:block 1]]
-  metabase.util/case-enum                                                              [[:block 1]]
-  metabase.util/ignore-exceptions                                                      [[:block 0]]
-  metabase.util/or-with                                                                [[:block 1]]
-  metabase.util/profile                                                                [[:block 1]]
-  metabase.util/prog1                                                                  [[:inner 0]]
-  metabase.util/varargs                                                                [[:inner 0]]
-  metabase.util/with-us-locale                                                         [[:block 0]]
-  metabase.util.date-2/with-time-zone-same-instant                                     [[:default]]
-  metabase.util.encryption-test/with-secret-key                                        [[:block 1]]
-  metabase.util.honey-sql-2/with-database-type-info                                    [[:default]]
-  metabase.util.i18n/deferred-trs                                                      [[:default]]
-  metabase.util.i18n/deferred-tru                                                      [[:default]]
-  metabase.util.i18n/trs                                                               [[:default]]
-  metabase.util.i18n/trsn                                                              [[:default]]
-  metabase.util.i18n/tru                                                               [[:default]]
-  metabase.util.i18n/trun                                                              [[:default]]
-  metabase.util.jvm/auto-retry                                                         [[:block 1]]
-  metabase.util.jvm/varargs                                                            [[:block 1]]
-  metabase.util.jvm/with-us-locale                                                     [[:block 0]]
-  metabase.util.malli/disable-enforcement                                              [[:block 0]]
-  metabase.util.malli/with                                                             [[:default]]
-  metabase.util.malli/with-api-error-message                                           [[:default]]
-  metabase.util.namespaces/import-fns                                                  [[:default]]
-  metabuild-common.core/exit-when-finished-nonzero-on-exception                        [[:block 0]]
-  metabuild-common.core/step                                                           [[:block 1]]
-  metabuild-common.entrypoint/exit-when-finished-nonzero-on-exception                  [[:block 0]]
-  metabuild-common.steps/step                                                          [[:block 1]]
-  methodical.core/defmethod                                                            [[:inner 0]]
-  methodical.core/defmulti                                                             [[:inner 0]]
-  methodical.core/with-dispatcher                                                      [[:default]]
-  methodical.core/with-method-table                                                    [[:default]]
-  methodical.core/with-prefers                                                         [[:default]]
-  methodical.interface/with-dispatcher                                                 [[:default]]
-  methodical.interface/with-method-table                                               [[:default]]
-  methodical.interface/with-prefers                                                    [[:default]]
-  methodical.macros/defmethod                                                          [[:inner 0]]
-  methodical.macros/defmulti                                                           [[:inner 0]]
-  saml20-clj.sp.response/validate-confirmation-datas                                   [[:block 1]]
-  toucan2.connection/with-transaction                                                  [[:block 1]]
-  toucan2.core/build                                                                   [[:block 0]]
-  toucan2.core/compile                                                                 [[:block 0]]
-  toucan2.core/debug                                                                   [[:block 0]]
-  toucan2.core/define-after-insert                                                     [[:inner 0]]
-  toucan2.core/define-after-select                                                     [[:inner 0]]
-  toucan2.core/define-after-update                                                     [[:inner 0]]
-  toucan2.core/define-before-delete                                                    [[:inner 0]]
-  toucan2.core/define-before-insert                                                    [[:inner 0]]
-  toucan2.core/define-before-select                                                    [[:inner 0]]
-  toucan2.core/define-default-fields                                                   [[:inner 0]]
-  toucan2.core/define-named-query                                                      [[:block 1]]
-  toucan2.core/deftransforms                                                           [[:block 1]]
-  toucan2.core/with-transaction                                                        [[:block 1]]
-  toucan2.tools.after/define-after-impl                                                [[:default]]
-  toucan2.tools.after-insert/define-after-insert                                       [[:inner 0]]
-  toucan2.tools.after-select/define-after-select                                       [[:inner 0]]
-  toucan2.tools.after-update/define-after-update                                       [[:inner 0]]
-  toucan2.tools.before-delete/define-before-delete                                     [[:inner 0]]
-  toucan2.tools.before-insert/define-before-insert                                     [[:inner 0]]
-  toucan2.tools.before-select/define-before-select                                     [[:inner 0]]
-  toucan2.tools.compile/build                                                          [[:block 0]]
-  toucan2.tools.compile/compile                                                        [[:block 0]]
-  toucan2.tools.compile/resolved                                                       [[:block 0]]
-  toucan2.tools.debug/debug                                                            [[:block 0]]
-  toucan2.tools.default-fields/define-default-fields                                   [[:inner 0]]
-  toucan2.tools.named-query/define-named-query                                         [[:block 1]]
-  toucan2.tools.simple-out-transform/define-out-transform                              [[:inner 0]]
-  toucan2.tools.transformed/deftransforms                                              [[:block 1]]
-  toucan2.tools.with-temp/with-temp                                                    [[:inner 0]]
-  toucan2.util/try-with-error-context                                                  [[:inner 0]]}}

.cljfmt/indents.clj

@@ -0,0 +1,2 @@
+{metabase.api.collection/foo [[:inner 0]]
+ toucan.db/insert!           [[:block 1]]}

.devcontainer/Dockerfile

@@ -2,10 +2,10 @@ FROM mcr.microsoft.com/vscode/devcontainers/java:11
 
 # Set up nodesource, install node, yarn, fontconfig for static viz, rlwrap for dev ergonomics
 
-RUN ( curl -fsSL https://deb.nodesource.com/setup_18.x | bash ) \
+RUN ( curl -fsSL https://deb.nodesource.com/setup_14.x | bash ) \
   && export DEBIAN_FRONTEND=noninteractive \
   && apt-key adv --refresh-keys --keyserver keyserver.ubuntu.com \
   && apt-get update && apt-get -y install --no-install-recommends nodejs yarn rlwrap fontconfig
 
 # install Clojure
-RUN curl https://download.clojure.org/install/linux-install-1.11.1.1262.sh | bash
+RUN curl https://download.clojure.org/install/linux-install-1.11.0.1100.sh | bash

.dir-locals.el

@@ -6,7 +6,6 @@
   ;; prefer keeping source width about ~118, GitHub seems to cut off stuff at either 119 or 120 and it's nicer
   ;; to look at code in GH when you don't have to scroll back and forth
   (fill-column . 118)
-  (whitespace-line-column . 118)
   ;; tell find-things-fast to always use this directory as project root regardless of presence of other
   ;; deps.edn files
   (ftf-project-finders . (ftf-get-top-git-dir)))
@@ -20,76 +19,76 @@
  (clojure-mode
   ;; Specify which arg is the docstring for certain macros
   ;; (Add more as needed)
-  (eval . (put 'defendpoint-schema                 'clojure-doc-string-elt 3))
-  (eval . (put 'defendpoint                        'clojure-doc-string-elt 3))
-  (eval . (put 'defendpoint-async                  'clojure-doc-string-elt 3))
-  (eval . (put 'define-premium-feature             'clojure-doc-string-elt 2))
-  (eval . (put 'api/defendpoint-schema             'clojure-doc-string-elt 3))
-  (eval . (put 'api/defendpoint                    'clojure-doc-string-elt 3))
-  (eval . (put 'api/defendpoint-async              'clojure-doc-string-elt 3))
-  (eval . (put 'defsetting                         'clojure-doc-string-elt 2))
-  (eval . (put 'setting/defsetting                 'clojure-doc-string-elt 2))
-  (eval . (put 's/defn                             'clojure-doc-string-elt 2))
-  (eval . (put 'p.types/defprotocol+               'clojure-doc-string-elt 2))
-  (eval . (put 'methodical/defmethod               'clojure-doc-string-elt 3))
-  (eval . (put 'methodical/defmulti                'clojure-doc-string-elt 2))
-  (eval . (put 'mi/define-simple-hydration-method  'clojure-doc-string-elt 3))
+  (eval . (put 'defendpoint-schema 'clojure-doc-string-elt 3))
+  (eval . (put 'defendpoint 'clojure-doc-string-elt 3))
+  (eval . (put 'defendpoint-async 'clojure-doc-string-elt 3))
+  (eval . (put 'define-premium-feature 'clojure-doc-string-elt 2))
+  (eval . (put 'api/defendpoint-schema 'clojure-doc-string-elt 3))
+  (eval . (put 'api/defendpoint 'clojure-doc-string-elt 3))
+  (eval . (put 'api/defendpoint-async 'clojure-doc-string-elt 3))
+  (eval . (put 'defsetting 'clojure-doc-string-elt 2))
+  (eval . (put 'setting/defsetting 'clojure-doc-string-elt 2))
+  (eval . (put 's/defn 'clojure-doc-string-elt 2))
+  (eval . (put 'p.types/defprotocol+ 'clojure-doc-string-elt 2))
+  (eval . (put 'methodical/defmethod 'clojure-doc-string-elt 3))
+  (eval . (put 'methodical/defmulti 'clojure-doc-string-elt 2))
+  (eval . (put 'mi/define-simple-hydration-method 'clojure-doc-string-elt 3))
   (eval . (put 'mi/define-batched-hydration-method 'clojure-doc-string-elt 3))
-  (eval . (put 'mr/def                             'clojure-doc-string-elt 2))
-  (eval . (put 'mu/defn                            'clojure-doc-string-elt 2))
+  (eval . (put 'mu/defn 'clojure-doc-string-elt 2))
   ;; Define custom indentation for functions inside metabase.
   ;; This list isn't complete; add more forms as we come across them.
   ;;
   ;; `put-clojure-indent' is a safe-local-eval-function, so use a bunch of calls to that
   ;; instead of one call to `define-clojure-indent'
-  (eval . (put-clojure-indent 'api/let-404                     1))
-  (eval . (put-clojure-indent 'c/step                          1))
-  (eval . (put-clojure-indent 'impl/test-migrations            2))
-  (eval . (put-clojure-indent 'let-404                         0))
-  (eval . (put-clojure-indent 'lib.schema.match/match          '(:defn)))
-  (eval . (put-clojure-indent 'lib.schema.match/match-one      '(:defn)))
-  (eval . (put-clojure-indent 'lib.schema.match/replace        '(:defn)))
-  (eval . (put-clojure-indent 'lib.schema.match/replace-in     '(:defn)))
-  (eval . (put-clojure-indent 'lib.util.match/replace          '(:defn)))
-  (eval . (put-clojure-indent 'macros/case                     0))
-  (eval . (put-clojure-indent 'match                           1))
-  (eval . (put-clojure-indent 'mt/dataset                      1))
-  (eval . (put-clojure-indent 'mt/format-rows-by               '(:form)))
-  (eval . (put-clojure-indent 'mt/query                        1))
-  (eval . (put-clojure-indent 'mt/test-driver                  1))
-  (eval . (put-clojure-indent 'mt/test-drivers                 1))
-  (eval . (put-clojure-indent 'mt/with-anaphora                1))
-  (eval . (put-clojure-indent 'prop/for-all                    1))
+  (eval . (put-clojure-indent 'api/let-404 1))
+  (eval . (put-clojure-indent 'c/step 1))
+  (eval . (put-clojure-indent 'impl/test-migrations 2))
+  (eval . (put-clojure-indent 'let-404 0))
+  (eval . (put-clojure-indent 'macros/case 0))
+  (eval . (put-clojure-indent 'match 1))
+  (eval . (put-clojure-indent 'mbql.match/match 1))
+  (eval . (put-clojure-indent 'mbql.match/match-one 1))
+  (eval . (put-clojure-indent 'mbql.match/replace 1))
+  (eval . (put-clojure-indent 'mbql.match/replace-in 2))
+  (eval . (put-clojure-indent 'mbql.u/replace 1))
+  (eval . (put-clojure-indent 'mi/define-methods '(:form)))
+  (eval . (put-clojure-indent 'mt/dataset 1))
+  (eval . (put-clojure-indent 'mt/format-rows-by 1))
+  (eval . (put-clojure-indent 'mt/query 1))
+  (eval . (put-clojure-indent 'mt/test-drivers 1))
+  (eval . (put-clojure-indent 'mt/test-driver 1))
+  (eval . (put-clojure-indent 'prop/for-all 1))
   (eval . (put-clojure-indent 'qp.streaming/streaming-response 1))
-  (eval . (put-clojure-indent 'tc/quick-check                  1))
-  (eval . (put-clojure-indent 'u/profile                       1))
-  (eval . (put-clojure-indent 'u/prog1                         1))
-  (eval . (put-clojure-indent 'u/select-keys-when              '(:form)))
-  (eval . (put-clojure-indent 'with-meta                       '(:form)))
+  (eval . (put-clojure-indent 'u/prog1 1))
+  (eval . (put-clojure-indent 'u/select-keys-when 1))
+  (eval . (put-clojure-indent 'with-meta '(:form)))
+  (eval . (put-clojure-indent 'tc/quick-check 1))
   ;; these ones have to be done with `define-clojure-indent' for now because of upstream bug
   ;; https://github.com/clojure-emacs/clojure-mode/issues/600 once that's resolved we should use `put-clojure-indent'
   ;; instead. Please don't add new entries unless they don't work with `put-clojure-indent'
   (eval . (define-clojure-indent
-           (l/matcha                  '(1 (:defn)))
-           (l/matche                  '(1 (:defn)))
+           (l/matcha '(1 (:defn)))
+           (l/matche '(1 (:defn)))
            (p.types/def-abstract-type '(1 (:defn)))
-           (p.types/defprotocol+      '(1 (:defn)))
-           (p.types/defrecord+        '(2 nil nil (:defn)))
-           (p.types/deftype+          '(2 nil nil (:defn)))
-           (p/def-map-type            '(2 nil nil (:defn)))
-           (p/defprotocol+            '(1 (:defn)))
-           (p/defrecord+              '(2 nil nil (:defn)))
-           (p/deftype+                '(2 nil nil (:defn)))
-           (tools.macro/macrolet      '(1 ((:defn)) :form))))
+           (p.types/defprotocol+ '(1 (:defn)))
+           (p.types/defrecord+ '(2 nil nil (:defn)))
+           (p.types/deftype+ '(2 nil nil (:defn)))
+           (p/def-map-type '(2 nil nil (:defn)))
+           (p/defprotocol+ '(1 (:defn)))
+           (p/defrecord+ '(2 nil nil (:defn)))
+           (p/deftype+ '(2 nil nil (:defn)))
+           (tools.macro/macrolet '(1 ((:defn)) :form))))
   (cider-clojure-cli-aliases . "dev:drivers:drivers-dev:ee:ee-dev:user")
   (clojure-indent-style . always-align)
   (cljr-favor-prefix-notation . nil)
-  (cljr-insert-newline-after-require . t)
-  (cljr-print-right-margin . 118)
   (clojure-docstring-fill-column . 118)
   (cider-preferred-build-tool . clojure-cli)
   (cider-default-cljs-repl . shadow-select)
-  (cider-shadow-default-options . "app"))
+  (cider-shadow-default-options . "node-repl"))
+
+ ("shared"
+  (clojure-mode
+   (cider-preferred-build-tool . shadow-cljs)))
 
  ("bin"
   (clojure-mode

.eslintignore

@@ -1,4 +1 @@
 frontend/src/cljs
-frontend/src/cljs_release
-e2e/support/cypress_sample_database.js
-e2e/support/cypress_sample_instance_data.js

.eslintrc

@@ -0,0 +1,161 @@
+{
+  "rules": {
+    "strict": [2, "never"],
+    "no-undef": 2,
+    "no-var": 1,
+    "no-unused-vars": [
+      "error",
+      {
+        "vars": "all",
+        "args": "none",
+        "varsIgnorePattern": "^_.+",
+        "ignoreRestSiblings": true
+      }
+    ],
+    "no-empty": [1, { "allowEmptyCatch": true }],
+    "curly": [1, "all"],
+    "eqeqeq": [1, "smart"],
+    "import/no-default-export": 2,
+    "import/no-commonjs": 1,
+    "import/order": [
+      "error",
+      {
+        "pathGroups": [
+          {
+            "pattern": "react",
+            "group": "builtin",
+            "position": "before"
+          },
+          {
+            "pattern": "metabase/**",
+            "group": "internal"
+          },
+          {
+            "pattern": "metabase/**/components",
+            "group": "internal",
+            "position": "before"
+          },
+          {
+            "pattern": "__**",
+            "group": "internal",
+            "position": "before"
+          },
+          {
+            "pattern": "metabase-lib/**",
+            "group": "internal",
+            "position": "after"
+          }
+        ],
+        "groups": [
+          "builtin",
+          "external",
+          "internal",
+          "parent",
+          "sibling",
+          "index",
+          "object"
+        ]
+      }
+    ],
+    "no-console": [2, {"allow": ["warn", "error"]}],
+    "react/no-is-mounted": 2,
+    "react/prefer-es6-class": 2,
+    "react/display-name": 1,
+    "react/prop-types": 2,
+    "react/no-did-mount-set-state": 0,
+    "react/no-did-update-set-state": 0,
+    "react/no-find-dom-node": 0,
+    "react/no-children-prop": 2,
+    "react/no-string-refs": 2,
+    "react/no-unescaped-entities": 2,
+    "react/jsx-no-target-blank": 2,
+    "react/jsx-key": 2,
+    "react/forbid-component-props": [2, { "forbid": ["w", "h"] }],
+    "react-hooks/exhaustive-deps": [
+      "warn",
+      { "additionalHooks": "(useSyncedQueryString|useSafeAsyncFunction)" }
+    ],
+    "prefer-const": [1, { "destructuring": "all" }],
+    "no-useless-escape": 0,
+    "no-only-tests/no-only-tests": "error",
+    "complexity": ["error", { "max": 54 }]
+  },
+  "globals": {
+    "before": true,
+    "cy": true,
+    "Cypress": true
+  },
+  "env": {
+    "browser": true,
+    "es6": true,
+    "commonjs": true,
+    "jest": true,
+    "jest/globals": true
+  },
+  "parser": "babel-eslint",
+  "plugins": ["react", "no-only-tests"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:react/recommended",
+    "plugin:react/jsx-runtime",
+    "plugin:react-hooks/recommended",
+    "plugin:import/errors",
+    "plugin:import/warnings"
+  ],
+  "settings": {
+    "import/internal-regex": "^metabase/|^metabase-lib/",
+    "import/resolver": "webpack",
+    "import/ignore": ["\\.css$"],
+    "react": {
+      "version": "detect"
+    }
+  },
+  "parserOptions": {
+    "ecmaFeatures": {
+      "legacyDecorators": true
+    }
+  },
+  "overrides": [
+    {
+      "extends": ["plugin:@typescript-eslint/recommended"],
+      "files": ["*.ts", "*.tsx"],
+      "parser": "@typescript-eslint/parser",
+      "plugins": ["@typescript-eslint"],
+      "rules": {
+        "prefer-rest-params": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/no-inferrable-types": "off",
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-this-alias": "off",
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          {
+            "vars": "all",
+            "args": "none",
+            "varsIgnorePattern": "^_.+",
+            "ignoreRestSiblings": true,
+            "destructuredArrayIgnorePattern": "^_"
+          }
+        ]
+      }
+    },
+    {
+      "extends": [
+        "plugin:jest/recommended",
+        "plugin:jest-dom/recommended",
+        "plugin:testing-library/react"
+      ],
+      "plugins": ["jest", "jest-dom", "testing-library"],
+      "files": [
+        "*.unit.spec.ts",
+        "*.unit.spec.tsx",
+        "*.unit.spec.js",
+        "*.unit.spec.jsx"
+      ],
+      "rules": {
+        "jest/valid-title": ["error", { "ignoreTypeOfDescribeName": true }]
+      }
+    }
+  ]
+}

.eslintrc.js

@@ -1,288 +0,0 @@
-/* eslint-disable import/no-commonjs */
-/* eslint-disable no-undef */
-
-// `postcss-modules` lints css modules class names, but it currently crashes
-// eslint on vscode. If you use webstorm or want to run the lint for the cli, you
-// can use this flag to enable it. This is set to true in CI
-const shouldLintCssModules =
-  process.env.LINT_CSS_MODULES === "true" || process.env.CI;
-
-module.exports = {
-  rules: {
-    strict: [2, "never"],
-    "no-undef": 2,
-    "no-var": 1,
-    "no-unused-vars": [
-      "error",
-      {
-        vars: "all",
-        args: "none",
-        varsIgnorePattern: "^_",
-        ignoreRestSiblings: true,
-      },
-    ],
-    "no-empty": [1, { allowEmptyCatch: true }],
-    "no-restricted-imports": [
-      "error",
-      {
-        paths: [
-          {
-            name: "moment",
-            message: "Moment is deprecated, please use dayjs",
-          },
-          {
-            name: "moment-timezone",
-            message: "Moment is deprecated, please use dayjs",
-          },
-        ],
-      },
-    ],
-    curly: [1, "all"],
-    eqeqeq: [1, "smart"],
-    "import/no-default-export": 2,
-    "import/no-named-as-default": 0,
-    "import/no-commonjs": 1,
-    "import/order": [
-      "error",
-      {
-        "newlines-between": "always",
-        alphabetize: {
-          order: "asc",
-          orderImportKind: "asc",
-          caseInsensitive: false,
-        },
-        groups: [
-          "builtin",
-          "external",
-          "internal",
-          "parent",
-          "sibling",
-          "index",
-        ],
-        warnOnUnassignedImports: false,
-      },
-    ],
-    "sort-imports": [
-      "error",
-      {
-        // allows this rule to work with import/order
-        ignoreDeclarationSort: true,
-      },
-    ],
-    "no-console": [2, { allow: ["warn", "error", "errorBuffer"] }],
-    "react/no-is-mounted": 2,
-    "react/prefer-es6-class": 2,
-    "react/display-name": 1,
-    "react/prop-types": 2,
-    "react/no-did-mount-set-state": 0,
-    "react/no-did-update-set-state": 0,
-    "react/no-find-dom-node": 0,
-    "react/no-children-prop": 2,
-    "react/no-string-refs": 2,
-    "react/no-unescaped-entities": 2,
-    "react/jsx-no-target-blank": 2,
-    "react/jsx-key": 2,
-    "react/forbid-component-props": [2, { forbid: ["sx"] }],
-    "react-hooks/exhaustive-deps": [
-      "warn",
-      { additionalHooks: "(useSafeAsyncFunction)" },
-    ],
-    "prefer-const": [1, { destructuring: "all" }],
-    "no-restricted-globals": ["error", "close"],
-    "no-useless-escape": 0,
-    "no-only-tests/no-only-tests": [
-      "error",
-      {
-        block: [
-          "describe",
-          "it",
-          "context",
-          "test",
-          "tape",
-          "fixture",
-          "serial",
-          "Feature",
-          "Scenario",
-          "Given",
-          "And",
-          "When",
-          "Then",
-          "describeWithSnowplow",
-          "describeEE",
-        ],
-      },
-    ],
-    complexity: ["error", { max: 54 }],
-    ...(shouldLintCssModules
-      ? {
-          "postcss-modules/no-undef-class": "error",
-        }
-      : {}),
-  },
-  globals: {
-    before: true,
-    cy: true,
-    Cypress: true,
-  },
-  env: {
-    browser: true,
-    es6: true,
-    commonjs: true,
-    jest: true,
-    "jest/globals": true,
-  },
-  parser: "babel-eslint",
-  plugins: ["react", "no-only-tests", "postcss-modules"],
-  extends: [
-    "eslint:recommended",
-    "plugin:react/recommended",
-    "plugin:react/jsx-runtime",
-    "plugin:react-hooks/recommended",
-    "plugin:import/errors",
-    "plugin:import/warnings",
-    "plugin:import/typescript",
-    "plugin:depend/recommended",
-    "plugin:storybook/recommended",
-  ],
-  settings: {
-    "import/internal-regex": "^metabase/|^metabase-lib/",
-    "import/resolver": {
-      webpack: {
-        typescript: true,
-      },
-    },
-    "import/ignore": ["\\.css$"],
-    react: {
-      version: "detect",
-    },
-    "postcss-modules": {
-      baseDir: "./frontend/src",
-    },
-  },
-  parserOptions: {
-    ecmaFeatures: {
-      legacyDecorators: true,
-    },
-  },
-  overrides: [
-    {
-      files: ["*.js", "*.jsx", "*.ts", "*.tsx"],
-      rules: {
-        "no-unconditional-metabase-links-render": "error",
-        "no-literal-metabase-strings": "error",
-        "depend/ban-dependencies": [
-          "error",
-          {
-            allowed: [
-              "underscore",
-              "moment",
-              "lodash.orderby",
-              "lodash.debounce",
-            ],
-          },
-        ],
-      },
-    },
-    {
-      files: [
-        "*.unit.spec.*",
-        "frontend/src/metabase/admin/**/*",
-        "frontend/src/metabase/setup/**/*",
-        "frontend/lint/**/*",
-        "*.stories.*",
-        "e2e/**/*",
-        "**/tests/*",
-        "release/**/*",
-      ],
-      rules: {
-        "no-unconditional-metabase-links-render": "off",
-        "no-literal-metabase-strings": "off",
-      },
-    },
-    {
-      extends: ["plugin:@typescript-eslint/recommended"],
-      files: ["*.ts", "*.tsx"],
-      parser: "@typescript-eslint/parser",
-      plugins: ["@typescript-eslint"],
-      rules: {
-        "prefer-rest-params": "off",
-        "@typescript-eslint/explicit-module-boundary-types": "off",
-        "@typescript-eslint/no-inferrable-types": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-this-alias": "off",
-        "@typescript-eslint/consistent-type-imports": [
-          "error",
-          {
-            fixStyle: "inline-type-imports",
-          },
-        ],
-        "@typescript-eslint/no-import-type-side-effects": "error",
-        "@typescript-eslint/no-unused-vars": [
-          "error",
-          {
-            argsIgnorePattern: "^_",
-            varsIgnorePattern: "^_",
-            ignoreRestSiblings: true,
-            destructuredArrayIgnorePattern: "^_",
-          },
-        ],
-        // This was introduced in 6.0.0
-        "@typescript-eslint/no-unsafe-declaration-merging": "off",
-      },
-    },
-    {
-      extends: [
-        "plugin:jest/recommended",
-        "plugin:jest-dom/recommended",
-        "plugin:testing-library/react",
-        "plugin:jest-formatting/recommended",
-      ],
-      plugins: ["jest", "jest-dom", "testing-library", "jest-formatting"],
-      files: [
-        "*.unit.spec.ts",
-        "*.unit.spec.tsx",
-        "*.unit.spec.js",
-        "*.unit.spec.jsx",
-      ],
-      rules: {
-        "jest/valid-title": ["error", { ignoreTypeOfDescribeName: true }],
-      },
-    },
-    {
-      // Enable jest formatting for cypress tests too, the plugin logic just works
-      extends: ["plugin:jest-formatting/recommended"],
-      files: ["*.cy.spec.ts", "*.cy.spec.js"],
-    },
-    {
-      files: ["frontend/src/**/*"],
-      rules: {
-        "no-restricted-syntax": [
-          "error",
-          {
-            selector: "Literal[value=/mb-base-color-/]",
-            message:
-              "You may not use base colors in the application, use semantic colors instead. (see colors.module.css)",
-          },
-        ],
-      },
-    },
-    {
-      files: ["frontend/src/metabase/**/*"],
-      rules: {
-        "no-restricted-syntax": [
-          "error",
-          {
-            selector: "Literal[value=/mb-base-color-/]",
-            message:
-              "You may not use base colors in the application, use semantic colors instead. (see colors.module.css)",
-          },
-          {
-            selector:
-              "CallExpression[callee.property.name='legacyQuery'] > ObjectExpression > Property[key.name='useStructuredQuery'][value.value=true]",
-            message: "StructuredQuery usage is forbidden. Use MLv2",
-          },
-        ],
-      },
-    },
-  ],
-};

.github/CODEOWNERS

@@ -1,12 +0,0 @@
-# Before changing this file, make sure you have read how we use it:
-# https://www.notion.so/metabase/Pull-Request-Code-Review-Guide-374f05df889748b69d67af753f9bc9b8?pvs=4#36550c04ceab40b5a8b8bee6264b090c
-
-enterprise/backend/src/metabase_enterprise/advanced_permissions @noahmoss
-enterprise/backend/src/metabase_enterprise/audit_app @noahmoss
-enterprise/backend/src/metabase_enterprise/sso @noahmoss
-enterprise/backend/src/metabase_enterprise/task/truncate_audit_table.clj @noahmoss
-enterprise/backend/src/metabase_enterprise/internal_user.clj @noahmoss
-frontend/src/metabase/ui @metabase/core-frontend-admin-webapp
-src/metabase/**/*permissions* @noahmoss
-src/metabase/integrations @noahmoss
-snowplow/* @metabase/data

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -38,7 +38,7 @@ body:
     validations:
       required: true
 
-  - type: textarea
+  - type: input
     id: expected-behavior
     attributes:
       label: Expected behavior
@@ -66,13 +66,12 @@ body:
         Copy and paste the JSON from `Admin -> Troubleshooting`.
         _This will be automatically formatted into code, so no need for backticks._
       placeholder: |
-        {"browser-info": {
-           "language": "en-US",
-           "platform": "MacIntel",
-           "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-           "vendor": "Google Inc."},
-         "metabase-info": {
-           "databases": [ "postgres",...
+        - Your browser and the version: (e.g., Chrome 52.1, Firefox 48.0, Safari 11.1, …)
+        - Your operating system: (e.g., OS X 10.10, Windows 10.1809, Ubuntu 16.04, …)
+        - Your databases: (e.g, MySQL, Postgres, MongoDB, …)
+        - Metabase version: (e.g., 0.19.3)
+        - Metabase hosting environment: (e.g., Elastic Beanstalk, Docker, Heroku, Jar-file on Ubuntu, …)
+        - Metabase internal database: (e.g., H2 (default), Postgres or MySQL)
       render: JSON
     validations:
       required: true
@@ -83,6 +82,7 @@ body:
       label: Severity
       description: |
         How severe an issue is this bug to you? Is this annoying, blocking some users, blocking an upgrade or blocking your usage of Metabase entirely?
+        _Note: the more honest and specific you are here the more we will take you seriously._
     validations:
       required: true
 

.github/ISSUE_TEMPLATE/epic.md

@@ -1,23 +0,0 @@
----
-name: Epic (Internal Use)
-about: This issue is used to track a feature/project that may span several days
-  to weeks to implement. This is used by the core Metabase team to project plan
-  and manage work.
-title: "[Epic] Title"
-labels: ".Epic"
----
-
-### Links
-
-- [product doc](LINK_TO_PRODUCT_DOC)
-- [technical design doc](LINK_TO_TECHNICAL_DESIGN_DOC)
-- [testing plan](LINK_TO_TESTING_PLAN)
-- feature branch: `BRANCH_NAME`
-- issue links: _related issues, if any_
-
-### Implementation Plan
-
-```[tasklist]
-#### Milestone 1
-- [ ] _Add tasks here_
-```