🔧 Make TokenSet an abstract data type

2025-12-11 22:14:05 +01:00 · 2025-06-02 18:31:41 +02:00
parent 6de9de9e38
commit f0f01af55c
10 changed files with 246 additions and 161 deletions
--- a/common/src/app/common/files/changes.cljc
+++ b/common/src/app/common/files/changes.cljc
@@ -418,7 +418,7 @@
      [:type [:= :set-token-set]]
      [:set-name :string]
      [:group? :boolean]
-      [:token-set [:maybe ctob/schema:token-set-attrs]]]]
+      [:token-set [:maybe [:fn ctob/token-set?]]]]]

    [:set-token
     [:map {:title "SetTokenChange"}
@@ -1025,11 +1025,10 @@
                  (ctob/delete-set lib' set-name))

                (not (ctob/get-set lib' set-name))
-                (ctob/add-set lib' (ctob/make-token-set token-set))
+                (ctob/add-set lib' token-set)

                :else
-                (ctob/update-set lib' set-name (fn [prev-token-set]
-                                                 (ctob/make-token-set (merge prev-token-set token-set)))))))))
+                (ctob/update-set lib' set-name (fn [_] token-set)))))))

 (defmethod process-change :set-token-theme
  [data {:keys [group theme-name theme]}]
--- a/common/src/app/common/files/changes_builder.cljc
+++ b/common/src/app/common/files/changes_builder.cljc
@@ -916,7 +916,7 @@
    (-> changes
        (update :redo-changes conj {:type :set-token-set
                                    :set-name name
-                                    :token-set (assoc prev-token-set :name new-name)
+                                    :token-set (ctob/rename prev-token-set new-name)
                                    :group? false})
        (update :undo-changes conj {:type :set-token-set
                                    :set-name new-name
@@ -937,11 +937,11 @@
                                    :group? group?})
        (update :undo-changes conj (if prev-token-set
                                     {:type :set-token-set
-                                      :set-name (or
-                                                 ;; Undo of edit
-                                                 (:name token-set)
-                                                 ;; Undo of delete
-                                                 set-name)
+                                      :set-name (if token-set
+                                                  ;; Undo of edit
+                                                  (ctob/get-name token-set)
+                                                  ;; Undo of delete
+                                                  set-name)
                                      :token-set prev-token-set
                                      :group? group?}
                                     ;; Undo of create
--- a/common/src/app/common/logic/tokens.cljc
+++ b/common/src/app/common/logic/tokens.cljc
@@ -41,7 +41,7 @@
  [group-path tokens-lib tokens-lib-theme]
  (let [deactivate? (contains? #{:all :partial} (ctob/sets-at-path-all-active? tokens-lib group-path))
        sets-names  (->> (ctob/get-sets-at-path tokens-lib group-path)
-                         (map :name)
+                         (map ctob/get-name)
                         (into #{}))]
    (if deactivate?
      (ctob/disable-sets tokens-lib-theme sets-names)
--- a/common/src/app/common/types/tokens_lib.cljc
+++ b/common/src/app/common/types/tokens_lib.cljc
@@ -17,6 +17,7 @@
   [app.common.transit :as t]
   [app.common.types.token :as cto]
   [app.common.uuid :as uuid]
+   [clojure.core.protocols :as protocols]
   [clojure.set :as set]
   [clojure.walk :as walk]
   [cuerdas.core :as str]))
@@ -25,13 +26,6 @@

 ;; TODO: add again the removed functions and refactor the rest of the module to use them

-(def ^:private schema:groupable-item
-  [:map {:title "Groupable item"}
-   [:name :string]])
-
-(def ^:private valid-groupable-item?
-  (sm/validator schema:groupable-item))
-
 (def ^:private xf-map-trim
  (comp
   (map str/trim)
@@ -60,14 +54,38 @@
 (defn get-path
  "Get the path of object by specified separator (E.g. with '.' separator, the
  'group.subgroup.name' -> ['group' 'subgroup'])"
-  [item separator]
-  (assert (valid-groupable-item? item) "expected groupable item")
-  (->> (split-path (:name item) separator)
+  [name separator]
+  (->> (split-path name separator)
       (not-empty)))

+;; === Common
+
+(defprotocol INamedItem
+  "Protocol for items that have a name, a description and a modified date."
+  (get-name [_] "Get the name of the item.")
+  (get-description [_] "Get the description of the item.")
+  (get-modified-at [_] "Get the description of the item.")
+  (rename [_ new-name] "Set the name of the item.")
+  (set-description [_ new-description] "Set the description of the item."))
+
 ;; === Token

-(defrecord Token [id name type value description modified-at])
+(defrecord Token [id name type value description modified-at]
+  INamedItem
+  (get-name [_]
+    name)
+
+  (get-description [_]
+    description)
+
+  (get-modified-at [_]
+    modified-at)
+
+  (rename [this new-name]
+    (assoc this :name new-name))
+
+  (set-description [this new-description]
+    (assoc this :description new-description)))

 (defn token?
  [o]
@@ -109,7 +127,7 @@

 (defn get-token-path
  [token]
-  (get-path token token-separator))
+  (get-path (:name token) token-separator))

 (defn find-token-value-references
  "Returns set of token references found in `token-value`.
@@ -146,9 +164,53 @@
  (update-token [_ token-name f] "update a token in the list")
  (delete-token [_ token-name] "delete a token from the list")
  (get-token [_ token-name] "return token by token-name")
-  (get-tokens [_] "return an ordered sequence of all tokens in the set"))
+  (get-tokens [_] "return an ordered sequence of all tokens in the set")
+  (get-tokens-map [_] "return a map of tokens in the set, indexed by token-name"))
+
+(deftype TokenSet [id name description modified-at tokens]
+  #?@(:clj  [clojure.lang.IDeref
+             (deref [_] {:id id
+                         :name name
+                         :description description
+                         :modified-at modified-at
+                         :tokens tokens})]
+      :cljs [cljs.core/IDeref
+             (-deref [_] {:id id
+                          :name name
+                          :description description
+                          :modified-at modified-at
+                          :tokens tokens})])
+
+  #?@(:cljs [cljs.core/IEncodeJS
+             (-clj->js [_] (js-obj "id" (clj->js id)
+                                   "name" (clj->js name)
+                                   "description" (clj->js description)
+                                   "modified-at" (clj->js modified-at)
+                                   "tokens" (clj->js tokens)))])
+  INamedItem
+  (get-name [_]
+    name)
+
+  (get-description [_]
+    description)
+
+  (get-modified-at [_]
+    modified-at)
+
+  (rename [_ new-name]
+    (TokenSet. id
+               new-name
+               description
+               (dt/now)
+               tokens))
+
+  (set-description [_ new-description]
+    (TokenSet. id
+               name
+               (d/nilv new-description "")
+               (dt/now)
+               tokens))

-(defrecord TokenSet [id name description modified-at tokens]
  ITokenSet
  (add-token [_ token]
    (let [token (check-token token)]
@@ -184,7 +246,10 @@
    (get tokens token-name))

  (get-tokens [_]
-    (vals tokens)))
+    (vals tokens))
+
+  (get-tokens-map [_]
+    tokens))

 (defn token-set?
  [o]
@@ -218,10 +283,7 @@
 (declare make-token-set)

 (def schema:token-set
-  [:and {:gen/gen (->> (sg/generator schema:token-set-attrs)
-                       (sg/fmap #(make-token-set %)))}
-   (sm/required-keys schema:token-set-attrs)
-   [:fn token-set?]])
+  (sm/required-keys schema:token-set-attrs))

 (sm/register! ::token-set schema:token-set) ;; need to register for the recursive schema of token-sets

@@ -233,13 +295,17 @@

 (defn make-token-set
  [& {:as attrs}]
-  (-> attrs
-      (update :id #(or % (uuid/next)))
-      (update :modified-at #(or % (dt/now)))
-      (update :tokens #(into (d/ordered-map) %))
-      (update :description d/nilv "")
-      (check-token-set-attrs)
-      (map->TokenSet)))
+  (let [attrs (-> attrs
+                  (update :id #(or % (uuid/next)))
+                  (update :modified-at #(or % (dt/now)))
+                  (update :tokens #(into (d/ordered-map) %))
+                  (update :description d/nilv "")
+                  (check-token-set-attrs))]
+    (TokenSet. (:id attrs)
+               (:name attrs)
+               (:description attrs)
+               (:modified-at attrs)
+               (:tokens attrs))))

 (def ^:private set-prefix "S-")

@@ -291,7 +357,7 @@

 (defn get-set-path
  [token-set]
-  (get-path token-set set-separator))
+  (get-path (get-name token-set) set-separator))

 (defn split-set-name
  [name]
@@ -315,7 +381,7 @@
      (set-full-path->set-prefixed-full-path)))

 (defn get-set-prefixed-path [token-set]
-  (let [path (get-path token-set set-separator)]
+  (let [path (get-path (get-name token-set) set-separator)]
    (set-full-path->set-prefixed-full-path path)))

 (defn prefixed-set-path-string->set-name-string [path-str]
@@ -333,7 +399,7 @@
      (conj name)))

 (defn tokens-tree
-  "Convert tokens into a nested tree with their `:name` as the path.
+  "Convert tokens into a nested tree with their name as the path.
  Optionally use `update-token-fn` option to transform the token."
  [tokens & {:keys [update-token-fn]
             :or {update-token-fn identity}}]
@@ -343,7 +409,7 @@
             {} tokens))

 (defn backtrace-tokens-tree
-  "Convert tokens into a nested tree with their `:name` as the path.
+  "Convert tokens into a nested tree with their name as the path.
  Generates a uuid per token to backtrace a token from an external source (StyleDictionary).
  The backtrace can't be the name as the name might not exist when the user is creating a token."
  [tokens]
@@ -392,7 +458,7 @@
  (get-set [_ set-name] "get one set looking for name"))

 (def schema:token-set-node
-  [:schema {:registry {::node [:or ::token-set
+  [:schema {:registry {::node [:or [:fn token-set?]
                               [:and
                                [:map-of {:gen/max 5} :string [:ref ::node]]
                                [:fn d/ordered-map?]]]}}
@@ -443,6 +509,22 @@
  (hidden-theme? [_] "if a theme is the (from the user ui) hidden temporary theme"))

 (defrecord TokenTheme [id name group description is-source external-id modified-at sets]
+  INamedItem
+  (get-name [_]
+    name)
+
+  (get-description [_]
+    description)
+
+  (get-modified-at [_]
+    modified-at)
+
+  (rename [this new-name]
+    (assoc this :name new-name))
+
+  (set-description [this new-description]
+    (assoc this :description new-description))
+
  ITokenTheme
  (set-sets [_ set-names]
    (TokenTheme. id
@@ -618,7 +700,7 @@
                      ;; Set
                      (and v (instance? TokenSet v))
                      [{:group? false
-                        :path (split-set-name (:name v))
+                        :path (split-set-name (get-name v))
                        :parent-path parent
                        :depth depth
                        :set v}]
@@ -664,7 +746,7 @@

                  ;; Set
                  (and v (instance? TokenSet v))
-                  (let [name (:name v)]
+                  (let [name (get-name v)]
                    [{:is-group false
                      :path (split-set-name name)
                      :id name
@@ -725,8 +807,14 @@ Will return a value that matches this schema:
 (declare export-dtcg-json)

 (deftype TokensLib [sets themes active-themes]
-  ;; NOTE: This is only for debug purposes, pending to properly
-  ;; implement the toString and alternative printing.
+  ;; This is to convert the TokensLib to a plain map, for debugging or unit tests.
+  protocols/Datafiable
+  (datafy [_]
+    {:sets (d/update-vals sets deref)
+     :themes themes
+     :active-themes active-themes})
+
+  ;; TODO: this is used in serialization, but there should be a better way to do it
  #?@(:clj  [clojure.lang.IDeref
             (deref [_] {:sets sets
                         :themes themes
@@ -746,8 +834,8 @@ Will return a value that matches this schema:

  ITokenSets
  (add-set [_ token-set]
-    (let [path      (get-set-prefixed-path token-set)
-          token-set (check-token-set token-set)]
+    (assert (token-set? token-set) "expected valid token-set")
+    (let [path (get-set-prefixed-path token-set)]
      (TokensLib. (d/oassoc-in sets path token-set)
                  themes
                  active-themes)))
@@ -756,10 +844,9 @@ Will return a value that matches this schema:
    (let [prefixed-full-path (set-name->prefixed-full-path set-name)
          set (get-in sets prefixed-full-path)]
      (if set
-        (let [set' (-> (make-token-set (f set))
-                       (assoc :modified-at (dt/now)))
+        (let [set' (f set)
              prefixed-full-path' (get-set-prefixed-path set')
-              name-changed? (not= (:name set) (:name set'))]
+              name-changed? (not= (get-name set) (get-name set'))]
          (if name-changed?
            (TokensLib. (-> sets
                            (d/oassoc-in-before prefixed-full-path prefixed-full-path' set')
@@ -767,7 +854,7 @@ Will return a value that matches this schema:
                        (walk/postwalk
                         (fn [form]
                           (if (instance? TokenTheme form)
-                             (update-set-name form (:name set) (:name set'))
+                             (update-set-name form (get-name set) (get-name set'))
                             form))
                         themes)
                        active-themes)
@@ -791,7 +878,7 @@ Will return a value that matches this schema:
    (let [path (split-set-name set-group-name)
          prefixed-path (map add-set-group-prefix path)
          child-set-names (->> (get-sets-at-path this path)
-                               (map :name)
+                               (map get-name)
                               (into #{}))]
      (TokensLib. (d/dissoc-in sets prefixed-path)
                  (walk/postwalk
@@ -833,7 +920,7 @@ Will return a value that matches this schema:
                  (set-full-path->set-prefixed-full-path before-path)))

              set
-              (assoc prev-set :name (join-set-path to-path))
+              (rename prev-set (join-set-path to-path))

              reorder?
              (= prefixed-from-path prefixed-to-path)
@@ -856,7 +943,7 @@ Will return a value that matches this schema:
                        (walk/postwalk
                         (fn [form]
                           (if (instance? TokenTheme form)
-                             (update-set-name form (:name prev-set) (:name set))
+                             (update-set-name form (get-name prev-set) (get-name set))
                             form))
                         themes))
                      active-themes))
@@ -888,15 +975,15 @@ Will return a value that matches this schema:
                    (d/oupdate-in prefixed-to-path (fn [sets]
                                                     (walk/prewalk
                                                      (fn [form]
-                                                        (if (instance? TokenSet form)
-                                                          (update form :name #(str to-path-str (str/strip-prefix % from-path-str)))
+                                                        (if (token-set? form)
+                                                          (rename form (str to-path-str (str/strip-prefix (get-name form) from-path-str)))
                                                          form))
                                                      sets)))))
              themes' (if reorder?
                        themes
                        (let [rename-sets-map (->> (get-sets-at-path this from-path)
                                                   (map (fn [set]
-                                                          [(:name set) (str to-path-str (str/strip-prefix (:name set) from-path-str))]))
+                                                          [(get-name set) (str to-path-str (str/strip-prefix (get-name set) from-path-str))]))
                                                   (into {}))]
                          (walk/postwalk
                           (fn [form]
@@ -934,12 +1021,12 @@ Will return a value that matches this schema:
          sets (get-sets-at-path this path)]
      (reduce
       (fn [lib set]
-         (update-set lib (:name set) (fn [set']
-                                       (update set' :name #(str to-path-str (str/strip-prefix % from-path-str))))))
+         (update-set lib (get-name set) (fn [set']
+                                          (rename set' (str to-path-str (str/strip-prefix (get-name set') from-path-str))))))
       this sets)))

  (get-ordered-set-names [this]
-    (map :name (get-sets this)))
+    (map get-name (get-sets this)))

  (set-count [this]
    (count (get-sets this)))
@@ -1080,7 +1167,7 @@ Will return a value that matches this schema:
          prefixed-path-str (set-group-path->set-group-prefixed-path-str group-path)]
      (if (seq active-set-names)
        (let [path-active-set-names (->> (get-sets-at-prefix-path this prefixed-path-str)
-                                         (map :name)
+                                         (map get-name)
                                         (into #{}))
              difference (set/difference path-active-set-names active-set-names)]
          (cond
@@ -1095,7 +1182,7 @@ Will return a value that matches this schema:
          active-set-names (filter theme-set-names all-set-names)
          tokens           (reduce (fn [tokens set-name]
                                     (let [set (get-set this set-name)]
-                                       (merge tokens (:tokens set))))
+                                       (merge tokens (get-tokens-map set))))
                                   (d/ordered-map)
                                   active-set-names)]
      tokens))
@@ -1160,11 +1247,10 @@ Will return a value that matches this schema:

 (defn duplicate-set [set-name lib & {:keys [suffix]}]
  (let [sets (get-sets lib)
-        unames (map :name sets)
+        unames (map get-name sets)
        copy-name (cfh/generate-unique-name set-name unames :suffix suffix)]
    (some-> (get-set lib set-name)
-            (assoc :name copy-name)
-            (assoc :modified-at (dt/now)))))
+            (rename copy-name))))

 ;; === Import / Export from JSON format

@@ -1459,8 +1545,10 @@ Will return a value that matches this schema:
  [tokens-lib]
  (let [{:keys [themes active-themes]} (dtcg-export-themes tokens-lib)
        sets (->> (get-sets tokens-lib)
-                  (map (fn [{:keys [name tokens]}]
-                         [(str name ".json") (tokens-tree tokens :update-token-fn token->dtcg-token)]))
+                  (map (fn [token-set]
+                         (let [name   (get-name token-set)
+                               tokens (get-tokens-map token-set)]
+                           [(str name ".json") (tokens-tree tokens :update-token-fn token->dtcg-token)])))
                  (into {}))]
    (-> sets
        (assoc "$themes.json" themes)
@@ -1477,8 +1565,9 @@ Will return a value that matches this schema:
        (->> (get-set-tree tokens-lib)
             (tree-seq d/ordered-map? vals)
             (filter (partial instance? TokenSet))
-             (map (fn [{:keys [name tokens]}]
-                    [name (tokens-tree tokens :update-token-fn token->dtcg-token)])))
+             (map (fn [set]
+                    [(get-name set)
+                     (tokens-tree (get-tokens-map set) :update-token-fn token->dtcg-token)])))

        ordered-set-names
        (mapv first name-set-tuples)
@@ -1522,7 +1611,7 @@ Will return a value that matches this schema:
     nil
     decoded-json)))

-;; === Serialization handlers for RPC API (transit) and database (fressian)
+;; === Serialization handlers for RPC API (transit)

 (t/add-handlers!
 {:id "penpot/tokens-lib"
@@ -1532,8 +1621,8 @@ Will return a value that matches this schema:

 {:id "penpot/token-set"
  :class TokenSet
-  :wfn #(into {} %)
-  :rfn #(map->TokenSet %)}
+  :wfn deref
+  :rfn #(make-token-set %)}

 {:id "penpot/token-theme"
  :class TokenTheme
@@ -1545,6 +1634,8 @@ Will return a value that matches this schema:
  :wfn #(into {} %)
  :rfn #(map->Token %)})

+;; === Serialization handlers for database (fressian)
+
 #?(:clj
   (defn- read-tokens-lib-v1-0
     "Reads the first version of tokens lib, now completly obsolete"
@@ -1670,10 +1761,10 @@ Will return a value that matches this schema:
     :class TokenSet
     :wfn (fn [n w o]
            (fres/write-tag! w n 1)
-            (fres/write-object! w (into {} o)))
+            (fres/write-object! w (into {} (deref o))))
     :rfn (fn [r]
            (let [obj (fres/read-object! r)]
-              (map->TokenSet obj)))}
+              (make-token-set obj)))}

    {:name "penpot/token-theme/v1"
     :class TokenTheme
--- a/common/test/common_tests/logic/token_test.cljc
+++ b/common/test/common_tests/logic/token_test.cljc
@@ -269,8 +269,7 @@
          new-set-name "foo1"
          changes (-> (pcb/empty-changes)
                      (pcb/with-library-data (:data file))
-                      (pcb/set-token-set set-name false (assoc prev-token-set
-                                                               :name new-set-name)))
+                      (pcb/set-token-set set-name false (ctob/rename prev-token-set new-set-name)))
          redo (thf/apply-changes file changes)
          redo-lib (tht/get-tokens-lib redo)
          undo (thf/apply-undo-changes redo changes)
--- a/common/test/common_tests/types/tokens_lib_test.cljc
+++ b/common/test/common_tests/types/tokens_lib_test.cljc
@@ -14,6 +14,7 @@
   [app.common.time :as dt]
   [app.common.transit :as tr]
   [app.common.types.tokens-lib :as ctob]
+   [clojure.datafy :refer [datafy]]
   [clojure.test :as t]))

 (defn setup-virtual-time
@@ -72,14 +73,14 @@
                                        :modified-at now
                                        :tokens [])]

-    (t/is (= (:name token-set1) "test-token-set-1"))
-    (t/is (= (:description token-set1) ""))
-    (t/is (some? (:modified-at token-set1)))
-    (t/is (empty? (:tokens token-set1)))
-    (t/is (= (:name token-set2) "test-token-set-2"))
-    (t/is (= (:description token-set2) "test description"))
-    (t/is (= (:modified-at token-set2) now))
-    (t/is (empty? (:tokens token-set2)))))
+    (t/is (= (ctob/get-name token-set1) "test-token-set-1"))
+    (t/is (= (ctob/get-description token-set1) ""))
+    (t/is (some? (ctob/get-modified-at token-set1)))
+    (t/is (empty? (ctob/get-tokens-map token-set1)))
+    (t/is (= (ctob/get-name token-set2) "test-token-set-2"))
+    (t/is (= (ctob/get-description token-set2) "test description"))
+    (t/is (= (ctob/get-modified-at token-set2) now))
+    (t/is (empty? (ctob/get-tokens-map token-set2)))))

 (t/deftest make-invalid-token-set
  (let [params {:name 777 :description 999}]
@@ -183,7 +184,7 @@
                                                                                              :type :boolean
                                                                                              :value true)})))
        expected (-> (ctob/get-set tokens-lib "A")
-                     (get :tokens)
+                     (ctob/get-tokens-map)
                     (ctob/tokens-tree))]
    (t/is (= (get-in expected ["foo" "bar" "baz" :name]) "foo.bar.baz"))
    (t/is (= (get-in expected ["foo" "bar" "bam" :name]) "foo.bar.bam"))
@@ -249,20 +250,18 @@
        tokens-lib' (-> tokens-lib
                        (ctob/update-set "test-token-set"
                                         (fn [token-set]
-                                           (assoc token-set
-                                                  :description "some description")))
+                                           (ctob/set-description token-set "some description")))
                        (ctob/update-set "not-existing-set"
                                         (fn [token-set]
-                                           (assoc token-set
-                                                  :description "no-effect"))))
+                                           (ctob/set-description token-set "no-effect"))))

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (:name token-set') "test-token-set"))
-    (t/is (= (:description token-set') "some description"))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (= (ctob/get-name token-set') "test-token-set"))
+    (t/is (= (ctob/get-description token-set') "some description"))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest rename-token-set
  (let [tokens-lib  (-> (ctob/make-tokens-lib)
@@ -271,15 +270,14 @@
        tokens-lib' (-> tokens-lib
                        (ctob/update-set "test-token-set"
                                         (fn [token-set]
-                                           (assoc token-set
-                                                  :name "updated-name"))))
+                                           (ctob/rename token-set "updated-name"))))

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "updated-name")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (:name token-set') "updated-name"))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (= (ctob/get-name token-set') "updated-name"))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest rename-token-set-group
  (let [tokens-lib  (-> (ctob/make-tokens-lib)
@@ -323,11 +321,11 @@
                                                                                     :type :boolean
                                                                                     :value true)})))
        token-set-copy (ctob/duplicate-set "test-token-set" tokens-lib {:suffix "copy"})
-        token (get-in token-set-copy [:tokens "test-token"])]
+        token (ctob/get-token token-set-copy "test-token")]

    (t/is (some? token-set-copy))
-    (t/is (= (:name token-set-copy) "test-token-set-copy"))
-    (t/is (= (count (:tokens token-set-copy)) 1))
+    (t/is (= (ctob/get-name token-set-copy) "test-token-set-copy"))
+    (t/is (= (count (ctob/get-tokens-map token-set-copy)) 1))
    (t/is (= (:name token) "test-token"))))

 (t/deftest duplicate-token-set-twice
@@ -341,11 +339,11 @@
        tokens-lib (ctob/add-set tokens-lib (ctob/duplicate-set "test-token-set" tokens-lib {:suffix "copy"}))

        token-set-copy (ctob/duplicate-set "test-token-set" tokens-lib {:suffix "copy"})
-        token (get-in token-set-copy [:tokens "test-token"])]
+        token (ctob/get-token token-set-copy "test-token")]

    (t/is (some? token-set-copy))
-    (t/is (= (:name token-set-copy) "test-token-set-copy-2"))
-    (t/is (= (count (:tokens token-set-copy)) 1))
+    (t/is (= (ctob/get-name token-set-copy) "test-token-set-copy-2"))
+    (t/is (= (count (ctob/get-tokens-map token-set-copy)) 1))
    (t/is (= (:name token) "test-token"))))

 (t/deftest duplicate-empty-token-set
@@ -353,11 +351,11 @@
                            (ctob/add-set (ctob/make-token-set :name "test-token-set")))

        token-set-copy (ctob/duplicate-set "test-token-set" tokens-lib {:suffix "copy"})
-        tokens         (get token-set-copy :tokens)]
+        tokens         (ctob/get-tokens-map token-set-copy)]

    (t/is (some? token-set-copy))
-    (t/is (= (:name token-set-copy) "test-token-set-copy"))
-    (t/is (= (count (:tokens token-set-copy)) 0))
+    (t/is (= (ctob/get-name token-set-copy) "test-token-set-copy"))
+    (t/is (= (count (ctob/get-tokens-map token-set-copy)) 0))
    (t/is (= (count tokens) 0))))

 (t/deftest duplicate-not-existing-token-set
@@ -392,12 +390,12 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token'      (get-in token-set' [:tokens "test-token"])]
+        token'      (ctob/get-token token-set' "test-token")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (count (:tokens token-set')) 1))
+    (t/is (= (count (ctob/get-tokens-map token-set')) 1))
    (t/is (= (:name token') "test-token"))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest update-token
  (let [tokens-lib  (-> (ctob/make-tokens-lib)
@@ -428,16 +426,16 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token       (get-in token-set [:tokens "test-token-1"])
-        token'      (get-in token-set' [:tokens "test-token-1"])]
+        token       (ctob/get-token token-set "test-token-1")
+        token'      (ctob/get-token token-set' "test-token-1")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (count (:tokens token-set')) 2))
-    (t/is (= (d/index-of (keys (:tokens token-set')) "test-token-1") 0))
+    (t/is (= (count (ctob/get-tokens-map token-set')) 2))
+    (t/is (= (d/index-of (keys (ctob/get-tokens-map token-set')) "test-token-1") 0))
    (t/is (= (:name token') "test-token-1"))
    (t/is (= (:description token') "some description"))
    (t/is (= (:value token') false))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))
    (t/is (dt/is-after? (:modified-at token') (:modified-at token)))))

 (t/deftest rename-token
@@ -460,16 +458,16 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token       (get-in token-set [:tokens "test-token-1"])
-        token'      (get-in token-set' [:tokens "updated-name"])]
+        token       (ctob/get-token token-set "test-token-1")
+        token'      (ctob/get-token token-set' "updated-name")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (count (:tokens token-set')) 2))
-    (t/is (= (d/index-of (keys (:tokens token-set')) "updated-name") 0))
+    (t/is (= (count (ctob/get-tokens-map token-set')) 2))
+    (t/is (= (d/index-of (keys (ctob/get-tokens-map token-set')) "updated-name") 0))
    (t/is (= (:name token') "updated-name"))
    (t/is (= (:description token') ""))
    (t/is (= (:value token') true))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))
    (t/is (dt/is-after? (:modified-at token') (:modified-at token)))))

 (t/deftest delete-token
@@ -486,12 +484,12 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token'      (get-in token-set' [:tokens "test-token"])]
+        token'      (ctob/get-token token-set' "test-token")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (count (:tokens token-set')) 0))
+    (t/is (= (count (ctob/get-tokens-map token-set')) 0))
    (t/is (nil? token'))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest get-ordered-sets
  (let [tokens-lib (-> (ctob/make-tokens-lib)
@@ -897,7 +895,7 @@
                                                               :value true)))

        set             (ctob/get-set tokens-lib "test-token-set")
-        tokens-list     (vals (:tokens set))]
+        tokens-list     (ctob/get-tokens set)]

    (t/is (= (count tokens-list) 5))
    (t/is (= (:name (nth tokens-list 0)) "token1"))
@@ -931,14 +929,14 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token       (get-in token-set [:tokens "group1.test-token-2"])
-        token'      (get-in token-set' [:tokens "group1.test-token-2"])]
+        token       (ctob/get-token token-set "group1.test-token-2")
+        token'      (ctob/get-token token-set' "group1.test-token-2")]

    (t/is (= (ctob/set-count tokens-lib') 1))
    (t/is (= (:name token') "group1.test-token-2"))
    (t/is (= (:description token') "some description"))
    (t/is (= (:value token') false))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))
    (t/is (dt/is-after? (:modified-at token') (:modified-at token)))))

 (t/deftest update-token-in-sets-rename
@@ -965,14 +963,14 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token       (get-in token-set [:tokens "group1.test-token-2"])
-        token'      (get-in token-set' [:tokens "group1.updated-name"])]
+        token       (ctob/get-token token-set "group1.test-token-2")
+        token'      (ctob/get-token token-set' "group1.updated-name")]

    (t/is (= (ctob/set-count tokens-lib') 1))
    (t/is (= (:name token') "group1.updated-name"))
    (t/is (= (:description token') ""))
    (t/is (= (:value token') true))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (:ctob/get-modified-at token-set)))
    (t/is (dt/is-after? (:modified-at token') (:modified-at token)))))

 (t/deftest move-token-of-group
@@ -999,15 +997,15 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token       (get-in token-set [:tokens "group1.test-token-2"])
-        token'      (get-in token-set' [:tokens "group2.updated-name"])]
+        token       (ctob/get-token token-set "group1.test-token-2")
+        token'      (ctob/get-token token-set' "group2.updated-name")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (d/index-of (keys (:tokens token-set')) "group2.updated-name") 1))
+    (t/is (= (d/index-of (keys (ctob/get-tokens-map token-set')) "group2.updated-name") 1))
    (t/is (= (:name token') "group2.updated-name"))
    (t/is (= (:description token') ""))
    (t/is (= (:value token') true))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))
    (t/is (dt/is-after? (:modified-at token') (:modified-at token)))))

 (t/deftest delete-token-in-group
@@ -1026,12 +1024,12 @@

        token-set   (ctob/get-set tokens-lib "test-token-set")
        token-set'  (ctob/get-set tokens-lib' "test-token-set")
-        token'      (get-in token-set' [:tokens "group1.test-token-2"])]
+        token'      (ctob/get-token token-set' "group1.test-token-2")]

    (t/is (= (ctob/set-count tokens-lib') 1))
-    (t/is (= (count (:tokens token-set')) 1))
+    (t/is (= (count (ctob/get-tokens-map token-set')) 1))
    (t/is (nil? token'))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest update-token-set-in-groups
  (let [tokens-lib  (-> (ctob/make-tokens-lib)
@@ -1044,7 +1042,7 @@
        tokens-lib' (-> tokens-lib
                        (ctob/update-set "group1/token-set-2"
                                         (fn [token-set]
-                                           (assoc token-set :description "some description"))))
+                                           (ctob/set-description token-set "some description"))))

        sets-tree   (ctob/get-set-tree tokens-lib)
        sets-tree'  (ctob/get-set-tree tokens-lib')
@@ -1055,9 +1053,9 @@
    (t/is (= (ctob/set-count tokens-lib') 5))
    (t/is (= (count group1') 3))
    (t/is (= (d/index-of (keys group1') "S-token-set-2") 0))
-    (t/is (= (:name token-set') "group1/token-set-2"))
-    (t/is (= (:description token-set') "some description"))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (= (ctob/get-name token-set') "group1/token-set-2"))
+    (t/is (= (ctob/get-description token-set') "some description"))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest rename-token-set-in-groups
  (let [tokens-lib  (-> (ctob/make-tokens-lib)
@@ -1070,8 +1068,7 @@
        tokens-lib' (-> tokens-lib
                        (ctob/update-set "group1/token-set-2"
                                         (fn [token-set]
-                                           (assoc token-set
-                                                  :name "group1/updated-name"))))
+                                           (ctob/rename token-set "group1/updated-name"))))

        sets-tree   (ctob/get-set-tree tokens-lib)
        sets-tree'  (ctob/get-set-tree tokens-lib')
@@ -1082,9 +1079,9 @@
    (t/is (= (ctob/set-count tokens-lib') 5))
    (t/is (= (count group1') 3))
    (t/is (= (d/index-of (keys group1') "S-updated-name") 0))
-    (t/is (= (:name token-set') "group1/updated-name"))
-    (t/is (= (:description token-set') ""))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (= (ctob/get-name token-set') "group1/updated-name"))
+    (t/is (= (ctob/get-description token-set') ""))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest move-token-set-of-group
  (let [tokens-lib  (-> (ctob/make-tokens-lib)
@@ -1097,8 +1094,7 @@
        tokens-lib' (-> tokens-lib
                        (ctob/update-set "group1/token-set-2"
                                         (fn [token-set]
-                                           (assoc token-set
-                                                  :name "group2/updated-name"))))
+                                           (ctob/rename token-set "group2/updated-name"))))

        sets-tree   (ctob/get-set-tree tokens-lib)
        sets-tree'  (ctob/get-set-tree tokens-lib')
@@ -1111,9 +1107,9 @@
    (t/is (= (count group1') 2))
    (t/is (= (count group2') 1))
    (t/is (nil? (get group1' "S-updated-name")))
-    (t/is (= (:name token-set') "group2/updated-name"))
-    (t/is (= (:description token-set') ""))
-    (t/is (dt/is-after? (:modified-at token-set') (:modified-at token-set)))))
+    (t/is (= (ctob/get-name token-set') "group2/updated-name"))
+    (t/is (= (ctob/get-description token-set') ""))
+    (t/is (dt/is-after? (ctob/get-modified-at token-set') (ctob/get-modified-at token-set)))))

 (t/deftest delete-token-set-in-group
  (let [tokens-lib  (-> (ctob/make-tokens-lib)
@@ -1413,7 +1409,7 @@
             tokens-lib' (ctob/parse-decoded-json encoded "")]
         (t/testing "library got updated but data is equal"
           (t/is (not= tokens-lib' tokens-lib))
-           (t/is (= @tokens-lib' @tokens-lib)))))))
+           (t/is (= (datafy tokens-lib') (datafy tokens-lib))))))))

 #?(:clj
   (t/deftest export-dtcg-json-with-default-theme
--- a/frontend/src/app/main/data/workspace/tokens/library_edit.cljs
+++ b/frontend/src/app/main/data/workspace/tokens/library_edit.cljs
@@ -175,7 +175,7 @@
    ptk/WatchEvent
    (watch [it state _]
      (let [data       (dsh/lookup-file-data state)
-            name       (ctob/normalize-set-name name (:name token-set))
+            name       (ctob/normalize-set-name name (ctob/get-name token-set))
            tokens-lib (get data :tokens-lib)]

        (if (ctob/get-set tokens-lib name)
@@ -185,7 +185,7 @@
                            :timeout 9000}))
          (let [changes (-> (pcb/empty-changes it)
                            (pcb/with-library-data data)
-                            (pcb/rename-token-set (:name token-set) name))]
+                            (pcb/rename-token-set (ctob/get-name token-set) name))]
            (rx/of (set-selected-token-set-name name)
                   (dch/commit-changes changes))))))))

@@ -202,7 +202,7 @@
        (when-let [set (ctob/duplicate-set name tokens-lib {:suffix suffix})]
          (let [changes (-> (pcb/empty-changes it)
                            (pcb/with-library-data data)
-                            (pcb/set-token-set (:name set) is-group set))]
+                            (pcb/set-token-set (ctob/get-name set) is-group set))]
            (rx/of (set-selected-token-set-name name)
                   (dch/commit-changes changes))))))))

@@ -346,7 +346,7 @@
                token-type (:type token)
                changes (-> (pcb/empty-changes it)
                            (pcb/with-library-data data)
-                            (pcb/set-token (:name token-set)
+                            (pcb/set-token (ctob/get-name token-set)
                                           (:name token)
                                           token))]

@@ -371,7 +371,7 @@
            token-type (:type token)
            changes   (-> (pcb/empty-changes it)
                          (pcb/with-library-data data)
-                          (pcb/set-token (:name token-set)
+                          (pcb/set-token (ctob/get-name token-set)
                                         (:name token)
                                         token'))]

--- a/frontend/src/app/main/data/workspace/tokens/selected_set.cljs
+++ b/frontend/src/app/main/data/workspace/tokens/selected_set.cljs
@@ -17,7 +17,7 @@
              (get :tokens-lib)
              (ctob/get-sets)
              (first)
-              :name)))
+              (ctob/get-name))))

 (defn get-selected-token-set [state]
  (when-let [set-name (get-selected-token-set-name state)]
@@ -31,4 +31,4 @@

 (defn get-all-tokens-in-selected-set [state]
  (some-> (get-selected-token-set state)
-          :tokens))
+          (ctob/get-tokens-map)))
--- a/frontend/src/app/main/ui/workspace/tokens/management.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/management.cljs
@@ -80,7 +80,7 @@
        ;; select the first one from the list of sets
        selected-token-set-tokens
        (when selected-token-set
-          (get selected-token-set :tokens))
+          (ctob/get-tokens-map selected-token-set))

        tokens
        (mf/with-memo [active-theme-tokens selected-token-set-tokens]
@@ -120,7 +120,7 @@
                          (not (ctob/get-set tokens-lib selected-token-set-name)))))
        (let [match (->> (ctob/get-sets tokens-lib)
                         (first)
-                         (:name))]
+                         (ctob/get-name))]
          (st/emit! (dwtl/set-selected-token-set-name match)))))

    [:*
--- a/frontend/src/app/main/ui/workspace/tokens/sets/lists.cljs
+++ b/frontend/src/app/main/ui/workspace/tokens/sets/lists.cljs
@@ -212,7 +212,7 @@
  [{:keys [id set label tree-depth tree-path tree-index is-selected is-active is-draggable is-editing
           on-select on-drop on-toggle on-start-edition on-reset-edition on-edit-submit]}]

-  (let [set-name  (get set :name)
+  (let [set-name  (ctob/get-name set)
        can-edit? (mf/use-ctx ctx/can-edit?)

        on-click