diff --git a/backend/src/uxbox/api.clj b/backend/src/uxbox/api.clj
index af29e0a9e..a5a251a93 100644
--- a/backend/src/uxbox/api.clj
+++ b/backend/src/uxbox/api.clj
@@ -12,6 +12,9 @@
             [uxbox.api.middleware :refer [handler router-options]]
             [uxbox.api.auth :as api-auth]
             [uxbox.api.pages :as api-pages]
+            [uxbox.api.users :as api-users]
+            [uxbox.api.icons :as api-icons]
+            [uxbox.api.images :as api-images]
             [uxbox.api.projects :as api-projects]))
 
 ;; --- Top Level Handlers
@@ -44,6 +47,8 @@
      ["/projects/by-token/:token" {:get (handler #'api-projects/get-by-share-token)}]
      ["/projects/:id" {:put (handler #'api-projects/update)
                        :delete (handler #'api-projects/delete)}]
+
+     ;; Pages
      ["/pages" {:get (handler #'api-pages/list)
                 :post (handler #'api-pages/create)}]
      ["/pages/:id" {:put (handler #'api-pages/update)
@@ -51,6 +56,41 @@
      ["/pages/:id/metadata" {:put (handler #'api-pages/update-metadata)}]
      ["/pages/:id/history" {:get (handler #'api-pages/retrieve-history)}]
      ["/pages/:id/history/:hid" {:put (handler #'api-pages/update-history)}]
+
+     ;; Profile
+     ["/profile/me" {:get (handler #'api-users/retrieve-profile)
+                     :put (handler #'api-users/update-profile)}]
+     ["/profile/me/password" {:put (handler #'api-users/update-password)}]
+     ["/profile/me/photo" {:post (handler #'api-users/update-photo)}]
+
+     ;; Library
+     ["/library"
+      ;; Icons
+      ["/icon-collections/:id" {:put (handler #'api-icons/update-collection)
+                                :delete (handler #'api-icons/delete-collection)}]
+      ["/icon-collections" {:get (handler #'api-icons/list-collections)
+                             :post (handler #'api-icons/create-collection)}]
+
+      ["/icons/:id/copy" {:put (handler #'api-icons/copy-icon)}]
+
+      ["/icons/:id" {:put (handler #'api-icons/update-icon)
+                     :delete (handler #'api-icons/delete-icon)}]
+      ["/icons" {:post (handler #'api-icons/create-icon)
+                 :get (handler #'api-icons/list-icons)}]
+
+      ;; Images
+      ["/image-collections/:id" {:put (handler #'api-images/update-collection)
+                                 :delete (handler #'api-images/delete-collection)}]
+      ["/image-collections" {:post (handler #'api-images/create-collection)
+                             :get (handler #'api-images/list-collections)}]
+      ["/images/:id/copy" {:put (handler #'api-images/copy-image)}]
+      ["/images/:id" {:get (handler #'api-images/retrieve-image)
+                      :delete (handler #'api-images/delete-image)
+                      :put (handler #'api-images/update-image)}]
+      ["/images" {:post (handler #'api-images/create-image)
+                  :get (handler #'api-images/list-images)}]
+      ]
+
      ]]
    router-options))
 
diff --git a/backend/src/uxbox/api/icons.clj b/backend/src/uxbox/api/icons.clj
new file mode 100644
index 000000000..78df9dcd0
--- /dev/null
+++ b/backend/src/uxbox/api/icons.clj
@@ -0,0 +1,131 @@
+;; This Source Code Form is subject to the terms of the Mozilla Public
+;; License, v. 2.0. If a copy of the MPL was not distributed with this
+;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
+;;
+;; Copyright (c) 2019 Andrey Antukh <niwi@niwi.nz>
+
+(ns uxbox.api.icons
+  (:require [struct.core :as st]
+            [promesa.core :as p]
+            [uxbox.services :as sv]
+            [uxbox.util.http :as http]
+            [uxbox.util.spec :as us]
+            [uxbox.util.uuid :as uuid]))
+
+(defn create-collection
+  {:parameters {:body {:name [st/required st/string]
+                       :id [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                       :type :create-icon-collection
+                       :user user)]
+    (->> (sv/novelty message)
+         (p/map (fn [result]
+                  (let [loc (str "/api/library/icons/" (:id result))]
+                    (http/created loc result)))))))
+
+(defn update-collection
+  {:parameters {:path {:id [st/required st/uuid-str]}
+                :body {:name [st/required st/string]
+                       :version [st/required st/integer]
+                       :id [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                       :id (get-in parameters [:path :id])
+                       :type :update-icon-collection
+                       :user user)]
+    (-> (sv/novelty message)
+        (p/then #(http/ok %)))))
+
+
+(defn delete-collection
+  {:parameters {:path {:id [st/required st/uuid-str]}}}
+  [{:keys [user parameters]}]
+  (let [message {:id (get-in parameters [:path :id])
+                 :type :delete-icon-collection
+                 :user user}]
+    (-> (sv/novelty message)
+        (p/then (fn [v] (http/no-content))))))
+
+(defn list-collections
+  [{:keys [user]}]
+  (let [params {:user user :type :list-icon-collections}]
+    (-> (sv/query params)
+        (p/then #(http/ok %)))))
+
+;; (def metadata-spec
+;;   {:width [st/number st/positive]
+;;    :height [st/number st/positive]
+;;    :view-box [st/coll [st/every number?]]
+;;    :mimetype [st/string]})
+
+;; (def metadata-validator
+;;   {:message "must be a metadata"
+;;    :optional true
+;;    :validate #(st/valid? %1 metadata-spec)})
+
+(defn create-icon
+  {:parameters {:body {:id [st/uuid]
+                       :collection [st/uuid]
+                       :metadata [st/required] ;; TODO
+                       :name [st/required st/string]
+                       :content [st/required st/string]}}}
+  [{:keys [user parameters]}]
+  (let [id (or (get-in parameters [:body :id]) (uuid/random))
+        data (get parameters :body)
+        message (assoc data
+                       :user user
+                       :id id
+                       :type :create-icon)]
+    (->> (sv/novelty message)
+         (p/map (fn [entry]
+                  (let [loc (str "/api/library/icons/" (:id entry))]
+                    (http/created loc entry)))))))
+
+(defn update-icon
+  {:parameters {:path {:id [st/required st/uuid-str]}
+                :body {:name [st/required st/string]
+                       :version [st/required st/number]
+                       :collection [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                       :id (get-in parameters [:path :id])
+                       :type :update-icon
+                       :user user)]
+    (->> (sv/novelty message)
+         (p/map #(http/ok %)))))
+
+(defn copy-icon
+  {:parameters {:path {:id [st/required st/uuid-str]}
+                :body {:collection [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message {:collection (get-in parameters [:body :collection])
+                 :id (get-in parameters [:path :id])
+                 :user user
+                 :type :copy-icon}]
+    (->> (sv/novelty message)
+         (p/map #(http/ok %)))))
+
+(defn delete-icon
+  {:parameters {:path {:id [st/required st/uuid-str]}}}
+  [{:keys [user parameters]}]
+  (let [message {:id (get-in parameters [:path :id])
+                 :type :delete-icon
+                 :user user}]
+    (->> (sv/novelty message)
+         (p/map (fn [v] (http/no-content))))))
+
+(defn list-icons
+  {:parameters {:query {:collection [st/uuid-str]}}}
+  [{:keys [user parameters]}]
+  (let [collection (get-in parameters [:query :collection])
+        message {:collection collection
+                 :type :list-icons
+                 :user user}]
+    (->> (sv/query message)
+         (p/map http/ok))))
+
diff --git a/backend/src/uxbox/api/images.clj b/backend/src/uxbox/api/images.clj
new file mode 100644
index 000000000..cb93fe920
--- /dev/null
+++ b/backend/src/uxbox/api/images.clj
@@ -0,0 +1,169 @@
+;; This Source Code Form is subject to the terms of the Mozilla Public
+;; License, v. 2.0. If a copy of the MPL was not distributed with this
+;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
+;;
+;; Copyright (c) 2019 Andrey Antukh <niwi@niwi.nz>
+
+(ns uxbox.api.images
+  (:require [struct.core :as st]
+            [promesa.core :as p]
+            [datoteka.storages :as ds]
+            [datoteka.core :as fs]
+            [uxbox.media :as media]
+            [uxbox.images :as images]
+            [uxbox.services :as sv]
+            [uxbox.util.http :as http]
+            [uxbox.util.spec :as us]
+            [uxbox.util.uuid :as uuid]))
+
+(def +thumbnail-options+ {:src :path
+                          :dst :thumbnail
+                          :width 300
+                          :height 100
+                          :quality 92
+                          :format "webp"})
+
+(def populate-thumbnails
+  #(images/populate-thumbnails % +thumbnail-options+))
+
+(def populate-urls
+  #(images/populate-urls % media/images-storage :path :url))
+
+(defn create-collection
+  {:parameters {:body {:name [st/required st/string]
+                       :id [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                       :type :create-image-collection
+                       :user user)]
+    (->> (sv/novelty message)
+         (p/map (fn [result]
+                  (let [loc (str "/api/library/images/" (:id result))]
+                    (http/created loc result)))))))
+
+(defn update-collection
+  {:parameters {:path {:id [st/required st/uuid-str]}
+                :body {:name [st/required st/string]
+                       :version [st/required st/number]
+                       :id [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                       :id (get-in parameters [:path :id])
+                       :type :update-image-collection
+                       :user user)]
+    (-> (sv/novelty message)
+        (p/then http/ok))))
+
+(defn delete-collection
+  {:parameters {:path {:id [st/required st/uuid-str]}}}
+  [{:keys [user parameters]}]
+  (let [message {:id (get-in parameters [:path :id])
+                 :type :delete-image-collection
+                 :user user}]
+    (-> (sv/novelty message)
+        (p/then (constantly (http/no-content))))))
+
+(defn list-collections
+  [{:keys [user]}]
+  (let [params {:user user :type :list-image-collections}]
+    (-> (sv/query params)
+        (p/then http/ok))))
+
+(defn retrieve-image
+  {:parameters {:path {:id [st/required st/uuid-str]}}}
+  [{:keys [user parameters]}]
+  (let [message {:user user
+                 :type :retrieve-image
+                 :id (get-in parameters [:path :id])}]
+    (->> (sv/query message)
+         (p/map (fn [result]
+                  (if result
+                    (-> (populate-thumbnails result)
+                        (populate-urls)
+                        (http/ok))
+                    (http/not-found "")))))))
+
+;; (s/def ::create-image
+;;   (s/keys :req-un [::file ::width ::height ::mimetype]
+;;           :opt-un [::us/id ::collection]))
+
+(defn create-image
+  [{user :identity data :data}]
+  #_(let [{:keys [file id width height
+                mimetype collection]} (us/conform ::create-image data)
+        id (or id (uuid/random))
+        filename (fs/name file)
+        storage media/images-storage]
+    (letfn [(persist-image-entry [path]
+              (sv/novelty {:id id
+                           :type :create-image
+                           :user user
+                           :width width
+                           :height height
+                           :mimetype mimetype
+                           :collection collection
+                           :name filename
+                           :path (str path)}))
+            (create-response [entry]
+              (let [loc (str "/api/library/images/" (:id entry))]
+                (http/created loc (rsp entry))))]
+      (->> (st/save storage filename file)
+           (p/mapcat persist-image-entry)
+           (p/map populate-thumbnails)
+           (p/map populate-urls)
+           (p/map create-response)))))
+
+(defn update-image
+  {:parameters {:path {:id [st/required st/uuid-str]}
+                :body {:name [st/required st/string]
+                       :version [st/required st/number]
+                       :collection [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                       :id (get-in parameters [:path :id])
+                       :type :update-image
+                       :user user)]
+    (->> (sv/novelty message)
+         (p/map populate-thumbnails)
+         (p/map populate-urls)
+         (p/map http/ok))))
+
+(defn copy-image
+  {:parameters {:path {:id [st/required st/uuid-str]}
+                :body {:collection [st/uuid]}}}
+  [{:keys [user parameters]}]
+  (let [message {:id (get-in parameters [:path :id])
+                 :type :copy-image
+                 :collection (get-in parameters [:body :collection])}]
+    (->> (sv/novelty message)
+         (p/map populate-thumbnails)
+         (p/map populate-urls)
+         (p/map http/ok))))
+
+(defn delete-image
+  {:parameters {:path {:id [st/required st/uuid-str]}}}
+  [{:keys [user parameters]}]
+  (let [message {:id (get-in parameters [:path :id])
+                 :type :delete-image
+                 :user user}]
+    (->> (sv/novelty message)
+         (p/map (constantly (http/no-content))))))
+
+;; --- List collections
+
+(defn list-images
+  {:parameters {:query {:collection [st/uuid-str]}}}
+  [{:keys [user parameters]}]
+  (let [collection (get-in parameters [:query :collection])
+        message {:collection collection
+                 :type :list-images
+                 :user user}]
+    (->> (sv/query message)
+         (p/map (partial map populate-thumbnails))
+         (p/map (partial map populate-urls))
+         (p/map http/ok))))
+
+
diff --git a/backend/src/uxbox/api/pages.clj b/backend/src/uxbox/api/pages.clj
index b5dda23ca..ab00b460c 100644
--- a/backend/src/uxbox/api/pages.clj
+++ b/backend/src/uxbox/api/pages.clj
@@ -92,7 +92,7 @@
   {:parameters {:path {:id [st/required st/uuid-str]
                        :hid [st/required st/uuid-str]}
                 :body {:label [st/required st/string]
-                       ::pinned [st/required st/boolean]}}}
+                       :pinned [st/required st/boolean]}}}
   [{:keys [user parameters]}]
   (let [{:keys [id hid]} (get parameters :path)
         message (assoc (get parameters :body)
diff --git a/backend/src/uxbox/api/users.clj b/backend/src/uxbox/api/users.clj
new file mode 100644
index 000000000..755788d3e
--- /dev/null
+++ b/backend/src/uxbox/api/users.clj
@@ -0,0 +1,84 @@
+;; This Source Code Form is subject to the terms of the Mozilla Public
+;; License, v. 2.0. If a copy of the MPL was not distributed with this
+;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
+;;
+;; Copyright (c) 2019 Andrey Antukh <niwi@niwi.nz>
+
+(ns uxbox.api.users
+  (:require [clojure.spec.alpha :as s]
+            [struct.core :as st]
+            [promesa.core :as p]
+            [datoteka.storages :as ds]
+            [datoteka.core :as fs]
+            [uxbox.services :as sv]
+            [uxbox.media :as media]
+            [uxbox.images :as images]
+            [uxbox.util.http :as http]
+            [uxbox.util.spec :as us]
+            [uxbox.util.uuid :as uuid]))
+
+;; --- Helpers
+
+(defn- resolve-thumbnail
+  [user]
+  (let [opts {:src :photo
+              :dst :photo
+              :size [100 100]
+              :quality 90
+              :format "jpg"}]
+    (images/populate-thumbnails user opts)))
+
+(defn retrieve-profile
+  [{:keys [user]}]
+  (let [message {:user user :type :retrieve-profile}]
+    (->> (sv/query message)
+         (p/map resolve-thumbnail)
+         (p/map #(http/ok %)))))
+
+(defn update-profile
+  {:parameters {:body {:username [st/required st/string]
+                       :email [st/required st/email]
+                       :fullname [st/required st/string]
+                       :metadata [st/required]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                       :type :update-profile
+                       :user user)]
+    (->> (sv/novelty message)
+         (p/map resolve-thumbnail)
+         (p/map #(http/ok %)))))
+
+
+(defn update-password
+  {:parameters {:body {:password [st/required st/string]
+                       :old-password [st/required st/string]}}}
+  [{:keys [user parameters]}]
+  (let [data (get parameters :body)
+        message (assoc data
+                      :type :update-profile-password
+                      :user user)]
+    (-> (sv/novelty message)
+        (p/then #(http/ok %)))))
+
+;; TODO: validate {:multipart {:file {:filename "sample.jpg", :content-type "application/octet-stream", :tempfile #file "/tmp/ring-multipart-7913603702731714635.tmp", :size 312043}}}
+
+(defn update-photo
+  {:parameters {:multipart {:file [st/required]}}}
+  [{:keys [user parameters] :as ctx}]
+  (letfn [(store-photo [{:keys [filename tempfile] :as upload}]
+            (let [filename (fs/name filename)
+                  storage media/images-storage]
+              (ds/save storage filename tempfile)))
+          (assign-photo [path]
+            (sv/novelty {:user user
+                         :path (str path)
+                         :type :update-profile-photo}))]
+    (->> (get-in parameters [:multipart :file])
+         (store-photo)
+         (p/mapcat assign-photo)
+         (p/map (constantly (http/no-content))))))
+
+
+
+
diff --git a/backend/src/uxbox/frontend.clj b/backend/src/uxbox/frontend.clj
index 981f22658..dc27a0f3b 100644
--- a/backend/src/uxbox/frontend.clj
+++ b/backend/src/uxbox/frontend.clj
@@ -148,7 +148,6 @@
         [:put "profile/me" #'users/update-profile]
         [:put "profile/me/password" #'users/update-password]
         [:post "profile/me/photo" #'users/update-photo]]]))))
-
 ;; --- State Initialization
 
 (defn- start-server
diff --git a/backend/test/uxbox/tests/test_icons.clj b/backend/test/uxbox/tests/test_icons.clj
index 3d93d65cc..c158f1c9d 100644
--- a/backend/test/uxbox/tests/test_icons.clj
+++ b/backend/test/uxbox/tests/test_icons.clj
@@ -2,162 +2,160 @@
   (:require [clojure.test :as t]
             [promesa.core :as p]
             [suricatta.core :as sc]
-            [clj-uuid :as uuid]
-            [clojure.java.io :as io]
-            [catacumba.testing :refer (with-server)]
-            [buddy.core.codecs :as codecs]
             [uxbox.db :as db]
             [uxbox.sql :as sql]
-            [uxbox.frontend :as uft]
+            [uxbox.api :as uapi]
             [uxbox.services.icons :as icons]
             [uxbox.services :as usv]
             [uxbox.tests.helpers :as th]))
 
-;; (t/use-fixtures :each th/database-reset)
+(t/use-fixtures :each th/database-reset)
 
-;; (t/deftest test-http-list-icon-collections
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "coll1"}
-;;           coll (icons/create-collection conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icon-collections")
-;;               [status data] (th/http-get user uri)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= 1 (count data))))))))
+(t/deftest test-http-list-icon-collections
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "coll1"}
+          coll (icons/create-collection conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icon-collections")
+              [status data] (th/http-get user uri)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= 1 (count data))))))))
 
-;; (t/deftest test-http-create-icon-collection
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icon-collections")
-;;               data {:user (:id user)
-;;                     :name "coll1"}
-;;               params {:body data}
-;;               [status data] (th/http-post user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 201 status))
-;;           (t/is (= (:user data) (:id user)))
-;;           (t/is (= (:name data) "coll1")))))))
+(t/deftest test-http-create-icon-collection
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icon-collections")
+              data {:user (:id user)
+                    :name "coll1"}
+              params {:body data}
+              [status data] (th/http-post user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 201 status))
+          (t/is (= (:user data) (:id user)))
+          (t/is (= (:name data) "coll1")))))))
 
-;; (t/deftest test-http-update-icon-collection
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "coll1"}
-;;           coll (icons/create-collection conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
-;;               params {:body (assoc coll :name "coll2")}
-;;               [status data] (th/http-put user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= (:user data) (:id user)))
-;;           (t/is (= (:name data) "coll2")))))))
+(t/deftest test-http-update-icon-collection
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "coll1"}
+          coll (icons/create-collection conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
+              params {:body (assoc coll :name "coll2")}
+              [status data] (th/http-put user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= (:user data) (:id user)))
+          (t/is (= (:name data) "coll2")))))))
 
-;; (t/deftest test-http-icon-collection-delete
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "coll1"
-;;                 :data #{1}}
-;;           coll (icons/create-collection conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
-;;               [status data] (th/http-delete user uri)]
-;;           (t/is (= 204 status))
-;;           (let [sqlv (sql/get-icon-collections {:user (:id user)})
-;;                 result (sc/fetch conn sqlv)]
-;;             (t/is (empty? result))))))))
+(t/deftest test-http-icon-collection-delete
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "coll1"
+                :data #{1}}
+          coll (icons/create-collection conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
+              [status data] (th/http-delete user uri)]
+          (t/is (= 204 status))
+          (let [sqlv (sql/get-icon-collections {:user (:id user)})
+                result (sc/fetch conn sqlv)]
+            (t/is (empty? result))))))))
 
-;; (t/deftest test-http-create-icon
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icons")
-;;               data {:name "sample.jpg"
-;;                     :content "<g></g>"
-;;                     :metadata {:width 200
-;;                                :height 200
-;;                                :view-box [0 0 200 200]}
-;;                     :collection nil}
-;;               params {:body data}
-;;               [status data] (th/http-post user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 201 status))
-;;           (t/is (= (:user data) (:id user)))
-;;           (t/is (= (:name data) "sample.jpg"))
-;;           (t/is (= (:metadata data) {:width 200
-;;                                      :height 200
-;;                                      :view-box [0 0 200 200]})))))))
+(t/deftest test-http-create-icon
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icons")
+              data {:name "sample.jpg"
+                    :content "<g></g>"
+                    :metadata {:width 200
+                               :height 200
+                               :view-box [0 0 200 200]}
+                    :collection nil}
+              params {:body data}
+              [status data] (th/http-post user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 201 status))
+          (t/is (= (:user data) (:id user)))
+          (t/is (= (:name data) "sample.jpg"))
+          (t/is (= (:metadata data) {:width 200
+                                     :height 200
+                                     :view-box [0 0 200 200]})))))))
 
-;; (t/deftest test-http-update-icon
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "test.svg"
-;;                 :content "<g></g>"
-;;                 :metadata {}
-;;                 :collection nil}
-;;           icon (icons/create-icon conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
-;;               params {:body (assoc icon :name "my stuff")}
-;;               [status data] (th/http-put user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= (:user data) (:id user)))
-;;           (t/is (= (:name data) "my stuff")))))))
+(t/deftest test-http-update-icon
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "test.svg"
+                :content "<g></g>"
+                :metadata {}
+                :collection nil}
+          icon (icons/create-icon conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
+              params {:body (assoc icon :name "my stuff")}
+              [status data] (th/http-put user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= (:user data) (:id user)))
+          (t/is (= (:name data) "my stuff")))))))
 
-;; (t/deftest test-http-copy-icon
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "test.svg"
-;;                 :content "<g></g>"
-;;                 :metadata {}
-;;                 :collection nil}
-;;           icon (icons/create-icon conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icons/copy")
-;;               body {:id (:id icon) :collection nil}
-;;               params {:body body}
-;;               [status data] (th/http-put user uri params)]
-;;           (println "RESPONSE:" status data)
-;;           (let [sqlv (sql/get-icons {:user (:id user) :collection nil})
-;;                 result (sc/fetch conn sqlv)]
-;;             (t/is (= 2 (count result)))))))))
+(t/deftest test-http-copy-icon
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "test.svg"
+                :content "<g></g>"
+                :metadata {}
+                :collection nil}
+          icon (icons/create-icon conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icons/" (:id icon) "/copy")
+              body {:collection nil}
+              params {:body body}
+              [status data] (th/http-put user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= status 200))
+          (let [sqlv (sql/get-icons {:user (:id user) :collection nil})
+                result (sc/fetch conn sqlv)]
+            (t/is (= 2 (count result)))))))))
 
-;; (t/deftest test-http-delete-icon
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "test.svg"
-;;                 :content "<g></g>"
-;;                 :metadata {}
-;;                 :collection nil}
-;;           icon (icons/create-icon conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
-;;               [status data] (th/http-delete user uri)]
-;;           (t/is (= 204 status))
-;;           (let [sqlv (sql/get-icons {:user (:id user) :collection nil})
-;;                 result (sc/fetch conn sqlv)]
-;;             (t/is (empty? result))))))))
+(t/deftest test-http-delete-icon
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "test.svg"
+                :content "<g></g>"
+                :metadata {}
+                :collection nil}
+          icon (icons/create-icon conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
+              [status data] (th/http-delete user uri)]
+          (t/is (= 204 status))
+          (let [sqlv (sql/get-icons {:user (:id user) :collection nil})
+                result (sc/fetch conn sqlv)]
+            (t/is (empty? result))))))))
 
-;; ;; (t/deftest test-http-list-icons
-;; ;;   (with-open [conn (db/connection)]
-;; ;;     (let [user (th/create-user conn 1)
-;; ;;           data {:user (:id user)
-;; ;;                 :name "test.png"
-;; ;;                 :path "some/path"
-;; ;;                 :collection nil}
-;; ;;           icon (icons/create-icon conn data)]
-;; ;;       (with-server {:handler (uft/routes)}
-;; ;;         (let [uri (str th/+base-url+ "/api/library/icons")
-;; ;;               [status data] (th/http-get user uri)]
-;; ;;           (println "RESPONSE:" status data)
-;; ;;           (t/is (= 200 status))
-;; ;;           (t/is (= 1 (count data))))))))
+(t/deftest test-http-list-icons
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "test.png"
+                :content "<g></g>"
+                :metadata {}
+                :collection nil}
+          icon (icons/create-icon conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/icons")
+              [status data] (th/http-get user uri)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= 1 (count data))))))))
diff --git a/backend/test/uxbox/tests/test_images.clj b/backend/test/uxbox/tests/test_images.clj
index 51bb9b3c6..4c7b8cd2a 100644
--- a/backend/test/uxbox/tests/test_images.clj
+++ b/backend/test/uxbox/tests/test_images.clj
@@ -3,74 +3,73 @@
             [promesa.core :as p]
             [suricatta.core :as sc]
             [clojure.java.io :as io]
-            [catacumba.testing :refer (with-server)]
             [datoteka.storages :as st]
             [uxbox.db :as db]
             [uxbox.sql :as sql]
             [uxbox.media :as media]
-            [uxbox.frontend :as uft]
+            [uxbox.api :as uapi]
             [uxbox.services.images :as images]
             [uxbox.services :as usv]
             [uxbox.tests.helpers :as th]))
 
-;; (t/use-fixtures :each th/database-reset)
+(t/use-fixtures :each th/database-reset)
 
-;; (t/deftest test-http-list-image-collections
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "coll1"}
-;;           coll (images/create-collection conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/image-collections")
-;;               [status data] (th/http-get user uri)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= 1 (count data))))))))
+(t/deftest test-http-list-image-collections
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "coll1"}
+          coll (images/create-collection conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/image-collections")
+              [status data] (th/http-get user uri)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= 1 (count data))))))))
 
-;; (t/deftest test-http-create-image-collection
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/image-collections")
-;;               data {:user (:id user)
-;;                     :name "coll1"}
-;;               params {:body data}
-;;               [status data] (th/http-post user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 201 status))
-;;           (t/is (= (:user data) (:id user)))
-;;           (t/is (= (:name data) "coll1")))))))
+(t/deftest test-http-create-image-collection
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/image-collections")
+              data {:user (:id user)
+                    :name "coll1"}
+              params {:body data}
+              [status data] (th/http-post user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 201 status))
+          (t/is (= (:user data) (:id user)))
+          (t/is (= (:name data) "coll1")))))))
 
