lacinia HTTP API with generators

deps.edn

{:paths ["."]
 :deps  {org.clojure/clojure              {:mvn/version "1.10.0"}
         com.walmartlabs/lacinia          {:mvn/version "0.32.0"}
         io.pedestal/pedestal.service     {:mvn/version "0.5.5"}
         io.pedestal/pedestal.jetty       {:mvn/version "0.5.5"}
         com.walmartlabs/lacinia-pedestal {:mvn/version "0.11.0"}
         org.clojure/test.check           {:mvn/version "0.10.0-alpha3"}
         com.rpl/specter                  {:mvn/version "1.1.2"}}}

schema.graphql

type Partido {
    id: ID
    nome: String
    sigla: String
    descricao: String
}

type Camarada {
    id: ID
    nome: String
    partido: Partido
    camaradas: [Camarada]
}

type Lei {
    id: ID
    descricao: String
    autor: Camarada
    pros: [Camarada]
    cons: [Camarada]
}


type QueryRoot {
    id: ID
    Camaradas: [Camarada]
}

user.clj

(ns user
  (:require [com.walmartlabs.lacinia :as lacinia]
            [com.walmartlabs.lacinia.pedestal :as lacinia.pedestal]
            [com.walmartlabs.lacinia.schema :as lacinia.schema]
            [com.walmartlabs.lacinia.parser.schema :as lacinia.parser.schema]
            [io.pedestal.http :as http]
            [com.rpl.specter :as sp]
            [clojure.java.io :as io]
            [clojure.spec.alpha :as s]
            [clojure.test.check.generators :as gen]))
(def type->gen
  {'ID     (s/gen uuid?)
   'String (s/gen string?)})


(defn add-gen
  [x]
  (sp/transform (sp/walker :type)
                (fn [{:keys [type] :as f}]
                  (let [many? (seq? type)
                        type-id (if many? (last type) type)
                        generator (get type->gen type-id (gen/hash-map :id (s/gen uuid?)))
                        generator (if many?
                                    (gen/vector generator)
                                    generator)]
                    (assoc f :resolve (fn [_ _ _]
                                        (let [data (gen/generate generator)]
                                          data)))))
                x))

(def schema
  (-> (io/resource "schema.graphql")
      slurp
      (lacinia.parser.schema/parse-schema {})
      add-gen
      (lacinia.schema/compile)))

(defonce http-state (atom nil))

(defn -main
  [& args]
  (swap! http-state (fn [x]
                      (when x
                        (http/stop x))
                      (-> (lacinia.pedestal/service-map schema {:graphiql true})
                          http/default-interceptors
                          http/dev-interceptors
                          http/create-server
                          http/start))))

(def context
  {})

(defn q
  [& [query variables options]]
  (lacinia/execute schema query variables context options))