fix: db migrate

src/main/frontend/worker/db/migrate.cljs

@@ -127,32 +127,34 @@
                                    [:db/add (:e d) :block/title title'])))))
         sorting-tx (->> (d/datoms db :avet :logseq.property.table/sorting)
                         (keep (fn [d]
-                                (when-let [props (seq (filter (fn [[old _new]]
-                                                                (some (fn [item] (= old (:id item))) (:v d))) props-to-rename))]
-                                  (let [value (reduce
-                                               (fn [sorting [old new]]
-                                                 (mapv
-                                                  (fn [item]
-                                                    (if (= old (:id item))
-                                                      (assoc item :id new)
-                                                      item))
-                                                  sorting))
-                                               (:v d)
-                                               props)]
-                                    [:db/add (:e d) :logseq.property.table/sorting value])))))
+                                (when (coll? (:v d))
+                                  (when-let [props (seq (filter (fn [[old _new]]
+                                                                  (some (fn [item] (= old (:id item))) (:v d))) props-to-rename))]
+                                    (let [value (reduce
+                                                 (fn [sorting [old new]]
+                                                   (mapv
+                                                    (fn [item]
+                                                      (if (= old (:id item))
+                                                        (assoc item :id new)
+                                                        item))
+                                                    sorting))
+                                                 (:v d)
+                                                 props)]
+                                      [:db/add (:e d) :logseq.property.table/sorting value]))))))
         sized-columns-tx (->> (d/datoms db :avet :logseq.property.table/sized-columns)
                               (keep (fn [d]
-                                      (when-let [props (seq (filter (fn [[old _new]] (get (:v d) old)) props-to-rename))]
-                                        (let [value (reduce
-                                                     (fn [sizes [old new]]
-                                                       (if-let [size (get sizes old)]
-                                                         (-> sizes
-                                                             (dissoc old)
-                                                             (assoc new size))
-                                                         sizes))
-                                                     (:v d)
-                                                     props)]
-                                          [:db/add (:e d) :logseq.property.table/sized-columns value])))))
+                                      (when (map? (:v d))
+                                        (when-let [props (seq (filter (fn [[old _new]] (get (:v d) old)) props-to-rename))]
+                                          (let [value (reduce
+                                                       (fn [sizes [old new]]
+                                                         (if-let [size (get sizes old)]
+                                                           (-> sizes
+                                                               (dissoc old)
+                                                               (assoc new size))
+                                                           sizes))
+                                                       (:v d)
+                                                       props)]
+                                            [:db/add (:e d) :logseq.property.table/sized-columns value]))))))
         hidden-columns-tx (mapcat
                            (fn [[old new]]
                              (->> (d/datoms db :avet :logseq.property.table/hidden-columns old)
@@ -162,31 +164,33 @@
                            props-to-rename)
         ordered-columns-tx (->> (d/datoms db :avet :logseq.property.table/ordered-columns)
                                 (keep (fn [d]
-                                        (when-let [props (seq (filter (fn [[old _new]] ((set (:v d)) old)) props-to-rename))]
-                                          (let [value (reduce
-                                                       (fn [col [old new]]
-                                                         (mapv (fn [v] (if (= old v) new v)) col))
-                                                       (:v d)
-                                                       props)]
-                                            [:db/add (:e d) :logseq.property.table/ordered-columns value])))))
+                                        (when (coll? (:v d))
+                                          (when-let [props (seq (filter (fn [[old _new]] ((set (:v d)) old)) props-to-rename))]
+                                            (let [value (reduce
+                                                         (fn [col [old new]]
+                                                           (mapv (fn [v] (if (= old v) new v)) col))
+                                                         (:v d)
+                                                         props)]
+                                              [:db/add (:e d) :logseq.property.table/ordered-columns value]))))))
         filters-tx (->> (d/datoms db :avet :logseq.property.table/filters)
                         (keep (fn [d]
                                 (let [filters (:filters (:v d))]
-                                  (when-let [props (seq (filter (fn [[old _new]]
-                                                                  (some (fn [item] (and (vector? item)
-                                                                                        (= old (first item)))) filters)) props-to-rename))]
-                                    (let [value (update (:v d) :filters
-                                                        (fn [col]
-                                                          (reduce
-                                                           (fn [col [old new]]
-                                                             (mapv (fn [item]
-                                                                     (if (and (vector? item) (= old (first item)))
-                                                                       (vec (cons new (rest item)))
-                                                                       item))
-                                                                   col))
-                                                           col
-                                                           props)))]
-                                      [:db/add (:e d) :logseq.property.table/filters value]))))))]
+                                  (when (coll? filters)
+                                    (when-let [props (seq (filter (fn [[old _new]]
+                                                                    (some (fn [item] (and (vector? item)
+                                                                                          (= old (first item)))) filters)) props-to-rename))]
+                                      (let [value (update (:v d) :filters
+                                                          (fn [col]
+                                                            (reduce
+                                                             (fn [col [old new]]
+                                                               (mapv (fn [item]
+                                                                       (if (and (vector? item) (= old (first item)))
+                                                                         (vec (cons new (rest item)))
+                                                                         item))
+                                                                     col))
+                                                             col
+                                                             props)))]
+                                        [:db/add (:e d) :logseq.property.table/filters value])))))))]
     (concat property-tx
             titles-tx
             sorting-tx