-;; (t/deftest test-http-update-image-collection
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "coll1"}
-;;           coll (images/create-collection conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
-;;               params {:body (assoc coll :name "coll2")}
-;;               [status data] (th/http-put user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= (:user data) (:id user)))
-;;           (t/is (= (:name data) "coll2")))))))
+(t/deftest test-http-update-image-collection
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "coll1"}
+          coll (images/create-collection conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
+              params {:body (assoc coll :name "coll2")}
+              [status data] (th/http-put user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= (:user data) (:id user)))
+          (t/is (= (:name data) "coll2")))))))
 
-;; (t/deftest test-http-image-collection-delete
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "coll1"
-;;                 :data #{1}}
-;;           coll (images/create-collection conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
-;;               [status data] (th/http-delete user uri)]
-;;           (t/is (= 204 status))
-;;           (let [sqlv (sql/get-image-collections {:user (:id user)})
-;;                 result (sc/fetch conn sqlv)]
-;;             (t/is (empty? result))))))))
+(t/deftest test-http-image-collection-delete
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "coll1"
+                :data #{1}}
+          coll (images/create-collection conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
+              [status data] (th/http-delete user uri)]
+          (t/is (= 204 status))
+          (let [sqlv (sql/get-image-collections {:user (:id user)})
+                result (sc/fetch conn sqlv)]
+            (t/is (empty? result))))))))
 
 ;; ;; (t/deftest test-http-create-image
 ;; ;;   (with-open [conn (db/connection)]
@@ -87,83 +86,86 @@
 ;; ;;           (t/is (= (:user data) (:id user)))
 ;; ;;           (t/is (= (:name data) "sample.jpg")))))))
 
