      (with-storage [s storage-spec]
        (->>
          (select-transactions-by-entity-id s entity-id parsed-options)
-         (map prepare-for-return)
+         (map after-read)
          (map #(append-items s %)))))))
 
 (defn select-items-by-reconciliation-id
   "Returns the transaction items associated with the specified reconciliation"
   [storage-spec reconciliation-id]
   (with-storage [s storage-spec]
-    (map prepare-item-for-return
+    (map after-item-read
          (select-transaction-items-by-reconciliation-id s reconciliation-id))))
 
 (defn count-by-entity-id

  ([storage-spec account-id options]
   (with-storage [s storage-spec]
     (let [account (accounts/find-by-id storage-spec account-id)]
       (map #(prepare-item-for-return % account)
            (select-transaction-items-by-account-id s
                                                    account-id
                                                    options))))))

              result (->> (assoc validated :items items-with-balances)
                          before-save
                          (create-transaction storage)
                          after-read)
              items (into [] (map #(->> (assoc % :transaction-id (:id result))
                                        before-save-item
                                        (create-transaction-item storage)
                                        after-item-read)
                                  items-with-balances))]
          (assoc result :items items))))))

