[datomic.schema "0.1.19"]

(require '[datomic.schema :as schema :refer [defschema]])

(defschema User
  (schema/attrs
   [:name :string]))

;; Construction Usage
(->User {:name "isaac"})
;;=> {:user/name "isaac"}

;; Spec Usage
(require '[clojure.spec.alpha :as s])
(s/valid? User {:user/name "isaac"})

;; Install schemas
(schema/install datomic-peer-connection-or-client-connection)

(declare Account UserRole)

;; User with 4 attributes
;;   `:user/name`
;;   `:user/email`    with `:db.unique/identity`
;;   `:user/accounts` is   `:db.type/ref`, ref many Accounts
;;   `:user/roles`    is   `:db.type/ref`, ref many Roles
(defschema User
  (schema/attrs
   [:name     :string]
   [:email    :string    {:unique :identity}]
   [:accounts #'Account  {:cardinality :many}]
   [:roles    #'UserRole {:cardinality :many}]))

(defschema Account
  ;; new partition `:db.part/account`, for Account constructor
  ;; partition must working with datomic peer library
  (schema/partition :db.part/account)
  (schema/attrs
   [:balance :bigdec]
   ;; `:foo/bar` already qualified,
   ;; ignore the schema namespace `account`
   [:foo/bar :string]))

;; Enumerations: `:user.type/vip`, `:user.type/blacklist` ...
;; We specify namespace to `:user/type` instead of `:user.role`
(defschema UserRole
  (schema/namespace :user.type)
  (schema/enums :vip :blacklist :normal))

;; only install attributes of User
(schema/install conn User)

;; install all defined attributes, `schema/install` with no argument
(schema/install conn)

@(d/transact
    conn
    [(->User {:name     "isaac"
              :email    "abc@example.xyz"
              :accounts {:balance 3.0M}
              :roles    :vip})])

(defschema User
  (schema/attrs
   [:name :string])

  ;; database function `:fn.user/valid?`
  (schema/fn valid? [u]
    (assert (-> (:user/name u) (count) (< 30))
            "`:user/name` must shorter than 30 characters")
    u)

  ;; transact function, db as first argument, but name is qualified already
  (schema/fn :user/add [db u]
    [(d/invoke db :fn.user/valid? u)]))


;; We also can gather all database function into one schema
(defschema Functions
  (schema/fn :fn.user/new [name]
    {:user/name name})

  (schema/fn :fn.user/greet [u]
    (str "greeting " (:user/name u))))

;; ok, you may be want to transact functions directly
@(d/transact conn [(schema/fn :abc/foo [args]
                     (prn args))])

(defschema Species
  (schema/attrs
   [:parent #'Species])
  (schema/enums
   :animal
   {:db/ident :bird
    :parent   :species/animal}))

;; one attribtes
{:db/ident              :species/parent
 :db/valueType          :db.type/ref
 :db/cardinality        :db.cardinality/one
 :db.install/_attribute :db.part/db}

;; `:species/animal`
{:db/ident              :species/animal}

;; `:species/bird`
{:db/ident              :species/bird
 :species/parent        :species/animal}

(defschema RawSchemas
  (schema/raws
   {:db/ident :db/doc
    :db/doc   "use for write documentation of some entity"}))

;; more complicated
(defschema SelfDepends
  (schema/attrs
   [:foo #'SelfDepends])
  (schema/raws
   {:db/doc "hello"}
   {:db/id            :self.depends/foo
    :self.depends/foo :self.depends/foo}))

(->> (->User {:name "isaac"
              :email "abc@example.xyz"
              :roles  [:vip]})
     (s/valid? User))
;;=> true


(->> {:user/name "isaac"
      :user/email "abc@example.xyz"
      ;; for datomic, `:db.cardinality/many` also support single value
      :user/roles :user.role/vip}
     (s/valid? User))
;;=> true


(->> {:user/name  "isaac"
      ;; will fail, because `:user/email` is `:db.cardinality/one`
      :user/email ["abc@example.xyz"]
      :user/roles :user.role/vip}
     (s/valid? User))
;;=> false