-;; (t/deftest test-http-update-image
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "test.png"
-;;                 :path "some/path"
-;;                 :width 100
-;;                 :height 100
-;;                 :mimetype "image/png"
-;;                 :collection nil}
-;;           img (images/create-image conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/images/" (:id img))
-;;               params {:body (assoc img :name "my stuff")}
-;;               [status data] (th/http-put user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= (:user data) (:id user)))
-;;           (t/is (= (:name data) "my stuff")))))))
+(t/deftest test-http-update-image
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "test.png"
+                :path "some/path"
+                :width 100
+                :height 100
+                :mimetype "image/png"
+                :collection nil}
+          img (images/create-image conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/images/" (:id img))
+              params {:body (assoc img :name "my stuff")}
+              [status data] (th/http-put user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= (:user data) (:id user)))
+          (t/is (= (:name data) "my stuff")))))))
 
-;; (t/deftest test-http-copy-image
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           storage media/images-storage
-;;           filename "sample.jpg"
-;;           rcs (io/resource "uxbox/tests/_files/sample.jpg")
-;;           path @(st/save storage filename rcs)
-;;           data {:user (:id user)
-;;                 :name filename
-;;                 :path (str path)
-;;                 :width 100
-;;                 :height 100
-;;                 :mimetype "image/jpg"
-;;                 :collection nil}
-;;           img (images/create-image conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/images/copy")
-;;               body {:id (:id img)
-;;                     :collection nil}
-;;               params {:body body}
-;;               [status data] (th/http-put user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (let [sqlv (sql/get-images {:user (:id user) :collection nil})
-;;                 result (sc/fetch conn sqlv)]
-;;             (t/is (= 2 (count result)))))))))
+(t/deftest test-http-copy-image
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          storage media/images-storage
+          filename "sample.jpg"
+          rcs (io/resource "uxbox/tests/_files/sample.jpg")
+          path @(st/save storage filename rcs)
+          data {:user (:id user)
+                :name filename
+                :path (str path)
+                :width 100
+                :height 100
+                :mimetype "image/jpg"
+                :collection nil}
+          img (images/create-image conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/images/" (:id img) "/copy")
+              body {:id (:id img)
+                    :collection nil}
+              params {:body body}
+              [status data] (th/http-put user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (let [sqlv (sql/get-images {:user (:id user) :collection nil})
+                result (sc/fetch conn sqlv)]
+            (t/is (= 2 (count result)))))))))
 
