@@ -12,6 +12,7 @@

   ((%database :reader database

               :initform (make-hash-table))))

 (defgeneric add-object (store object))

+(defgeneric objects-of-type (store type))

 (defgeneric get-object (store type id))

 (defgeneric ingest-jsonapi (store object))

 (defgeneric stored-types (store))

@@ -29,7 +30,7 @@

   ((%id :accessor id)

    (%shipments :accessor shipments-a)))

 (defmethod add-object ((store jsonapi-datastore) (object batch))

-  (setf (object :batches (id object))

+  (setf (object store :batches (id object))

         (alexandria:alist-hash-table

          `(("relationships" . ,(mapcar (lambda (it)

                                          (alexandria:alist-hash-table

@@ -77,7 +78,7 @@

   (alexandria:once-only (h-t)

     `(let-lazy ,(loop for (name key . rest) in bindings

                       collect `(,name (gethash ,key ,h-t ,@rest)))

-       ,@body)))

+               ,@body)))

 (defmacro destructure-resource (resource &body body)

   `(hash-table-dbind ((id "id")

@@ -86,19 +87,22 @@

                       (relationships "relationships" 'empty)

                       (links "links" 'empty)

                       (meta "meta" 'empty))

-       ,resource

-     ,@body))

+                     ,resource

+                     ,@body))

+(defmethod objects-of-type ((store jsonapi-datastore) type)

+  (gethash (normalize-type type)

+           (database store)))

 (defgeneric id-resolver-gf (store resource))

 (defmethod id-resolver-gf ((store jsonapi-datastore) (resource hash-table))

   (destructure-resource resource

-    (get-object store type id)))

+                        (get-object store type id)))

 (defmethod id-resolver-gf ((store jsonapi-datastore) (resource string))

   (patmatch:let-pat* (((vector type id) (fwoar.string-utils:split "/" resource :count 1)))

-    (get-object store

-                type

-                id)))

+                     (get-object store

+                                 type

+                                 id)))

 (defun id-resolver (store)

   (lambda (resource)

@@ -106,7 +110,7 @@

 (defmethod add-object :before ((store recording-datastore) (object hash-table))

   (vector-push-extend (destructure-resource object

-                        (list :add-object id type attributes))

+                                            (list :add-object id type attributes))

                       (record store)))

 (defmethod stored-types ((store jsonapi-datastore))

@@ -120,30 +124,30 @@

                      (jsonapi "jsonapi" 'empty)

                      (links "links" 'empty)

                      (included "included" 'empty))

-      object

-    (when (and (eql data 'empty)

-               (eql errors 'empty)

-               (eql meta 'empty))

-      (warn "one of data, errors or meta must be specified in a toplevel object"))

-    (when (not (or (eql data 'empty)

-                   (eql errors 'empty)))

-      (warn "only one of data or errors may be specified"))

-    (unless (when (eql data 'empty)

-              (not (eql included 'empty)))

-      (warn "included may only be specified if data is specified"))

-    (if (typep included 'sequence)

-        (add-object store included)

-        (unless (eql included 'empty)

-          (warn "included should be a sequence")

-          (add-object store included)))

-    (add-object store data)))

+                    object

+                    (when (and (eql data 'empty)

+                               (eql errors 'empty)

+                               (eql meta 'empty))

+                      (warn "one of data, errors or meta must be specified in a toplevel object"))

+                    (when (not (or (eql data 'empty)

+                                   (eql errors 'empty)))

+                      (warn "only one of data or errors may be specified"))

+                    (unless (when (eql data 'empty)

+                              (not (eql included 'empty)))

+                      (warn "included may only be specified if data is specified"))

+                    (if (typep included 'sequence)

+                        (add-object store included)

+                        (unless (eql included 'empty)

+                          (warn "included should be a sequence")

+                          (add-object store included)))

+                    (add-object store data)))

 (defun resource-identifier-p (resource)

   (destructure-resource resource

-    (and resource

-         (eql attributes 'empty)

-         (eql relationships 'empty)

-         (eql links 'empty))))

+                        (and resource

+                             (eql attributes 'empty)

+                             (eql relationships 'empty)

+                             (eql links 'empty))))

 (defmacro with-json-output ((stream &key indent) &body body)

   "Set up a JSON streaming encoder context on STREAM, then evaluate BODY."

@@ -156,21 +160,21 @@

 (defmethod add-object ((store jsonapi-datastore) (object hash-table))

   (destructure-resource object

-    (let* ((store-ht (database store))

-           (type-store (alexandria:ensure-gethash (normalize-type type)

-                                                  store-ht

-                                                  (make-hash-table :test 'equal)))

-           (old-value (gethash id type-store)))

-      (unless (eql relationships 'empty)

-        (loop for v being the hash-values of relationships

-              for data = (gethash "data" v)

-              when data do

-                (add-object store data)))

-      (if (resource-identifier-p old-value)

-          (setf (gethash id type-store) object)

-          (if (resource-identifier-p object)

-              old-value

-              (setf (gethash id type-store) object))))))

+                        (let* ((store-ht (database store))

+                               (type-store (alexandria:ensure-gethash (normalize-type type)

+                                                                      store-ht

+                                                                      (make-hash-table :test 'equal)))

+                               (old-value (gethash id type-store)))

+                          (unless (eql relationships 'empty)

+                            (loop for v being the hash-values of relationships

+                                  for data = (gethash "data" v)

+                                  when data do

+                                    (add-object store data)))

+                          (if (resource-identifier-p old-value)

+                              (setf (gethash id type-store) object)

+                              (if (resource-identifier-p object)

+                                  old-value

+                                  (setf (gethash id type-store) object))))))

 (defmethod add-object ((store jsonapi-datastore) (objects sequence))

   (map 'list

@@ -187,10 +191,10 @@

 (defun summarize-objects-of-type (store type map-fn filter-fn)

   (serapeum:collecting

-    (serapeum:do-hash-table (k v (gethash type (database store)))

-      (declare (ignore k))

-      (when (funcall filter-fn v)

-        (collect (funcall map-fn v))))))

+   (serapeum:do-hash-table (k v (gethash type (database store)))

+     (declare (ignore k))

+     (when (funcall filter-fn v)

+       (collect (funcall map-fn v))))))

 (defun get-signin-page ()

   (let ((c-j (make-instance 'drakma:cookie-jar)))

@@ -201,8 +205,8 @@

 (defun extract-auth-token (doc)

   (lquery:$1 (inline doc)

-    "form input[type=hidden][name=authenticity_token]"

-    (attr "value")))

+             "form input[type=hidden][name=authenticity_token]"

+             (attr "value")))

 (defvar *csrf-token* nil)

 (defun request-json (url cj &rest r &key (method :get) (parameters ()))

@@ -243,12 +247,12 @@

            (user-home (login-garagiste auth-token cookie-jar)))

       (setf *csrf-token*

             (lquery:$1 (initialize user-home)

-              "meta[name=csrf-token]"

-              (attr "content")))

+                       "meta[name=csrf-token]"

+                       (attr "content")))

       (values (yason:parse

                (lquery:$1 (initialize user-home)

-                 "div[data-react-class=Portal]"

-                 (attr "data-react-props")))

+                          "div[data-react-class=Portal]"

+                          (attr "data-react-props")))

               cookie-jar))))

 (defun user-id (ud)

@@ -263,6 +267,10 @@

   (request-json (format nil "https://app.garagiste.com/customers/~a/requests/" user-id)

                 cookie-jar))

+(defun offerings (user-id cookie-jar)

+  (offering-json (format nil "https://app.garagiste.com/customers/~a/offerings/" user-id)

+                 cookie-jar))

+

 (defun orders (user-id cookie-jar)

   (request-json (format nil "https://app.garagiste.com/customers/~a/orders/" user-id)

                 cookie-jar))

@@ -273,27 +281,26 @@

 (data-lens:defalias simplify-order

-  (data-lens:<>1 (lambda (it)

-                   (mapcan (lambda (key el)

-                             (list key el))

-                           '(:unit-price :count :total-price :offering-name)

-                           it))

-                 (data-lens:juxt (data-lens:key "unit_price")

-                                 (data-lens:key "count")

-                                 (data-lens:key "total_price")

-                                 (data-lens:key "offering_name"))))

+    (data-lens:<>1 (lambda (it)

+                     (mapcan (lambda (key el)

+                               (list key el))

+                             '(:unit-price :count :total-price :offering-name)

+                             it))

+                   (data-lens:juxt (data-lens:key "unit_price")

+                                   (data-lens:key "count")

+                                   (data-lens:key "total_price")

+                                   (data-lens:key "offering_name"))))

 (data-lens:defalias summarize-orders

-  (data-lens:<>1 (data-lens:denest)

-                 (data-lens:transform-head

-                  (lambda (it)

-                    (list :id it)))

-                 (data-lens:juxt (data-lens:juxt (data-lens:<>1 'normalize-type

-                                                                (data-lens:key "type"))

-                                                 (data-lens:key "id"))

-                                 (data-lens:<>1 'simplify-order

-                                                (data-lens:key "attributes")))))

+    (data-lens:<>1 (data-lens:denest)

+                   (data-lens:transform-head

+                    (lambda (it)

+                      (list :id it)))

+                   (data-lens:juxt (data-lens:juxt (data-lens:<>1 'normalize-type

+                                                                  (data-lens:key "type"))

+                                                   (data-lens:key "id"))

+                                   (data-lens:<>1 'simplify-order

+                                                  (data-lens:key "attributes")))))

 (defclass test-store (jsonapi-datastore recording-datastore)

   ())

-