♻️ Minor refactor of persistence layer.

backend/resources/migrations/0011-add-session-id-field-to-page-change-table.sql

@@ -0,0 +1,2 @@
+ALTER TABLE page_change
+  ADD COLUMN session_id uuid DEFAULT NULL;

backend/src/uxbox/migrations.clj

@@ -55,7 +55,11 @@
 
     {:desc "Add new HTTP session table"
      :name "0010-add-http-session-table"
-     :fn (mg/resource "migrations/0010-add-http-session-table.sql")}]})
+     :fn (mg/resource "migrations/0010-add-http-session-table.sql")}
+
+    {:desc "Add session_id field to page_change table"
+     :name "0011-add-session-id-field-to-page-change-table"
+     :fn (mg/resource "migrations/0011-add-session-id-field-to-page-change-table.sql")}]})
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Entry point

backend/src/uxbox/services/mutations/pages.clj

@@ -178,14 +178,14 @@
                         :stored-revn (:revn page)}))
   (let [sid      (:session-id params)
         changes  (:changes params)
-
         page     (-> page
                      (update :data blob/decode)
                      (update :data pmg/migrate-data)
                      (update :data cp/process-changes changes)
                      (update :data blob/encode)
                      (update :revn inc)
-                 (assoc :changes (blob/encode changes)))
+                     (assoc :changes (blob/encode changes)
+                            :session-id sid))
 
         chng     (insert-page-change! conn page)
         msg      {:type :page-change
@@ -206,11 +206,12 @@
     (retrieve-lagged-changes conn chng params)))
 
 (defn- insert-page-change!
-  [conn {:keys [revn data changes] :as page}]
+  [conn {:keys [revn data changes session-id] :as page}]
   (let [id (uuid/next)
         page-id (:id page)]
     (db/insert! conn :page-change
                 {:id id
+                 :session-id session-id
                  :page-id page-id
                  :revn revn
                  :data data
@@ -218,7 +219,8 @@
 
 (def ^:private
   sql:lagged-changes
-  "select s.id, s.changes
+  "select s.id, s.revn, s.page_id,
+          s.session_id, s.changes
      from page_change as s
     where s.page_id = ?
       and s.revn > ?
@@ -226,13 +228,8 @@
 
 (defn- retrieve-lagged-changes
   [conn snapshot params]
-  (let [rows (db/exec! conn [sql:lagged-changes (:id params) (:revn params)])]
+  (->> (db/exec! conn [sql:lagged-changes (:id params) (:revn params)])
-    {:page-id (:id params)
+       (mapv decode-row)))
-     :revn (:revn snapshot)
-     :changes (into [] (comp (map decode-row)
-                             (map :changes)
-                             (mapcat identity))
-                    rows)}))
 
 ;; --- Mutation: Delete Page
 

common/uxbox/common/spec.cljc

@@ -106,6 +106,7 @@
 (s/def ::integer (s/conformer integer-conformer str))
 (s/def ::not-empty-string (s/and string? #(not (str/empty? %))))
 (s/def ::url string?)
+(s/def ::fn fn?)
 #?(:clj (s/def ::path (s/conformer path-conformer str)))
 
 ;; --- Macros

frontend/src/uxbox/main/data/workspace.cljs

@@ -42,10 +42,6 @@
 ;; --- Specs
 
 (s/def ::shape-attrs ::cp/shape-attrs)
-
-(s/def ::set-of-uuid
-  (s/every uuid? :kind set?))
-
 (s/def ::set-of-string
   (s/every string? :kind set?))
 
@@ -186,10 +182,11 @@
   (ptk/reify ::initialize-group-check
     ptk/WatchEvent
     (watch [_ state stream]
-      ;; TODO: add stoper
+      (let [stoper (rx/filter (ptk/type? ::finalize-page) stream)]
         (->> stream
              (rx/filter #(satisfies? dwc/IUpdateGroup %))
-           (rx/map #(adjust-group-shapes (dwc/get-ids %)))))))
+             (rx/map #(adjust-group-shapes (dwc/get-ids %)))
+             (rx/take-until stoper))))))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -280,11 +277,17 @@
                                           (assoc :left-offset left-offset)))))))))))
 
 