-;; (t/deftest test-http-delete-image
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)
-;;           data {:user (:id user)
-;;                 :name "test.png"
-;;                 :path "some/path"
-;;                 :width 100
-;;                 :height 100
-;;                 :mimetype "image/png"
-;;                 :collection nil}
-;;           img (images/create-image conn data)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/library/images/" (:id img))
-;;               [status data] (th/http-delete user uri)]
-;;           (t/is (= 204 status))
-;;           (let [sqlv (sql/get-images {:user (:id user) :collection nil})
-;;                 result (sc/fetch conn sqlv)]
-;;             (t/is (empty? result))))))))
+(t/deftest test-http-delete-image
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "test.png"
+                :path "some/path"
+                :width 100
+                :height 100
+                :mimetype "image/png"
+                :collection nil}
+          img (images/create-image conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/images/" (:id img))
+              [status data] (th/http-delete user uri)]
+          (t/is (= 204 status))
+          (let [sqlv (sql/get-images {:user (:id user) :collection nil})
+                result (sc/fetch conn sqlv)]
+            (t/is (empty? result))))))))
 
-;; ;; (t/deftest test-http-list-images
-;; ;;   (with-open [conn (db/connection)]
-;; ;;     (let [user (th/create-user conn 1)
-;; ;;           data {:user (:id user)
-;; ;;                 :name "test.png"
-;; ;;                 :path "some/path"
-;; ;;                 :collection nil}
-;; ;;           img (images/create-image conn data)]
-;; ;;       (with-server {:handler (uft/routes)}
-;; ;;         (let [uri (str th/+base-url+ "/api/library/images")
-;; ;;               [status data] (th/http-get user uri)]
-;; ;;           (println "RESPONSE:" status data)
-;; ;;           (t/is (= 200 status))
-;; ;;           (t/is (= 1 (count data))))))))
+(t/deftest test-http-list-images
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)
+          data {:user (:id user)
+                :name "test.png"
+                :path "some/path"
+                :width 100
+                :height 100
+                :mimetype "image/png"
+                :collection nil}
+          img (images/create-image conn data)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/library/images")
+              [status data] (th/http-get user uri)]
+          (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= 1 (count data))))))))
diff --git a/backend/test/uxbox/tests/test_users.clj b/backend/test/uxbox/tests/test_users.clj
index fdc03fa6f..7f39acd04 100644
--- a/backend/test/uxbox/tests/test_users.clj
+++ b/backend/test/uxbox/tests/test_users.clj
@@ -5,60 +5,59 @@
             [buddy.hashers :as hashers]
             [clj-http.client :as http]
             [suricatta.core :as sc]
