ensorcel.conjure — efisef/ensorcel 0.1.1-1

app clj

(app spellbook & 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 args)

call-> cljs

(call-> {call :call schema :schema} & 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

coerce clj/s≠

clj

(coerce value spec)

cljs

(coerce schema result)

coercions clj/s

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.

default-spellbook clj

endpoint clj/s≠

clj

(endpoint impls [endpoint spec])

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

cljs

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

format-path cljs

(format-path values [f & fragments])

parse cljs

(parse schema result)

parse-params clj

(parse-params params input-spec)

path-fn cljs

(path-fn base-path path)

ping-service clj

(ping-service)

ping ping ping ping

root clj

(root 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-service clj

(version-service {version :version})

version version version version

wrap cljs

(wrap endpoints)

wrap-endpoint clj

(wrap-endpoint {:keys [args returns response] :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