ensorcel.conjure — efisef/ensorcel 0.3.1-2

app clj

(app spellbook opts & services)

Creates a full ring application with default wrappers given a spellbook and conjured services

arg-count clj

(arg-count f)

assemble-call cljs

(assemble-call path-fn body-fn method)

body-fn cljs

(body-fn path query-args args)

call-> cljs

(call-> {call-fn :call-fn args :args headers :headers spec :spec} & thens)

Calls the endpoint, and if the response is successful, passes the parsed response through to the supplied functions one after the other

client cljs

(client {services :services :as spellbook} service-name & opts)

Create a REST client for a particular service from a spellbook

construct-input clj

(construct-input {:keys [params body]} input-spec)

Given a request and an input spec, coerces the components to the correct types and then validates that everything looks as expected.

construct-options clj

(construct-options endpoints)

Creates all required options for given paths and methods

correct-method clj

(correct-method method)

default-opts clj

endpoint clj/s≠

clj

(endpoint impls [endpoint {:keys [path method] :as spec}])

Creates a bidi endpoint from the given impls and an endpoint specification

cljs

(endpoint base-url {:keys [path method args query returns] :as spec})

extract cljs

(extract spec thens response)

format-path cljs

(format-path values [f & fragments])

inject-token cljs

(inject-token token client)

method-dispatch clj

(method-dispatch [path endpoints])

path-fn cljs

(path-fn base-path path query-args)

ping-endpoint cljs

(ping-endpoint host port version-str)

ping-service clj

(ping-service)

ping ping ping ping

query-fn cljs

(query-fn query-args args)

root clj

(root {version :version} {:keys [include-version?]} services)

service clj

(service {services :services :as spellbook} service-name & impls)

Creates a bidi service from the given impls and spellbook

stringify clj

(stringify x)

urlify cljs

(urlify value)

validate clj

(validate received expected raise!)

Validates that a received payload matches the expected schema. Raises <raise!> if not.

version-endpoint cljs

(version-endpoint host port version-str)

version-service clj

(version-service {version :version})

version version version version

wrap cljs

(wrap endpoints)

wrap-endpoint clj

(wrap-endpoint {:keys [args returns response headers] :or {response ok}} f)

Wraps a given endpoint implementation in the gubbins for a ring request Different outcomes for different arity implementions: 0 arity -> just calls the function 1 arity -> provides a parameter map from the request body and url 2 arity -> provides a parameter map and an options map containing things like cookies etc. Also validates that the inputs and outputs match the specification in the spellbook