-            [catacumba.testing :refer (with-server)]
             [uxbox.db :as db]
-            [uxbox.frontend :as uft]
+            [uxbox.api :as uapi]
             [uxbox.services.users :as usu]
             [uxbox.services :as usv]
             [uxbox.tests.helpers :as th]))
 
 (t/use-fixtures :each th/database-reset)
 
-;; (t/deftest test-http-retrieve-profile
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/profile/me")
-;;               [status data] (th/http-get user uri)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= (:fullname data) "User 1"))
-;;           (t/is (= (:username data) "user1"))
-;;           (t/is (= (:metadata data) "1"))
-;;           (t/is (= (:email data) "user1@uxbox.io"))
-;;           (t/is (not (contains? data :password))))))))
+(t/deftest test-http-retrieve-profile
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/profile/me")
+              [status data] (th/http-get user uri)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= (:fullname data) "User 1"))
+          (t/is (= (:username data) "user1"))
+          (t/is (= (:metadata data) "1"))
+          (t/is (= (:email data) "user1@uxbox.io"))
+          (t/is (not (contains? data :password))))))))
 
-;; (t/deftest test-http-update-profile
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/profile/me")
-;;               data (assoc user
-;;                           :fullname "Full Name"
-;;                           :username "user222"
-;;                           :metadata "222"
-;;                           :email "user222@uxbox.io")
-;;               [status data] (th/http-put user uri {:body data})]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 200 status))
-;;           (t/is (= (:fullname data) "Full Name"))
-;;           (t/is (= (:username data) "user222"))
-;;           (t/is (= (:metadata data) "222"))
-;;           (t/is (= (:email data) "user222@uxbox.io"))
-;;           (t/is (not (contains? data :password))))))))
+(t/deftest test-http-update-profile
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/profile/me")
+              data (assoc user
+                          :fullname "Full Name"
+                          :username "user222"
+                          :metadata "222"
+                          :email "user222@uxbox.io")
+              [status data] (th/http-put user uri {:body data})]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 200 status))
+          (t/is (= (:fullname data) "Full Name"))
+          (t/is (= (:username data) "user222"))
+          (t/is (= (:metadata data) "222"))
+          (t/is (= (:email data) "user222@uxbox.io"))
+          (t/is (not (contains? data :password))))))))
 
