(:require [ensorcel.conjure :as conjure])

; example/api.cljc

(ns example.api
  (:require [ensorcel.types :as t]
            [spec-tools.core :as st]
            #?(:clj  [clojure.spec.alpha :as s]
               :cljs [cljs.spec.alpha :as s :include-macros true])))

(s/def :widget/id  ::t/integer)
(s/def :widget/msg ::t/string)

; we wrap our key specs into spec-tools so that we can strip
; any extra keys
(s/def ::widget
  (st/spec (s/keys :req-un [:widget/id :widget/msg])))

(s/def ::get-widget-request
  (st/spec (s/keys :req-un [:widget/id])))

(def spellbook
  {:version "1"
   :services {:widgets {:path "widgets"
                        :endpoints {:get-all {:path ""
                                              :method :GET
                                              :returns (s/* ::widget)}
                                    :get     {:path [:id]
                                              :method :GET
                                              :args ::get-widget-request
                                              :returns ::widget}}}}})

; example/server.clj

(ns example.server
  (:require [example.api :as api]
            [ensorcel.conjure :as conjure]
            [org.httpkit.server :refer [run-server]]))

...

(defn- get-all-widgets
  []
  [{:id 0 :msg "I am a widget!"}
   {:id 1 :msg "I am another widget!"}])

(defn- get-widget
  [{id :id}]
  [{:id id :msg "I'm probably not what you wanted.."}])

; create our service
(def widget-service
  (conjure/service api/spellbook :widgets
                   :get     get-widget
                   :get-all get-all-widgets))

; tie it all together into our app
(def app
  (conjure/app api/spellbook {} ; options go here
               widget-service))

(defn start-server
  []
  (run-server app {:port 8000}))

; example/client.cljs

(ns example.client
  (:require [example.api :as api]
            [ensorcel.conjure :as conjure :refer [call->]]))

(def client (conjure/client api/spellbook :widgets))

(call-> (client :get-all)
        println)          ; the extracted, properly typed list of
                          ; widgets is passed to `println`

(call-> (client :get {:id 0})
        println)

...

(s/def ::my-query-argument ::types/string)
(s/def ::do-thing-request
  (st/spec (s/keys :opt-un [::my-query-argument])))

...
  ; in your spellbook
  :do-thing {:path   "thing"
             :method :GET
             :query  [:my-query-argument]
             :args   ::do-thing-request}

(call-> (client :do-thing)) ; becomes <path>/thing
(call-> (client :do-thing {:my-query-argument "hi")) ; becomes <path>/thing?my-query-argument=hi

...
  ; in your spellbook
  :my-endpoint {:path "endpoint"
                :method :GET
                :headers {"Content-Type" "text/html"}
                ...
               }

...
  (:require [ring.util.http-response :refer [created]] ;using http-response for example
    ...
...
  ; in your spellbook
  :new {:path "new-thing"
        :method :POST
        :response created
        ...
        }

(defn endpoint-zero
  [] ; no arguments
  ...)

(defn endpoint-one
  [args] ; argument map will be provided
  ...)

(defn endpoint-two
  [args request] ; the full ring request will also be provided
  ...)           ; containing cookies, headers etc.