+;; TODO: this event is mainly replaced by `:reg-objects` change, but many events
+;; are still implemented in function of this so we need to maintain it until
+;; all is ported to use `:reg-objects`.
+
+;; TODO: Additioanlly: many stuff related to rotation is not ported so
+;; we need to port it before completelly remove this.
+
 (defn adjust-group-shapes
   [ids]
   (ptk/reify ::adjust-group-shapes
     dwc/IBatchedChange
-
     ptk/UpdateEvent
     (update [_ state]
       (let [page-id (:current-page-id state)
@@ -570,69 +573,7 @@
   (ptk/reify ::update-shape
     ptk/WatchEvent
     (watch [_ state stream]
-      (let [page-id (:current-page-id state)
+      (rx/of (dwc/update-shapes [id] #(merge % attrs))))))
-            object  (get-in state [:workspace-data page-id :objects id])
-            nobject (merge object attrs)
-            rops    (dwc/generate-operations object nobject)
-            uops    (dwc/generate-operations nobject object)
-            rchg    {:type :mod-obj
-                     :operations rops
-                     :id id}
-            uchg    {:type :mod-obj
-                     :operations uops
-                     :id id}]
-        (rx/of (dwc/commit-changes [rchg] [uchg] {:commit-local? true}))))))
-
-(defn update-shapes-recursive
-  [ids attrs]
-  (us/verify ::shape-attrs attrs)
-  (letfn [(impl-update [shape]
-            (cond-> (merge shape attrs)
-              (and (= :text (:type shape))
-                   (string? (:fill-color attrs)))
-              (dwtxt/impl-update-shape-attrs {:fill (:fill-color attrs)})))
-
-          (impl-get-children [objects id]
-            (cons id (cph/get-children id objects)))
-
-          (impl-gen-changes [objects ids]
-            (loop [sids (seq ids)
-                   cids (seq (impl-get-children objects (first sids)))
-                   rchanges []
-                   uchanges []]
-              (cond
-                (nil? sids)
-                [rchanges uchanges]
-
-                (nil? cids)
-                (recur (next sids)
-                       (seq (impl-get-children objects (first (next sids))))
-                       rchanges
-                       uchanges)
-
-                :else
-                (let [id   (first cids)
-                      obj1 (get objects id)
-                      obj2 (impl-update obj1)
-                      rops (dwc/generate-operations obj1 obj2)
-                      uops (dwc/generate-operations obj2 obj1)
-                      rchg {:type :mod-obj
-                            :operations rops
-                            :id id}
-                      uchg {:type :mod-obj
-                            :operations uops
-                            :id id}]
-                  (recur sids
-                         (next cids)
-                         (conj rchanges rchg)
-                         (conj uchanges uchg))))))]
-    (ptk/reify ::update-shapes-recursive
-      ptk/WatchEvent
-      (watch [_ state stream]
-        (let [page-id  (get-in state [:workspace-page :id])
-              objects  (get-in state [:workspace-data page-id :objects])
-              [rchanges uchanges] (impl-gen-changes objects (seq ids))]
-        (rx/of (dwc/commit-changes rchanges uchanges {:commit-local? true})))))))
 
 ;; --- Update Selected Shapes attrs
 
@@ -652,8 +593,13 @@
     ptk/WatchEvent
     (watch [_ state stream]
       (let [selected (get-in state [:workspace-local :selected])
-            page-id  (get-in state [:workspace-page :id])]
+            update-fn
-        (rx/of (update-shapes-recursive selected attrs))))))
+            (fn [shape]
+              (cond-> (merge shape attrs)
+                (and (= :text (:type shape))
+                     (string? (:fill-color attrs)))
+                (dwtxt/impl-update-shape-attrs {:fill (:fill-color attrs)})))]
+        (rx/of (dwc/update-shapes-recursive selected update-fn))))))
 
 
 ;; --- Shape Movement (using keyboard shorcuts)
@@ -762,19 +708,6 @@
                dws/deselect-all)))))
 
 
