                                           {:transaction-id id
                                            :transaction-date transaction-date}
                                           {:sort [[:action :desc] [:amount :desc]]})
-                (map after-item-read)))))
+                (mapv after-item-read)))))
 
 (defn- append-lot-items
   [transaction storage]

                                    (concat upserted-items
                                            dereferenced-base-items)
                                    (:transaction-date validated))
          (reload storage validated))))))

(defn- get-preceding-items
  "Returns the items that precede each item in the

    (let [validated (validate storage ::existing-transaction transaction)]
      (if (validation/has-error? validated)
        validated
        (let [existing (find-by-id storage (:id validation) (:transaction-date validated))
              dereferenced-items (remove (fn [{validated-item-id :id}]
                                           (some #(= validated-item-id
                                                     (:id existing-item))
                                                 (:items validated)))
                                         (:items existing))
              dereferenced-base-items (map #())
              updated (update-transaction storage validated)
              ])
        )

        #_(let [dereferenced-base-items (process-removals
                                        storage
                                        validated)
              upserted-items (->> (:items validated)
