removed konserve, because of outdated dependencies. Reused the konserve api

Author: Timo-Linde

project.clj

@@ -9,12 +9,7 @@
                  [ring "1.9.5"]
                  [ring-middleware-format "0.7.4"]
                  [ring/ring-defaults "0.3.3"]
-                 [metosin/spec-tools "0.10.5"]
-
-                 [org.clojure/core.async "1.5.648"]
-                 [io.replikativ/konserve "0.7.270" :exclusions
-                  [org.clojure/clojurescript
-                   org.clojure/tools.analyzer.jvm]]]
+                 [metosin/spec-tools "0.10.5"]]
   :main ^:skip-aot todo-api.core
   :target-path "target/%s"
   :profiles {:uberjar {:aot :all}})

src/todo_api/middleware/catch_spec.clj

@@ -16,4 +16,5 @@
         (let [{:keys [type msg]} (ex-data ex)]
           (case type
             :invalid-spec (rr/not-found msg)
+            :invalid-key (rr/not-found msg)
             (handle-unknown-error ex)))))))

src/todo_api/storage/api.clj

@@ -1,7 +1,41 @@
-(ns todo-api.storage.api)
+(ns todo-api.storage.api
+  (:refer-clojure :exclude [get get-in update update-in assoc assoc-in exists? dissoc keys]))
 
+(def implementation
+  (constantly
+    #_:edn-file
+    :atom))
+
+(defmulti assoc
+  implementation)
+
+(defmulti dissoc
+  implementation)
+
+(defmulti get
+  implementation)
+
+(defmulti update
+  implementation)
+
+(defmulti assoc-in
+  implementation)
+
+(defmulti get-in
+  implementation)
+
+(defmulti update-in
+  implementation)
+
+(defmulti exists?
+  implementation)
+
+(defmulti keys
+  implementation)
+
+;;; Remove Old implementation:
 (defmulti fetch
-  (constantly :edn-file))
+  implementation)
 
 (defmulti persist
-  (constantly :edn-file))
+  implementation)

src/todo_api/storage/atom.clj

@@ -2,12 +2,86 @@
   (:require
     [todo-api.storage.api :as api]))
 
-(def ^:private todos (atom {}))
+(def ^:private store (atom {}))
+
+(defn- fetch
+  []
+  @store)
+
+(defn- persist
+  [new-store]
+  (reset! store new-store))
+
+(defn- with-fetch-persist
+  [f]
+  (-> (fetch)
+    (f)
+    (persist)))
+
+(defn- with-fetch
+  [f]
+  (f (fetch)))
+
+(defmethod api/assoc :atom
+  [k v]
+  (with-fetch-persist
+    (fn [store]
+      (assoc store k v))))
+
+(defmethod api/dissoc :atom
+  [k]
+  (with-fetch-persist
+    (fn [store]
+      (dissoc store k))))
+
+(defmethod api/get :atom
+  [k]
+  (with-fetch
+    (fn [store]
+      (get store k))))
+
+(defmethod api/update :atom
+  [k f & args]
+  (with-fetch-persist
+    (fn [store]
+      (apply update store k f args))))
+
+(defmethod api/assoc-in :atom
+  [ks v]
+  (with-fetch-persist
+    (fn [store]
+      (assoc-in store ks v))))
+
+(defmethod api/get-in :atom
+  [ks]
+  (with-fetch
+    (fn [store]
+      (get-in store ks))))
+
+(defmethod api/update-in :atom
+  [ks f & args]
+  (with-fetch-persist
+    (fn [store]
+      (apply update-in store ks f args))))
+
+(defmethod api/exists? :atom
+  [k]
+  (with-fetch
+    (fn [store]
+      (->> (if (vector? k) k (vector k))
+        (get-in store)
+        (some?)))))
+
+(defmethod api/keys :atom
+  []
+  (with-fetch
+    (fn [store]
+      (keys store))))
 
 (defmethod api/fetch :atom
   []
-  @todos)
+  (fetch))
 
 (defmethod api/persist :atom
-  [new-todos]
-  (reset! todos new-todos))
+  [new-store]
+  (persist new-store))

src/todo_api/storage/konserve.clj

@@ -0,0 +1,9 @@
+(ns todo-api.storage.utils
+  (:require [todo-api.storage.api :as store]))
+
+(defn check-key-exist-or-throw
+  [key]
+  (when-not (store/exists? key)
+    (throw
+      (ex-info "Key invalid!" {:type :invalid-key
+                               :msg  (str "Key not found: '" key "'")}))))