-;; --- Rename Shape
-
-(defn rename-shape
-  [id name]
-  (us/verify ::us/uuid id)
-  (us/verify string? name)
-  (ptk/reify ::rename-shape
-    dwc/IBatchedChange
-    ptk/UpdateEvent
-    (update [_ state]
-      (let [page-id (:current-page-id state)]
-        (update-in state [:workspace-data page-id :objects id] assoc :name name)))))
-
 ;; --- Shape Vertical Ordering
 
 (s/def ::loc  #{:up :down :bottom :top})
@@ -987,21 +920,19 @@
 
 ;; --- Update Dimensions
 
-(defn update-rect-dimensions
+;; Event mainly used for handling user modification of the size of the
+;; object from workspace sidebar options inputs.
+
+(defn update-dimensions
   [id attr value]
   (us/verify ::us/uuid id)
   (us/verify #{:width :height} attr)
   (us/verify ::us/number value)
-  (ptk/reify ::update-rect-dimensions
+  (ptk/reify ::update-dimensions
-    dwc/IBatchedChange
+    ptk/WatchEvent
-    dwc/IUpdateGroup
+    (watch [_ state stream]
-    (get-ids [_] [id])
+      (rx/of (dwc/update-shapes [id] #(geom/resize-rect % attr value))))))
 
-    ptk/UpdateEvent
-    (update [_ state]
-      (let [page-id (:current-page-id state)]
-        (update-in state [:workspace-data page-id :objects id]
-                   geom/resize-rect attr value)))))
 
 ;; --- Shape Proportions
 
@@ -1260,6 +1191,18 @@
             pages (vec (concat before [id] after))]
         (assoc-in state [:projects (:project-id page) :pages] pages)))))
 
+(defn update-shape-flags
+  [id {:keys [blocked hidden] :as flags}]
+  (s/assert ::us/uuid id)
+  (s/assert ::shape-attrs flags)
+  (ptk/reify ::update-shape-flags
+    ptk/WatchEvent
+    (watch [_ state stream]
+      (letfn [(update-fn [obj]
+                (cond-> obj
+                  (boolean? blocked) (assoc :blocked blocked)
+                  (boolean? hidden) (assoc :hidden hidden)))]
+        (rx/of (dwc/update-shapes-recursive [id] update-fn))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; GROUPS
@@ -1481,6 +1424,7 @@
 (def handle-selection dws/handle-selection)
 (def select-inside-group dws/select-inside-group)
 
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Shortcuts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

frontend/src/uxbox/main/data/workspace/common.cljs

@@ -314,3 +314,93 @@
                                (map (fn [id] {id true}))
                                (into {}))))]
         (update-in state [:workspace-local :expanded] expand-fn)))))
