Merge pull request #7 from decode-development/sync/upstream-2026-06-08

Sync upstream v0.61.3 (merge conflicts)

Author: trevorgowing

.clj-kondo/config.edn

@@ -177,6 +177,7 @@
      clojure.core.async/take!
      clojure.core.async/to-chan!
      clojure.core.async/to-chan!!
+     metabase.api.macros.defendpoint.tools-manifest/assert-optional-fields-nullable!
      metabase.channel.core/send!
      metabase.warehouses.models.database/assert-not-h2!
      metabase.driver.sql-jdbc.execute/execute-prepared-statement!

.clj-kondo/config/modules/config.edn

@@ -322,7 +322,8 @@
    :api  #{metabase.app-db.cluster-lock ; TODO FIXME
            metabase.app-db.core
            metabase.app-db.init
-           metabase.app-db.setup}
+           metabase.app-db.setup
+           metabase.app-db.transient-error}
    :uses #{auth-provider
            classloader
            config
@@ -1679,7 +1680,6 @@
                     :model/NativeQuerySnippet
                     :model/Notification
                     :model/Revision
-                    :model/Table
                     :model/User}}
 
   queries-rest
@@ -1928,6 +1928,7 @@
   {:team "UX West"
    :api  #{metabase.server.core
            metabase.server.init
+           metabase.server.middleware.security
            metabase.server.middleware.session
            metabase.server.settings
            metabase.server.streaming-response} ; TODO -- too many API namespaces
@@ -3241,6 +3242,7 @@
    :api  #{metabase-enterprise.security-center.api
            metabase-enterprise.security-center.init}
    :uses #{analytics
+           analytics-interface
            api
            app-db
            channel

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

@@ -500,8 +500,8 @@
               (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.
+              ;; 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.

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

@@ -28,8 +28,8 @@
                                             (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.
+                                                       ;; 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))))

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