src/todo_api/storage/utils.clj

@@ -1,47 +1,45 @@
 (ns todo-api.task.api
   (:require
     [todo-api.spec-tools :as spec-tools]
-    [todo-api.storage.api :refer [fetch persist]]
+    [todo-api.storage.api :as storage]
+    [todo-api.storage.atom]
+    [todo-api.storage.utils :refer [check-key-exist-or-throw]]
     [todo-api.task.spec :as task-spec]
     [todo-api.todo.api :as todo-api]
     [todo-api.todo.spec :as todo-spec]))
 
 (defn create-task
   [todo-id name]
   (spec-tools/check-spec-or-throw ::todo-spec/id todo-id)
-  (let [new-task
-        {:id   (random-uuid)
-         :name name}]
+  (let [task-id (random-uuid)
+        new-task {:name name}]
     (spec-tools/check-spec-or-throw ::task-spec/task new-task)
-    (-> (fetch)
-      (assoc-in [todo-id :tasks (:id new-task)]
-        (dissoc new-task :id))
-      (persist))))
+    (storage/assoc-in [todo-id :tasks task-id] new-task)
+    task-id))
 
 (defn read-task
   [todo-id task-id]
   (spec-tools/check-spec-or-throw ::todo-spec/id todo-id)
   (spec-tools/check-spec-or-throw ::task-spec/id task-id)
-  (-> (fetch)
-    (get-in [todo-id :tasks task-id])))
+  (check-key-exist-or-throw [todo-id :tasks task-id])
+  (->> (storage/get-in [todo-id :tasks task-id])
+    (assoc :id task-id)))
 
 (defn update-task
   [todo-id task-id name]
   (spec-tools/check-spec-or-throw ::todo-spec/id todo-id)
   (spec-tools/check-spec-or-throw ::task-spec/id task-id)
   (spec-tools/check-spec-or-throw ::task-spec/name name)
-  (-> (fetch)
-    (update-in [todo-id :tasks task-id]
-      assoc :name name)
-    (persist)))
+  (check-key-exist-or-throw [todo-id :tasks task-id])
+  (storage/update-in [todo-id :tasks task-id] assoc :name name))
 
 (defn delete-task
   [todo-id task-id]
   (spec-tools/check-spec-or-throw ::todo-spec/id todo-id)
   (spec-tools/check-spec-or-throw ::task-spec/id task-id)
-  (-> (fetch)
-    (update-in [todo-id :tasks] dissoc task-id)
-    (persist)))
+  (check-key-exist-or-throw [todo-id :tasks task-id])
+  (storage/update-in [todo-id :tasks]
+    dissoc task-id))
 
 (defn list-tasks
   [todo-id]

src/todo_api/task/api.clj

@@ -1,8 +1,9 @@
 (ns todo-api.todo.api
   (:require
-    [konserve.core :as k]
     [todo-api.spec-tools :as spec-tools]
-    [todo-api.storage.konserve :refer [check-key-exist-or-throw opts store]]
+    [todo-api.storage.utils :refer [check-key-exist-or-throw]]
+    [todo-api.storage.api :as store]
+    [todo-api.storage.atom]
     [todo-api.todo.spec :as todo-spec]))
 
 (defn- update-todo-entry
@@ -17,30 +18,31 @@
         new-todo {:name        name
                   :description description}]
     (spec-tools/check-spec-or-throw ::todo-spec/todo new-todo)
-    (k/assoc store id new-todo opts)
+    (store/assoc id new-todo)
     id))
 
 (defn read-todo
   [id]
   (spec-tools/check-spec-or-throw ::todo-spec/id id)
-  (check-key-exist-or-throw store id)
-  (k/get store id opts))
+  (check-key-exist-or-throw id)
+  (-> (store/get id)
+    (assoc :id id)))
 
 (defn update-todo
   [id name description]
   (spec-tools/check-spec-or-throw ::todo-spec/todo
     {:name name
      :description description})
-  (check-key-exist-or-throw store id)
-  (k/update store id #(update-todo-entry % name description) opts))
+  (check-key-exist-or-throw id)
+  (store/update id #(update-todo-entry % name description)))
 
 (defn delete-todo
   [id]
   (spec-tools/check-spec-or-throw ::todo-spec/id id)
-  (check-key-exist-or-throw store id)
-  (k/dissoc store id opts))
+  (check-key-exist-or-throw id)
+  (store/dissoc id))
 
 (defn list-todos
   []
-  (let [keys (k/keys store opts)]
+  (let [keys (store/keys)]
     (map read-todo keys)))