+
+;; --- Update Shape Attrs
+
+;; NOTE: This is a generic implementation for update multiple shapes
+;; in one single commit/undo entry.
+
+(s/def ::coll-of-uuid
+  (s/every ::us/uuid))
+
+(defn update-shapes
+  ([ids f] (update-shapes ids f nil))
+  ([ids f {:keys [reg-objects?] :or {reg-objects? false}}]
+   (us/assert ::coll-of-uuid ids)
+   (us/assert fn? f)
+   (ptk/reify ::update-shapes
+     ptk/WatchEvent
+     (watch [_ state stream]
+      (let [page-id (:current-page-id state)
+            objects (get-in state [:workspace-data page-id :objects])]
+        (loop [ids (seq ids)
+               rch []
+               uch []]
+          (if (nil? ids)
+            (rx/of (commit-changes
+                    (cond-> rch reg-objects? (conj {:type :reg-objects :shapes (vec ids)}))
+                    (cond-> uch reg-objects? (conj {:type :reg-objects :shapes (vec ids)}))
+                    {:commit-local? true}))
+
+            (let [id   (first ids)
+                  obj1 (get objects id)
+                  obj2 (f obj1)
+                  rchg {:type :mod-obj
+                        :operations (generate-operations obj1 obj2)
+                        :id id}
+                  uchg {:type :mod-obj
+                        :operations (generate-operations obj2 obj1)
+                        :id id}]
+              (recur (next ids)
+                     (conj rch rchg)
+                     (conj uch uchg))))))))))
+
+
+(defn update-shapes-recursive
+  [ids f]
+  (us/assert ::coll-of-uuid ids)
+  (us/assert fn? f)
+  (letfn [(impl-get-children [objects id]
+            (cons id (cph/get-children id objects)))
+
+          (impl-gen-changes [objects ids]
+            (loop [sids (seq ids)
+                   cids (seq (impl-get-children objects (first sids)))
+                   rchanges []
+                   uchanges []]
+              (cond
+                (nil? sids)
+                [rchanges uchanges]
+
+                (nil? cids)
+                (recur (next sids)
+                       (seq (impl-get-children objects (first (next sids))))
+                       rchanges
+                       uchanges)
+
+                :else
+                (let [id   (first cids)
+                      obj1 (get objects id)
+                      obj2 (f obj1)
+                      rops (generate-operations obj1 obj2)
+                      uops (generate-operations obj2 obj1)
+                      rchg {:type :mod-obj
+                            :operations rops
+                            :id id}
+                      uchg {:type :mod-obj
+                            :operations uops
+                            :id id}]
+                  (recur sids
+                         (next cids)
+                         (conj rchanges rchg)
+                         (conj uchanges uchg))))))]
+    (ptk/reify ::update-shapes-recursive
+      ptk/WatchEvent
+      (watch [_ state stream]
+        (let [page-id  (get-in state [:workspace-page :id])
+              objects  (get-in state [:workspace-data page-id :objects])
+              [rchanges uchanges] (impl-gen-changes objects (seq ids))]
+        (rx/of (commit-changes rchanges uchanges {:commit-local? true})))))))
+
+
+

frontend/src/uxbox/main/data/workspace/persistence.cljs

@@ -13,6 +13,7 @@
    [cljs.spec.alpha :as s]
    [potok.core :as ptk]
    [uxbox.common.data :as d]
+   [uxbox.common.geom.point :as gpt]
    [uxbox.common.pages :as cp]
    [uxbox.common.spec :as us]
    [uxbox.main.data.dashboard :as dd]
@@ -20,8 +21,8 @@
    [uxbox.main.data.workspace.common :as dwc]
    [uxbox.main.repo :as rp]
    [uxbox.main.store :as st]
-   [uxbox.common.geom.point :as gpt]
    [uxbox.util.i18n :as i18n :refer [tr]]
+   [uxbox.util.object :as obj]
    [uxbox.util.router :as rt]
    [uxbox.util.time :as dt]
    [uxbox.util.transit :as t]))
