migrates accounts

src/clj/auto_ap/ssr/utils.clj

@@ -1,9 +1,14 @@
 (ns auto-ap.ssr.utils
   (:require
+   [auto-ap.datomic :refer [all-schema]]
    [auto-ap.logging :as alog]
+   [clojure.string :as str]
    [config.core :refer [env]]
    [hiccup2.core :as hiccup]
-   [clojure.string :as str]))
+   [malli.core :as mc]
+   [malli.error :as me]
+   [malli.transform :as mt2]
+   [ring.middleware.nested-params :refer [parse-nested-keys]]))
 
 (defn html-response [hiccup & {:keys [status headers oob] :or {status 200 headers {} oob []}}]
   {:status  status
@@ -68,3 +73,119 @@
         (seq k)
         (str/join "_" (map path->name k))
         :else k))
+
+
+(defn forced-vector [x]
+  [:vector {:decode/json {:enter (fn [x]
+                                   (if (sequential? x)
+                                     x
+                                     [x])
+                                   )}}
+   x])
+
+(def entity-id (mc/schema nat-int?))
+(def temp-id (mc/schema :string))
+
+(defn str->keyword [s]
+  (if (string? s)
+    (let [[ns k] (str/split s #"/")]
+      (if (and ns k)
+        (keyword ns k)
+        (keyword s)))
+    s))
+
+(defn keyword->str [k]
+  (subs (str k) 1))
+
+(defn wrap-schema-decode [handler & {:keys [form-schema query-schema route-schema params-schema]}]
+  (fn [{:keys [form-params query-params params]  :as request}]
+    (try
+      
+      (handler (cond-> request
+                 (and (:params request) params-schema)
+                 (assoc :params
+                        (mc/coerce
+                          params-schema
+                          (:params request)
+                          (mt2/transformer 
+                            (mt2/key-transformer {:encode keyword->str :decode str->keyword})
+                            mt2/string-transformer
+                            mt2/json-transformer) ))
+
+                 (and (:route-params request) route-schema)
+                 (assoc :route-params
+                        (mc/coerce
+                          route-schema
+                          (:route-params request)
+                          (mt2/transformer 
+                            (mt2/key-transformer {:encode keyword->str :decode str->keyword})
+                            mt2/string-transformer
+                            mt2/json-transformer) ))
+
+                 (and form-schema form-params)
+                 (assoc :parsed-form-params
+                        (mc/coerce
+                          form-schema
+                          form-params
+                          (mt2/transformer 
+                            (mt2/key-transformer {:encode keyword->str :decode str->keyword})
+                            mt2/string-transformer
+                            mt2/json-transformer) ))
+
+                 (and query-schema query-params)
+                 (assoc :parsed-query-params
+                        (mc/coerce
+                          query-schema
+                          query-params
+                          (mt2/transformer 
+                            (mt2/key-transformer {:encode name :decode keyword})
+                            mt2/string-transformer
+                            mt2/json-transformer) ))))
+      (catch Exception e
+        (alog/warn ::validation-error :error e)
+        (html-response [:span.error-content.text-red-500 (str/join ", "
+                                                                   (mapcat identity 
+                                                                           (-> e
+                                                                               (ex-data )
+                                                                               :data
+                                                                               :explain
+                                                                               me/humanize
+                                                                               vals)))]
+                       :status 400)))))
+
+(defn ref->enum-schema [n]
+  (into [:enum {:decode/string #(keyword n %)}]
+        (for [{:db/keys [ident]} (all-schema)
+              :when (= n (namespace ident))]
+          ident)))
+
+(defn ref->select-options [n & {:keys [allow-nil?]}]
+  (into (if allow-nil?
+          [["" ""]]
+          [])
+        (for [{:db/keys [ident]} (all-schema)
+              :when              (= n (namespace ident))]
+          [(name ident) (str/replace (str/capitalize (name ident)) "-" " ")])))
+
+(def map->db-id-decoder
+  {:enter (fn [x]
+            (into []
+                  (for [[k v] x]
+                    (assoc v :db/id (cond (and (string? k) (re-find #"^\d+$" k))
+                                          (Long/parseLong k)
+                                          (keyword? k)
+                                          (name k)
+                                          :else
+                                          k)))))})
+
+(defn namespaceize-decoder [n]
+  {:exit (fn [m]
+           (when m
+             (reduce
+               (fn [m [k v]]
+                 (if (= k "id")
+                   (assoc m :db/id v)
+                   (assoc m (keyword n (name k)) v)))
+               m
+               m)))})
+