stillsuit user manual

(ns stillsuit-sample.seattle-manual
  (:require [com.walmartlabs.lacinia :as lacinia]
            [stillsuit.core :as stillsuit]
            [datomic.api :as d]))

;; Standard lacinia query definition
(def my-schema {:objects {...} :queries {:query_name {...}}})

;; Connection to datomic, which is added to the app context
(def datomic-conn (d/connect "datomic:dev://localhost:4334/seattle"))

;; Map of resolver names to resolver functions
(def my-resolvers {:resolver/name (fn [c a v] ...)})

;; Regular GraphQL query, ie from client code
(def my-query "{ query_name { field ... } }")

(defn -main [_]
  (let [;; This options map tells stillsuit where to look for stuff
        options   {:stillsuit/schema     my-schema
                   :stillsuit/connection (d/connect my-db-uri)
                   :stillsuit/resolvers  my-resolvers}
        ;; (stillsuit/decorate) is the main stillsuit interface.
        stillsuit (stillsuit/decorate options)
        ;; Stillsuit returns a compiled schema to the calling code
        compiled  (:stillsuit/schema stillsuit)
        ;; It also sets up an app context
        context   (:stillsuit/app-context stillsuit)
        ;; We pass these two values to (lacinia/execute) to resolve the query.
        result    (lacinia/execute compiled my-query nil context)]
    (println result)))

(let [options   #:stillsuit{:connection my-connection
                            :resolvers  my-resolvers
                            :schema     {:objects {:foo {...}}}}
      decorated (stillsuit/decorate options)]
  (lacinia/execute
   (:stillsuit/schema decorated)                            ; Schema
   "query getFoo(id: Int!) { foo(id: $id) { bar } }"        ; Query
   {:foo-id 123}                                            ; Variables
   (:stillsuit/app-context decorated)))                     ; Context

(defn everybody [context args value]
  (let [db   (stillsuit/db context)
        eids (d/q '[:find [?person ...]
                    :in $
                    :where [?person :person/id _]]
                  db)]
    (map #(d/entity db %) eids)))

(defn person-by-id [context {:keys [id] :as args} value]
  (let [db  (stillsuit/db context)
        eid (d/q '[:find ?person .
                   :in $ ?id
                   :where [?person :person/id ?id]]
                 db
                 id)]
    (some->> eid (d/entity db))))

;; Maps from the keywords we used in our schema definition to the actual resolver functions
(def resolvers {:query/person-by-id person-by-id :query/everybody everybody})

;; Call stillsuit
(def decorated (decorate #:stillsuit{:schema     lacinia-schema
                                     :connection conn
                                     :resolvers  resolvers}))

;; Now we can execute queries against our decorated result:
(stillsuit/execute decorated "{ everybody { name } }")
;; => {:data #ordered/map([:everybody (#ordered/map([:name "Sarah"]) #ordered/map([:name "Joe"]))])}

(execute decorated "{ person(id: 123) { name } }")
;; => {:data #ordered/map([:person #ordered/map([:name "Sarah"])])}

;; Here we define a ref enum attribute, plus every value it can be set to:
@(d/transact conn [;; enum value definitions
                   {:db/ident :color/blue}
                   {:db/ident :color/red}
                   ;; enum attribute
                   {:db/ident       :car/color
                    :db/valueType   :db.type/ref
                    :db/cardinality :db.cardinality/one}
                   {:db/ident       :car/id
                    :db/valueType   :db.type/long
                    :db/unique      :db.unique/identity
                    :db/cardinality :db.cardinality/one}])

;; Note that transacting the value just uses a simple keyword, which is nice:
@(d/transact conn [{:db/id     (d/tempid :db.part/user)
                    :car/color :color/red
                    :car/id    100}])

;; The entity API resolves the ref idents to keywords:
(def car (d/entity (d/db conn) [:car/id 100]))
(:car/color car)
; => :color/red

;; But the pull API requires calling code to pull out the :db/ident values:
(d/pull (d/db conn) [:car/color] [:car/id 100])
; => #:car{:color #:db{:id 17592186046398}}
(d/pull (d/db conn) [{:car/color [:db/ident]}] [:car/id 100])
; => #:car{:color #:db{:ident :color/red}}

;; ...and the query API also requires this:
(d/q '[:find [?val ...]
       :where [?car :car/id 100]
              [?car :car/color ?color]
              [?color :db/ident ?val]]
     (get-db conn))
; => [:color/red]

;; With keyword enums, we don't need to set up the values in the database schema:
@(d/transact conn [;; enum attribute
                   {:db/ident       :boat/size
                    :db/valueType   :db.type/keyword
                    :db/cardinality :db.cardinality/one}
                   {:db/ident       :boat/id
                    :db/valueType   :db.type/long
                    :db/unique      :db.unique/identity
                    :db/cardinality :db.cardinality/one}])

;; Transacting values just uses plain keywords, as in ref enums:
@(d/transact conn [{:db/id     (d/tempid :db.part/user)
                    :boat/size :size/large
                    :boat/id   100}])

;; The entity, pull, and query APIs all return plain keywords:
(def boat (d/entity (d/db conn) [:boat/id 100]))
(:boat/size boat)
; => :size/large

(d/pull (d/db conn) [:boat/size] [:boat/id 100])
; => #:boat{:size :size/large}

(d/q '[:find [?val ...]
       :where [?car :boat/id 100]
              [?car :boat/size ?val]]
     (get-db conn))
; => [:size/large]