(require '[com.github.ivarref.clj-paginate :as cp])

(defn nodes [page]
  (->> page
       :edges
       (mapv :node)))

(def data (vec (shuffle [{:inst 0}
                         {:inst 1}
                         {:inst 2}])))

; Get the initial page:
(def page-1 (cp/paginate 
               data
               
               ; The next argument, `sort-attrs`, specifies how the vector should be sorted. 
               ; It must be a single keyword, a vector of keywords or a vector of pairs (keyword and :asc/:desc).
               ; See more documentation below for information about ascending or descending
               ; sorting.
               :inst
               
               ; A function to transform an initial node into a final node,
               ; i.e. load more data from a database.
               identity
               
               ; What to get, the first two elements in this case:
               {:first 2}))
; page-1
;=>
;{:edges
; [{:node {:inst 0}, :cursor "{:context {} :cursor [0 ]}"}
;  {:node {:inst 1}, :cursor "{:context {} :cursor [1 ]}"}],
; :pageInfo
; {:hasPrevPage false,
;  :hasNextPage true,
;  :startCursor "{:context {} :cursor [0 ]}",
;  :endCursor "{:context {} :cursor [1 ]}",
;  :totalCount 3}}


; Get the second page:
(def page-2 (cp/paginate data
                         :inst
                         identity
                         {:first 2
                          :after (get-in page-1 [:pageInfo :endCursor])}))
; (nodes page-2)
; => [{:inst 2}]

; Get the next (empty) page:
(def page-3 (cp/paginate data
                         :inst
                         identity
                         {:first 2
                          :after (get-in page-2 [:pageInfo :endCursor])}))
; (nodes page-3)
; => []
; No more data! 
; The poller, i.e. a different backend, should now sleep for some time before attempting again.


; More data has arrived:
(def data [{:inst 0} ; old
           {:inst 1} ; old
           {:inst 2} ; old
           {:inst 3} ; new item
           {:inst 4} ; new item
           ])

; Time for another poll. Growing data is handled:
(def page-4 (cp/paginate data
                         :inst
                         identity
                         {:first 2
                          :after (get-in page-3 [:pageInfo :endCursor])}))
; (nodes page-4)
; => [{:inst 3} {:inst 4}]

; More data has arrived, and old data expired/got removed:
(def data [{:inst 6}
           {:inst 7}
           {:inst 8}])

; Changed data is handled as long as the newer data adheres to sorting
(def page-5 (cp/paginate data
                         :inst
                         identity
                         {:first 2
                          :after (get-in page-4 [:pageInfo :endCursor])}))
; (nodes page-5)
; => [{:inst 6} {:inst 7}]

(require '[com.github.ivarref.clj-paginate :as cp])

(def data
  (vec (shuffle [{:inst 0 :id 1}
                 {:inst 1 :id 2}
                 {:inst 2 :id 3}])))

(defn http-post-handler 
  [response data http-body]
  (assoc response
    :status 200
    :body (cp/paginate
            ; The first argument is the data to paginate.
            data
            
            ; The second argument specifies how the vector is sorted.
            ; It thus also specifies what constitute a unique identifier for a node.
            ; It may be a single keyword, a vector of keywords,
            ; or a vector of pairs where each pair has a keyword and :asc or :desc.
            [:inst]
            
            ; The third argument is a function that further processes the node.
            ; The function may for example load more data from a database or other external storage.
            (fn [{:keys [inst id] :as node}]  
              (Thread/sleep 10) ; Do some heavy work.
              (assoc node :value-from-db 1))
            
            ; The fourth argument should be a map containing the arguments to the pagination.
            ; This map must contain either:
            ; :first (Integer), how many items to fetch from the start, and optionally :after, the cursor,
            ; or :last (Integer), how many items to fetch from the end, and optionally :before, the cursor.
            ; If this requirement is not satisfied, an exception will be thrown.
            http-body)))

(require '[com.github.ivarref.clj-paginate :as cp])

(def data
  (vec (shuffle [{:inst #inst"2000" :id 1}
                 {:inst #inst"2000" :id 2}
                 {:inst #inst"2001" :id 3}])))

(cp/paginate
   ; The first argument is the data to paginate.
   data
   
   ; The second argument specifies how the vector should be sorted.
   [[:inst :asc] [:id :desc]]
   
   identity
   {:first 2})

(def conn *1)

(mapv :node (:edges conn))
=> [{:inst #inst"2000", :id 2} {:inst #inst"2000", :id 1}]

(cp/paginate
   ; The first argument is the data to paginate.
   ; The data must already be sorted.
   data

   ; The second argument specifies which attributes constitute a unique identifier for a node.
   ; It may be a single keyword, or a vector of keywords.
   [[:inst :asc] [:id :desc]]

   identity
   {:first 2 :after (get-in conn [:pageInfo :endCursor])})

(mapv :node (:edges *1))
=> [{:inst #inst"2001", :id 3}]

(require '[com.github.ivarref.clj-paginate :as cp])

(def data
   (group-by :status
             [{:inst 0 :id 1 :status :init}
              {:inst 1 :id 2 :status :pending}
              {:inst 2 :id 3 :status :done}
              {:inst 3 :id 4 :status :error}
              {:inst 4 :id 5 :status :done}]))

(defn http-post-handler
   [response data http-body]
   (assoc response
      :status 200
      :body (cp/paginate
               data ; data is now a map.
               :inst
               (fn [{:keys [inst id] :as node}]
                  (Thread/sleep 10) ; Do some heavy work.
                  (assoc node :value-from-db 1))

               ; Assume that the HTTP endpoint accepts a parameter `:statuses` for the body,
               ; and that when present, this is a vector such as `[:init :pending :done :error]` or similar,
               ; i.e. the keys of `data` that we want to filter on.
               ;
               ; Paginate's `opts` accepts a key `:filter` that does exactly this for data maps.
               ; Thus we can simply rename `:statuses` to `:filter` in the http body.
               ; clj-paginate takes care of storing the value of `:filter` in the cursor
               ; for subsequent queries.
               (clojure.set/rename-keys http-body {:statuses :filter}))))

; To illustrate this, consider the following code:
(let [conn (cp/paginate
              data
              :inst
              identity
              {:first  1
               :filter [:done]})]
   ; Will print [{:inst 2, :id 3, :status :done}].
   (println (mapv :node (:edges conn))) 

   ; Will print [{:inst 4, :id 5, :status :done}].
   ; Notice here that we do not re-specify `:filter`.
   ; It is already stored in the cursor from the original connection.
   (println (mapv :node (:edges (cp/paginate
                                   data
                                   :inst
                                   identity
                                   {:first 1
                                    :after (get-in conn [:pageInfo :endCursor])})))))

(require '[com.github.ivarref.clj-paginate :as cp])

; Using :first:
(cp/paginate
  data
  [:sort-attrs]
  identity
  {:first 10 :after (:startCursor (:pageInfo connection))}
  :inclusive? true)

; Using :last:
(cp/paginate
   data
   [:sort-attrs]
   identity
   {:last 10 :before (:endCursor (:pageInfo connection))}
   :inclusive? true)

(require '[com.github.ivarref.clj-paginate :as cp])

(defn load-batch [nodes]
  (let [loaded-nodes (->> (mapv :id nodes)
                          
                          ; load data from database using pull-many:
                          (datomic.api/pull-many datomic-db '[:*])

                          ; Do we have any ordering guarantees? Pretend the ordering got mixed up:
                          (shuffle))]
    (cp/ensure-order nodes 
                     loaded-nodes
                     :sf :id ; Source id function, defaults to :id.
                     :df :db/id ; Dest id function, defaults to :id.
                     
                     ; (sf input-node) must be equal to some (df output-node).
                     ; ensure-order uses this to order `loaded-nodes` according
                     ; to how `nodes` were ordered.
                     )))

; Using load-batch
(cp/paginate
   data
   :id
   load-batch
   {:first 100}
   
   ; The named parameter :batch? is set to `true`:
   :batch? true
   )