Add our general macros

iac/src/main/utils/general.clj

@@ -0,0 +1,81 @@
+(ns utils.general
+  (:require
+   [clojure.walk]))
+
+(defmacro build-registry
+  "Generates a flat resource registry map from a nested provider definition map."
+  [definitions]
+  (let [map-entries
+        (reduce-kv
+         (fn [entries provider-group-kw provider-group-def]
+           (let [{:keys [root-sym provider-key resources]} provider-group-def
+                 provider-ns (name provider-group-kw)]
+             (reduce-kv
+              (fn [entries resource-kw resource-def]
+                (let [{:keys [path defaults-fn defaults-name]} resource-def
+                      resource-name (name resource-kw)
+                      final-key (keyword provider-ns resource-name)
+                      constructor-form (list* '.. root-sym path)
+                      defaults-fn-form
+                      (cond
+                        defaults-fn defaults-fn
+                        defaults-name (let [defaults-fn-sym (symbol "default" (name defaults-name))]
+                                        `(fn [env] (~defaults-fn-sym (:options env))))
+                        :else (let [defaults-fn-sym (symbol "default" resource-name)]
+                                `(fn [env] (~defaults-fn-sym (:options env)))))
+                      value-map `{:constructor ~constructor-form
+                                  :provider-key ~provider-key
+                                  :defaults-fn ~defaults-fn-form}]
+                  (conj entries [final-key value-map])))
+              entries
+              resources)))
+         []
+         definitions)]
+    `~(into {} map-entries)))
+
+
+(defn- p->-replace-percent
+  "Walks 'form' and replaces all instances of the symbol '%'
+   with the value of 'x'."
+  [form x]
+  (clojure.walk/postwalk
+    (fn [sub-form]
+      (if (= sub-form '%) x sub-form))
+    form))
+
+(defmacro pulet
+  "Sequential binding for Pulumi Outputs.
+   Looks like let*, but each binding is chained."
+  [bindings & body]
+  (if (empty? bindings)
+    `(do ~@body)
+    (let [[sym val & rest] bindings]
+      `(p-chain ~val
+                (fn [~sym]
+                  (pulet [~@rest] ~@body))))))
+
+
+
+
+(defmacro p-> [x & forms]
+  (let [wrap (fn [acc form]
+               (cond
+                 (map? form)
+                 `(p-chain ~acc (fn [val#] ~form))
+
+                 (keyword? form)
+                 `(p-chain ~acc #(get % ~form))
+
+                 (string? form)
+                 `(p-chain ~acc #(aget % ~form))
+
+                 (symbol? form)
+                 `(p-chain ~acc #(~form %))
+
+                 (list? form)
+                 `(p-chain ~acc (fn [val#] (~@form val#)))
+
+                 :else
+                 (throw (ex-info "Unsupported form in p->" {:form form}))))]
+    (reduce wrap x forms)))
+