-;; (t/deftest test-http-update-profile-photo
-;;   (with-open [conn (db/connection)]
-;;     (let [user (th/create-user conn 1)]
-;;       (with-server {:handler (uft/routes)}
-;;         (let [uri (str th/+base-url+ "/api/profile/me/photo")
-;;               params [{:name "sample.jpg"
-;;                        :part-name "file"
-;;                        :content (io/input-stream
-;;                                  (io/resource "uxbox/tests/_files/sample.jpg"))}]
-;;               [status data] (th/http-multipart user uri params)]
-;;           ;; (println "RESPONSE:" status data)
-;;           (t/is (= 204 status)))))))
+(t/deftest test-http-update-profile-photo
+  (with-open [conn (db/connection)]
+    (let [user (th/create-user conn 1)]
+      (th/with-server {:handler uapi/app}
+        (let [uri (str th/+base-url+ "/api/profile/me/photo")
+              params [{:name "sample.jpg"
+                       :part-name "file"
+                       :content (io/input-stream
+                                 (io/resource "uxbox/tests/_files/sample.jpg"))}]
+              [status data] (th/http-multipart user uri params)]
+          ;; (println "RESPONSE:" status data)
+          (t/is (= 204 status)))))))
 
 ;; (t/deftest test-http-register-user
 ;;   (with-server {:handler (uft/routes)}