@@ -34,6 +35,10 @@
 
 (defn initialize-page-persistence
   [page-id]
+  (letfn [(enable-reload-stoper []
+            (obj/set! js/window "onbeforeunload" (constantly false)))
+          (disable-reload-stoper []
+            (obj/set! js/window "onbeforeunload" nil))]
     (ptk/reify ::initialize-persistence
       ptk/UpdateEvent
       (update [_ state]
@@ -44,22 +49,28 @@
         (let [stoper   (rx/filter #(= ::finalize %) stream)
               notifier (->> stream
                             (rx/filter (ptk/type? ::dwc/commit-changes))
-                          (rx/debounce 200)
+                            (rx/debounce 2000)
                             (rx/merge stoper))]
           (rx/merge
            (->> stream
                 (rx/filter (ptk/type? ::dwc/commit-changes))
                 (rx/map deref)
+                (rx/tap enable-reload-stoper)
                 (rx/buffer-until notifier)
                 (rx/map vec)
                 (rx/filter (complement empty?))
                 (rx/map #(persist-changes page-id %))
                 (rx/take-until (rx/delay 100 stoper)))
+           (->> stream
+                (rx/filter (ptk/type? ::changes-persisted))
+                (rx/tap disable-reload-stoper)
+                (rx/ignore)
+                (rx/take-until stoper))
            (->> stream
                 (rx/filter #(satisfies? dwc/IBatchedChange %))
-              (rx/debounce 200)
+                (rx/debounce 10)
                 (rx/map (fn [_] (dwc/diff-and-commit-changes page-id)))
-              (rx/take-until stoper)))))))
+                (rx/take-until stoper))))))))
 
 (defn persist-changes
   [page-id changes]
@@ -74,6 +85,11 @@
                      :session-id sid
                      :changes changes}]
         (->> (rp/mutation :update-page params)
+             (rx/map (fn [lagged]
+                       (if (= #{sid} (into #{} (map :session-id) lagged))
+                         (map #(assoc % :changes []) lagged)
+                         lagged)))
+             (rx/mapcat seq)
              (rx/map shapes-changes-persisted))))))
 
 (s/def ::shapes-changes-persisted
@@ -85,10 +101,9 @@
   (ptk/reify ::changes-persisted
     ptk/UpdateEvent
     (update [_ state]
-      (let [session-id (:session-id state)
+      (let [sid   (:session-id state)
-            state (-> state
+            page  (get-in state [:workspace-pages page-id])
-                      (assoc-in [:workspace-pages page-id :revn] revn))
+            state (update-in state [:workspace-pages page-id :revn] #(max % revn))]
-            changes (filter #(not= session-id (:session-id %)) changes)]
         (-> state
             (update-in [:workspace-data page-id] cp/process-changes changes)
             (update-in [:workspace-pages page-id :data] cp/process-changes changes))))))

frontend/src/uxbox/main/data/workspace/texts.cljs

@@ -9,15 +9,16 @@
 
 (ns uxbox.main.data.workspace.texts
   (:require
-   [clojure.walk :as walk]
+   ["slate" :as slate :refer [Editor Node Transforms Text]]
+   ["slate-react" :as rslate]
+   [beicon.core :as rx]
    [cljs.spec.alpha :as s]
+   [clojure.walk :as walk]
    [goog.object :as gobj]
    [potok.core :as ptk]
-   [uxbox.util.object :as obj]
-   [uxbox.main.fonts :as fonts]
    [uxbox.main.data.workspace.common :as dwc]
-   ["slate-react" :as rslate]
+   [uxbox.main.fonts :as fonts]
-   ["slate" :as slate :refer [Editor Node Transforms Text]]))
+   [uxbox.util.object :as obj]))
 
 (defn create-editor
   []
@@ -171,13 +172,9 @@
         (editor-set! editor (clj->js attrs) #js {:match pred :split split})))
 
     (ptk/reify ::update-attrs
-      dwc/IBatchedChange
+      ptk/WatchEvent
-      ptk/UpdateEvent
+      (watch [_ state stream]
-      (update [_ state]
+        (rx/of (dwc/update-shapes [id] #(impl-update-shape-attrs % attrs pred)))))))
-        (let [page-id (get-in state [:workspace-page :id])
-              merge-attrs #(merge-attrs % attrs)]
-          (update-in state [:workspace-data page-id :objects id]
-                     #(impl-update-shape-attrs % attrs pred)))))))
 
 (defn update-text-attrs
   [options]

frontend/src/uxbox/main/data/workspace/transforms.cljs

@@ -368,16 +368,15 @@
      :displacement displacement}))
 
 
-;; Set-rotation is custom because applies different modifiers to each shape adjusting their position
+;; Set-rotation is custom because applies different modifiers to each
+;; shape adjusting their position.
+
 (defn set-rotation
   ([delta-rotation shapes]
    (set-rotation delta-rotation shapes (-> shapes gsh/selection-rect gsh/center)))
 
   ([delta-rotation shapes center]
    (ptk/reify ::set-rotation
-     dwc/IUpdateGroup
-     (get-ids [_] (map :id shapes))
-
      ptk/UpdateEvent
      (update [_ state]
        (let [page-id (:current-page-id state)]

frontend/src/uxbox/main/ui/workspace/context_menu.cljs

@@ -54,10 +54,10 @@
         do-bring-to-front #(st/emit! (dw/vertical-order-selected :top))
         do-send-backward #(st/emit! (dw/vertical-order-selected :down))
         do-send-to-back #(st/emit! (dw/vertical-order-selected :bottom))
-        do-show-shape #(st/emit! (dw/update-shapes-recursive [id] {:hidden false}))
+        do-show-shape #(st/emit! (dw/update-shape-flags id {:hidden false}))
-        do-hide-shape #(st/emit! (dw/update-shapes-recursive [id] {:hidden true}))
+        do-hide-shape #(st/emit! (dw/update-shape-flags id {:hidden true}))
-        do-lock-shape #(st/emit! (dw/update-shapes-recursive [id] {:blocked true}))
+        do-lock-shape #(st/emit! (dw/update-shape-flags id {:blocked true}))
-        do-unlock-shape #(st/emit! (dw/update-shapes-recursive [id] {:blocked false}))
+        do-unlock-shape #(st/emit! (dw/update-shape-flags id {:blocked false}))
         do-create-group #(st/emit! dw/group-selected)
         do-remove-group #(st/emit! dw/ungroup-selected)]
     [:*

frontend/src/uxbox/main/ui/workspace/sidebar/layers.cljs

@@ -59,7 +59,7 @@
                         parent (.-parentNode parent)
                         name (dom/get-value target)]
                     (set! (.-draggable parent) true)
-                    (st/emit! (dw/rename-shape (:id shape) name))
+                    (st/emit! (dw/update-shape (:id shape) {:name name}))
                     (swap! local assoc :edition false)))
         on-key-down (fn [event]
                       (when (kbd/enter? event)
@@ -118,15 +118,15 @@
         (fn [event]
           (dom/stop-propagation event)
           (if (:blocked item)
-            (st/emit! (dw/update-shapes-recursive [id] {:blocked false}))
+            (st/emit! (dw/update-shape-flags id {:blocked false}))
-            (st/emit! (dw/update-shapes-recursive [id] {:blocked true}))))
+            (st/emit! (dw/update-shape-flags id {:blocked true}))))
 
         toggle-visibility
         (fn [event]
           (dom/stop-propagation event)
           (if (:hidden item)
-            (st/emit! (dw/update-shapes-recursive [id] {:hidden false}))
+            (st/emit! (dw/update-shape-flags id {:hidden false}))
-            (st/emit! (dw/update-shapes-recursive [id] {:hidden true}))))
+            (st/emit! (dw/update-shape-flags id {:hidden true}))))
 
         select-shape
         (fn [event]

frontend/src/uxbox/main/ui/workspace/sidebar/options/frame.cljs

@@ -33,8 +33,8 @@
 
         on-preset-selected
         (fn [width height]
-          (st/emit! (udw/update-rect-dimensions (:id shape) :width width)
+          (st/emit! (udw/update-dimensions (:id shape) :width width)
-                    (udw/update-rect-dimensions (:id shape) :height height)))
+                    (udw/update-dimensions (:id shape) :height height)))
 
         on-orientation-clicked
         (fn [orientation]
@@ -42,15 +42,15 @@
                 height (:height shape)
                 new-width (if (= orientation :horiz) (max width height) (min width height))
                 new-height (if (= orientation :horiz) (min width height) (max width height))]
-            (st/emit! (udw/update-rect-dimensions (:id shape) :width new-width)
+            (st/emit! (udw/update-dimensions (:id shape) :width new-width)
-                      (udw/update-rect-dimensions (:id shape) :height new-height))))
+                      (udw/update-dimensions (:id shape) :height new-height))))
 
         on-size-change
         (fn [event attr]
           (let [value (-> (dom/get-target event)
                           (dom/get-value)
                           (d/parse-integer 0))]
-            (st/emit! (udw/update-rect-dimensions (:id shape) attr value))))
+            (st/emit! (udw/update-dimensions (:id shape) attr value))))
 
         on-proportion-lock-change
         (fn [event]

frontend/src/uxbox/main/ui/workspace/sidebar/options/measures.cljs

@@ -36,7 +36,7 @@
           (let [value (-> (dom/get-target event)
                           (dom/get-value)
                           (d/parse-integer 0))]
-            (st/emit! (udw/update-rect-dimensions (:id shape) attr value))))
+            (st/emit! (udw/update-dimensions (:id shape) attr value))))
 
         on-proportion-lock-change
         (fn [event]