Add Temporal codec-server endpoints

[raszi]

The work in #85 and my follow-up PR made it possible to use the data converter that the client uses directly.

This opens up the possibility to ship ring-compatible functions that could be mounted to web applications to encode and decode messages.

What I imagined is two higher-order functions that receive an optional data converter or fall back to the default if none is provided, and return a ring-compatible function that could be mounted in web apps.

See https://docs.temporal.io/production-deployment/data-encryption#sample-requestresponse

[raszi]

Since the data converter could potentially depend on the namespace, it might need to receive a function as its argument that receives either the whole request or just the namespace and returns the data converter to be used.

[FelipeCortez]

we use a quick and dirty implementation which works for both Clojure and non-Clojure payloads:

(ns stylitics.temporal.codec-server
  (:gen-class)
  (:require
   [clojure.data.json :as json]
   [clojure.edn :as edn]
   [clojure.java.io :as io]
   [clojure.string :as string]
   [org.httpkit.server :as hkit]
   [stylitics.core.bytes :as sty.bytes]
   [taoensso.nippy :as nippy]
   [taoensso.telemere :as t]))

(def CORS-headers
  {"Access-Control-Allow-Origin"  "*"
   "Access-Control-Allow-Methods" "POST, GET, OPTIONS"
   "Access-Control-Allow-Headers" "X-Namespace, Content-Type"})

(defn decode-payload [{:strs [metadata data] :as input}]
  (if (and (= (get metadata "encoding") #=(sty.bytes/base64-encode-string "binary/plain"))
           (string/starts-with? data #=(sty.bytes/base64-encode-string "NPY")))
    (let [nippy-thawed (nippy/thaw-from-string data)]
      {:decoded-to-json nippy-thawed
       :raw-clj-str (pr-str nippy-thawed)})
    input))

(defn encode-payload [{:strs [_metadata data] :as input}]
  (let [decoded-data (sty.bytes/base64-decode-string data)]
    (if (string/starts-with? decoded-data "{\"raw-clj-str\":")
      {:metadata {:encoding #=(sty.bytes/base64-encode-string "binary/plain")}
       :data (-> decoded-data
                 (json/read-str {:key-fn keyword})
                 (:raw-clj-str)
                 (edn/read-string)
                 (nippy/freeze-to-string))}
      input)))

(defn response [req]
  (try
    (case (:request-method req)
      :options
      {:status  200
       :headers CORS-headers}

      :post
      (case (:uri req)
        ("/decode" "/codec-server/decode")
        {:status  200
         :headers (assoc CORS-headers "Content-Type" "application/json")
         :body
         (-> req
             (:body)
             (io/reader)
             (json/read)
             (update "payloads" (partial mapv decode-payload))
             (json/write-str))}

        ("/encode" "/codec-server/encode")
        {:status  200
         :headers (assoc CORS-headers "Content-Type" "application/json")
         :body    (-> req
                      (:body)
                      (io/reader)
                      (json/read)
                      (update "payloads" (partial mapv encode-payload))
                      (json/write-str))}))
    (catch Exception e
      {:status 500
       :headers (assoc CORS-headers "Content-Type" "application/json")
       :body (json/write-str (Throwable->map e))})))

(defn start-server! [& [{:keys [port]}]]
  (let [port (or port
                 (some-> (System/getenv "TEMPORAL_CODEC_SERVER_PORT")
                         (parse-long))
                 3009)]
    (t/log! (format "Starting Temporal codec server on localhost:%d..." port))
    (hkit/run-server #'response {:port port})))


(defn -main [& _args]
  (start-server!))