@@ -13,23 +13,23 @@
       (let [c (first chars)]
         (if (= c \')
           (cond
-              ;; Doubled quotes: skip both
+            ;; Doubled quotes: skip both
             (and (next chars) (= (second chars) \'))
             (recur (nthrest chars 2))
 
-              ;; Placeholder escape. We allow for intentional escaping, like either '{0}` or '{{`, but not 'arbitrary
-              ;; strings' So basically, just require the *next* character to be a `{`, find the next single-quote, and
-              ;; continue on from there.
-              ;;
-              ;; Technically a string like "foo bar's happy but i'm not" is totally fine, but we'll say it's invalid
-              ;; because... that inner string literal is probably not what we actually want. So since we've never done
-              ;; this intentionally as far as I can tell, let's just remove the possibility to avoid ambiguity.
+            ;; Placeholder escape. We allow for intentional escaping, like either '{0}` or '{{`, but not 'arbitrary
+            ;; strings' So basically, just require the *next* character to be a `{`, find the next single-quote, and
+            ;; continue on from there.
+            ;;
+            ;; Technically a string like "foo bar's happy but i'm not" is totally fine, but we'll say it's invalid
+            ;; because... that inner string literal is probably not what we actually want. So since we've never done
+            ;; this intentionally as far as I can tell, let's just remove the possibility to avoid ambiguity.
             (= (second chars) \{)
             (let [at-closing (drop-while #(not= \' %) (next chars))]
               (if (seq at-closing)
                 (recur (next at-closing))
                 false))
-              ;; Unpaired single quote: invalid
+            ;; Unpaired single quote: invalid
             :else
             false)
           (recur (rest chars)))))))

.cljfmt.edn

@@ -1,12 +1,10 @@
 ;; Cljfmt config. See https://github.com/weavejester/cljfmt#formatting-options
-{:sort-ns-references?
- true
-
- :function-arguments-indentation
- :community
-
- :parallel?
- true
+{:function-arguments-indentation  :community
+ :indent-line-comments?           true
+ :normalize-newlines-at-file-end? true
+ :parallel?                       true
+ :remove-blank-lines-in-forms?    true
+ :sort-ns-references?             true
 
  :paths
  ["src"
@@ -15,11 +13,63 @@
   "bin/build"
   "bin/lint-migrations-file"
   "bin/release-list"
+  #_"mage/src"
+  #_"mage/test"
   "modules/drivers"
   ".clj-kondo/src"
   ".clj-kondo/test"
   #_"dev"]
 
+ ;; a map of symbols that tell cljfmt which forms are allowed to have blank lines inside of them. The value may be
+ ;; either `:all`, which means blank lines are allowed between all elements in the form, e.g. `{cond :all}` to allow
+ ;; blank lines between any of the elements inside cond; or it may be a set of element indexes that are allowed to
+ ;; have blank lines, e.g. `{let #{0}}`, to allow blank lines in the binding of a `let` form.
+ :extra-blank-line-forms
+ {are                                                                    :all
+  case                                                                   :all
+  cond->                                                                 :all
+  cond->>                                                                :all
+  condp                                                                  :all
+  clojure.spec.alpha/or                                                  :all
+  clojure.test/are                                                       :all
+  metabase.driver-api.core/match-many                                    :all
+  metabase.driver-api.core/match-one                                     :all
+  metabase.driver-api.core/replace                                       :all
+  metabase.driver-api.core/replace-in                                    :all
+  metabase.lib.drill-thru.test-util/test-drill-variants-with-merged-args :all
+  metabase.lib.drill-thru.test-util/test-returns-drill                   :all
+  metabase.test/with-temp                                                #{0}
+  metabase.util.match/match-many                                         :all
+  metabase.util.match/match-one                                          :all
+  metabase.util.match/replace                                            :all
+  metabase.util.match/replace-in                                         :all
+  ;; TODO (Cam 2026-05-21) I'm not really sure about `defprotocol`, `deftype`, `defrecord`, `proxy`, `reify`, etc., I
+  ;; think idiomatically these should probably not have blank lines but we can worry about that later
+  defprotocol                                                            :all
+  defrecord                                                              :all
+  deftype                                                                :all
+  extend                                                                 :all
+  extend-protocol                                                        :all
+  potemkin.types/def-map-type                                            :all
+  potemkin.types/defprotocol+                                            :all
+  potemkin.types/defrecord+                                              :all
+  potemkin.types/deftype+                                                :all
+  potemkin/def-map-type                                                  :all
+  potemkin/defprotocol+                                                  :all
+  potemkin/defrecord+                                                    :all
+  potemkin/deftype+                                                      :all
+  proxy                                                                  :all
+  reify                                                                  :all
+  ;; TODO (Cam 2026-05-21) -- save these for a follow-on PR
+  defmacro                                                               :all
+  defmethod                                                              :all
+  defn                                                                   :all
+  defn-                                                                  :all
+  fn                                                                     :all
+  metabase.util.malli/defmethod                                          :all
+  metabase.util.malli/defn                                               :all
+  metabase.util.malli/defn-                                              :all}
+
  ;; See https://github.com/weavejester/cljfmt/blob/master/cljfmt/resources/cljfmt/indents/clojure.clj for the default
  ;; definitions
  ;;
@@ -37,7 +87,7 @@
  ;; `: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
+ { ;; clojure.core stuff
   fn*                                                                                         [[:inner 0]]
   let*                                                                                        [[:block 1]]
   with-meta                                                                                   [[:default]]

.github/workflows/drivers.yml

@@ -1625,7 +1625,9 @@ jobs:
       # if you add a driver job, you must add it to this list for it to be a required check
       - be-tests-h2
       - be-tests-athena-ee
-      - be-tests-bigquery-cloud-sdk-ee
+      # these are not reliable, but we want to run them anyway to gather data about failures
+      # - be-tests-snowflake-ee
+      # - be-tests-bigquery-cloud-sdk-ee
       - be-tests-druid-ee
       - be-tests-databricks-ee
       - be-tests-druid-jdbc-ee
@@ -1637,7 +1639,6 @@ jobs:
       - be-tests-postgres
       - be-tests-presto-jdbc-ee
       - be-tests-redshift-ee
-      - be-tests-snowflake-ee
       - be-tests-sparksql-ee
       - be-tests-sqlite-ee
       - be-tests-sqlserver
@@ -1665,7 +1666,7 @@ jobs:
               }));
 
             // are all jobs skipped or successful?
-            if (jobs.every(job => (job.result === 'skipped' || job.result === 'success' || job.name == 'be-tests-starburst-ee'))) {
+            if (jobs.every(job => (job.result === 'skipped' || job.result === 'success'))) {
                 console.log("");
                 console.log("        _------.        ");
                 console.log("       /  ,     \_      ");