auto-convert-casing.clj

auto-convert-casing.clj

(ns example.server
  (:require [camel-snake-kebab.core :as csk]
            [clojure.spec.alpha :as s]
            [clojure.string :as str]
            [clojure.walk :as walk]
            [muuntaja.core :as m]
            [reitit.coercion.spec :as spec]
            [reitit.dev.pretty :as pretty]
            [reitit.ring :as ring]
            [reitit.ring.coercion :as coercion]
            [reitit.ring.middleware.exception :as exception]
            [reitit.ring.middleware.multipart :as multipart]
            [reitit.ring.middleware.muuntaja :as muuntaja]
            [reitit.ring.middleware.parameters :as parameters]
            [reitit.swagger :as swagger]
            [reitit.swagger-ui :as swagger-ui]
            [ring.adapter.jetty :as jetty]))

;;;;;;;;;;;;;;;;;;;;; swagger endpoint middleware
(defn transform-map [tk tv m]
  (->> m
       (map (fn [[k v]]
              [(tk k); postwalk?
               (tv v)]))
       (into {})))

(defn transform-schema [tf {:keys [type] :as schema}]
  (case type
    "object"
    (-> schema
        (update :required #(map tf %))
        (update :properties (partial transform-map tf (partial transform-schema tf))))

    "array"
    ;(update schema :items transform-schema)
    (update schema :items (partial transform-schema tf))

    schema))

(defn transform-params [tf path-data]
  (transform-map identity
                 (fn [method-data]
                   (-> method-data
                       (update :parameters
                               #(map (fn [{:keys [in] :as param}]
                                       (cond
                                         (.contains ["query" "path"] in)
                                         (update param :name tf)

                                         (= "body" in)
                                         (update param :schema (partial transform-schema tf))))
                                     %))
                       (update :responses (partial transform-map
                                                   identity
                                                   #(update % :schema (partial transform-schema tf))))))
                 path-data))

(defn transform-request-path [tf path]
  (str/replace path #"(?<=\{).+?(?=\})" tf))

(defn wrap-transform-keys [tf]
  (fn [handler]
    (fn [request]
      (let [response (handler request)]
        (update-in response
                   [:body :paths]
                   (partial transform-map
                            (partial transform-request-path tf)
                            (partial transform-params tf)))))))

;;;;;;;;;;;;;;;;;;;;; transform request keys
(defn transform-body [tf coll]
  (let [f (fn [[k v]] [(tf k) v])]
    (walk/postwalk #(if (map? %)
                      (into {} (map f %))
                      %)
                   coll)))

(defn transform-request-case [tf]
  (fn [handler]
    (fn [request]
      (handler
       (-> request
           (update :body-params (partial transform-body tf))
           (update :query-params (partial transform-body tf)))))))


;;;;;;;;;;;;;;;;;;;;; transform response keys


(defn transform-response-case [tf]
  (fn [handler]
    (fn [request]
      (let [response (handler request)]
        (update response :body (partial transform-body tf))))))

(def app
  (ring/ring-handler
   (ring/router
    [["/swagger.json"
      {:get {:no-doc true
             :swagger {:info {:title "my-api"}}
             :middleware [(wrap-transform-keys csk/->camelCase)]
             :handler (swagger/create-swagger-handler)}}]

     ["/endpoint/{p-param}"
      {:post {:summary "minus with spec query parameters"
              :parameters {:query {:q-param int?}
                           :path {:p-param int?}
                           :body {:foo-bar int?
                                  :bar-foo int?
                                  :object-one {:x-tudo int?
                                               :parameter-y (s/coll-of int?)
                                               :object-three {:uhul-meu-fii int? :j int?}
                                               :object-two {:f-ahahah-boo int? :i int?}}}}
              :responses {200 {:body {:list (s/coll-of int?)
                                      :obj-n {:obj-name string?}
                                      :foo int?}}}
              :handler
              (fn [{params :parameters}]
                {:status 200
                 :body {:list [1 2 3 4]
                        :obj-n {:obj-name "nested-object"}
                        :foo 10}})}}]]

    {;;:reitit.middleware/transform dev/print-request-diffs ;; pretty diffs
       ;;:validate spec/validate ;; enable spec validation for route data
       ;;:reitit.spec/wrap spell/closed ;; strict top-level validation
     :exception pretty/exception
     :data {:coercion reitit.coercion.spec/coercion
            :muuntaja m/instance
            :middleware [;; swagger feature
                         swagger/swagger-feature

                         ;; query-params & form-params
                         parameters/parameters-middleware

                         ;; content-negotiation
                         muuntaja/format-negotiate-middleware

                         ;; encoding response body
                         muuntaja/format-response-middleware

                         ;; converts all incoming requests to camelCase
                         (transform-response-case csk/->camelCase)

                         ;; exception handling
                         exception/exception-middleware

                         ;; decoding request body
                         muuntaja/format-request-middleware

                         ;; coercing response bodys
                         coercion/coerce-response-middleware

                         ;; converts all incoming requests to kebab-case
                         (transform-request-case csk/->kebab-case-keyword)

                         ;; coercing request parameters
                         coercion/coerce-request-middleware

                         ;; multipart
                         multipart/multipart-middleware]}})
   (ring/routes
    (swagger-ui/create-swagger-ui-handler
     {:path "/"
      :config {:validatorUrl nil
               :operationsSorter "alpha"}})
    (ring/create-default-handler))))

(defn start []
  (jetty/run-jetty #'app {:port 3000, :join? false})
  (println "server running in port 3000"))

(comment
  (start))

fails for me:

java.lang.IllegalArgumentException: No implementation of method: :alter-name of protocol: #'camel-snake-kebab.internals.alter-name/AlterName found for class: java.lang.Long
        at clojure.core$_cache_protocol_fn.invokeStatic(core_deftype.clj:584)
        at clojure.core$_cache_protocol_fn.invoke(core_deftype.clj:576)
        at camel_snake_kebab.internals.alter_name$eval276$fn__277$G__267__284.invoke(alter_name.cljc:4)
        at camel_snake_kebab.core$__GT_camelCase.invokeStatic(core.cljc:51)
        at camel_snake_kebab.core$__GT_camelCase.doInvoke(core.cljc:51)
        at clojure.lang.RestFn.invoke(RestFn.java:410)
        at example.server$transform_body$f__9337.invoke(server.clj:74)

I think it's because of 200 as a key in the responses

example.server=> :tf #object[camel_snake_kebab.core$__GT_kebab_case_keyword 0x62f23d8f camel_snake_kebab.core$__GT_kebab_case_keyword@62f23d8f] :coll nil
:tf #object[camel_snake_kebab.core$__GT_kebab_case_keyword 0x62f23d8f camel_snake_kebab.core$__GT_kebab_case_keyword@62f23d8f] :coll {}
:tf #object[camel_snake_kebab.core$__GT_camelCase 0x6af0585 camel_snake_kebab.core$__GT_camelCase@6af0585] :coll {:swagger 2.0, :x-id #{:reitit.swagger/default}, :info {:title my-api}, :paths {/endpoint/{pParam} {:post {:responses {200 {:schema {:type object, :properties {list {:type array, :items {:type integer, :format int64}}, objN {:type object, :properties {objName {:type string}}, :required (objName)}, foo {:type integer, :format int64}}, :required (list objN foo)}, :description }}, :produces #{application/json application/transit+msgpack application/transit+json application/edn}, :consumes #{application/json application/transit+msgpack application/transit+json application/edn}, :parameters ({:in query, :name qParam, :description , :type integer, :required true, :format int64} {:in path, :name pParam, :description , :type integer, :required true, :format int64} {:in body, :name body, :description , :required true, :schema {:type object, :properties {fooBar {:type integer, :format int64}, barFoo {:type integer, :format int64}, objectOne {:type object, :properties {xTudo {:type integer, :format int64}, parameterY {:type array, :items {:type integer, :format int64}}, objectThree {:type object, :properties {uhulMeuFii {:type integer, :format int64}, j {:type integer, :format int64}}, :required (uhulMeuFii j)}, objectTwo {:type object, :properties {fAhahahBoo {:type integer, :format int64}, i {:type integer, :format int64}}, :required (fAhahahBoo i)}}, :required (xTudo parameterY objectThree objectTwo)}}, :required (fooBar barFoo objectOne)}}), :summary minus with spec query parameters}}}, :definitions nil}
2024-03-06 10:39:07.230:WARN:oejs.HttpChannel:qtp481489781-38: /swagger.json

hits this issue with csk

fix is this

(defn transform-body [tf coll]
  (let [f (fn [[k v]]
            (if (number? k)
              [k v]
              [(tf k) v]))]
    (walk/postwalk #(if (map? %)
                      (into {} (map f %))
                      %)
                   coll)))