feat: select to delete rows from query result

src/main/frontend/components/objects.cljs

@@ -182,6 +182,9 @@
                                      (let [pages (filter ldb/page? selected-rows)
                                            blocks (remove ldb/page? selected-rows)]
                                        (p/do!
+                                        (set-data! (get-class-objects class))
+                                        (when-let [f (get-in table [:data-fns :set-row-selection!])]
+                                          (f {}))
                                         (ui-outliner-tx/transact!
                                          {:outliner-op :delete-blocks}
                                          (when (seq blocks)
@@ -189,10 +192,7 @@
                                          (let [page-ids (map :db/id pages)
                                                tx-data (map (fn [pid] [:db/retract pid :block/tags (:db/id class)]) page-ids)]
                                            (when (seq tx-data)
-                                             (outliner-op/transact! tx-data {:outliner-op :save-block}))))
-                                        (set-data! (get-class-objects class))
-                                        (when-let [f (get-in table [:data-fns :set-row-selection!])]
-                                          (f {})))))}))))
+                                             (outliner-op/transact! tx-data {:outliner-op :save-block})))))))}))))
 
 (rum/defcs class-objects < rum/reactive db-mixins/query mixins/container-id
   [state class {:keys [current-page? sidebar?]}]
@@ -258,6 +258,9 @@
                                        (let [pages (filter ldb/page? selected-rows)
                                              blocks (remove ldb/page? selected-rows)]
                                          (p/do!
+                                          (set-data! (get-property-related-objects (state/get-current-repo) property))
+                                          (when-let [f (get-in table [:data-fns :set-row-selection!])]
+                                            (f {}))
                                           (ui-outliner-tx/transact!
                                            {:outliner-op :delete-blocks}
                                            (when (seq blocks)
@@ -265,10 +268,7 @@
                                            (let [page-ids (map :db/id pages)
                                                  tx-data (map (fn [pid] [:db/retract pid (:db/ident property)]) page-ids)]
                                              (when (seq tx-data)
-                                               (outliner-op/transact! tx-data {:outliner-op :save-block}))))
-                                          (set-data! (get-property-related-objects (state/get-current-repo) property))
-                                          (when-let [f (get-in table [:data-fns :set-row-selection!])]
-                                            (f {}))))))}))))
+                                               (outliner-op/transact! tx-data {:outliner-op :save-block}))))))))}))))
 
 ;; Show all nodes containing the given property
 (rum/defcs property-related-objects < rum/reactive db-mixins/query mixins/container-id

src/main/frontend/components/query/view.cljs

@@ -4,7 +4,11 @@
             [frontend.db :as db]
             [logseq.db :as ldb]
             [rum.core :as rum]
-            [frontend.mixins :as mixins]))
+            [frontend.mixins :as mixins]
+            [promesa.core :as p]
+            [frontend.modules.outliner.ui :as ui-outliner-tx]
+            [frontend.modules.outliner.op :as outliner-op]
+            [frontend.state]))
 
 (defn- columns
   [config result]
@@ -41,11 +45,25 @@
   [state config view-entity result]
   (let [*result (::result state)
         result' (or @*result (init-result result view-entity))
-        columns' (columns (assoc config :container-id (::container-id state)) result')]
+        columns' (columns (assoc config :container-id (::container-id state)) result')
+        set-data! (fn [data] (reset! *result data))]
     [:div.query-result.w-full
      (views/view view-entity
                  {:title-key :views.table/live-query-title
                   :data result'
-                  :set-data! (fn [data]
-                               (when (seq data) (reset! *result data)))
-                  :columns columns'})]))
+                  :set-data! set-data!
+                  :columns columns'
+                  :on-delete-rows (fn [table selected-rows]
+                                    (let [pages (filter ldb/page? selected-rows)
+                                          blocks (remove ldb/page? selected-rows)
+                                          selected (set (map :id selected-rows))
+                                          data' (remove (fn [row] (contains? selected (:id row))) (:data table))]
+                                      (p/do!
+                                       (set-data! data')
+                                       (ui-outliner-tx/transact!
+                                        {:outliner-op :delete-blocks}
+                                        (when (seq blocks)
+                                          (outliner-op/delete-blocks! blocks nil))
+                                        (doseq [page pages]
+                                          (when-let [id (:block/uuid page)]
+                                            (outliner-op/delete-page! id)))))))})]))

src/main/frontend/components/views.cljs

@@ -1278,18 +1278,17 @@
         (more-actions columns table)
 
         (when add-new-object! (new-record-button table view-entity))]]
-      (fn []
-        [:div.ls-view-body.flex.flex-col.gap-2.grid
-         (filters-row table)
+      [:div.ls-view-body.flex.flex-col.gap-2.grid
+       (filters-row table)
 
-         (case display-type
-           :logseq.property.view/type.list
-           (list-view (:config option) view-entity (:rows table))
+       (case display-type
+         :logseq.property.view/type.list
+         (list-view (:config option) view-entity (:rows table))
 
-           :logseq.property.view/type.gallery
-           (gallery-view (:config option) table view-entity (:rows table) *scroller-ref)
+         :logseq.property.view/type.gallery
+         (gallery-view (:config option) table view-entity (:rows table) *scroller-ref)
 
-           (table-view table option row-selection add-new-object! *scroller-ref))])
+         (table-view table option row-selection add-new-object! *scroller-ref))]
       {:title-trigger? false})]))
 
 (rum/defcs view

src/main/frontend/modules/outliner/ui.cljc

@@ -1,6 +1,6 @@
 (ns frontend.modules.outliner.ui
   #?(:cljs (:require-macros [frontend.modules.outliner.ui]))
-  #?(:cljs (:require [frontend.state :as state]
+  #?(:cljs (:require [frontend.state]
                      [frontend.db.transact]
                      [frontend.db.conn]
                      [logseq.outliner.op]
@@ -11,32 +11,32 @@
   [opts & body]
   `(let [test?# frontend.util/node-test?]
      (let [ops# frontend.modules.outliner.op/*outliner-ops*
-           editor-info# (state/get-editor-info)]
+           editor-info# (frontend.state/get-editor-info)]
        (if ops#
          (do ~@body)                    ; nested transact!
          (binding [frontend.modules.outliner.op/*outliner-ops* (transient [])]
            ~@body
            (let [r# (persistent! frontend.modules.outliner.op/*outliner-ops*)
-                 worker# @state/*db-worker]
+                 worker# @frontend.state/*db-worker]
             ;;  (js/console.groupCollapsed "ui/transact!")
             ;;  (prn :ops r#)
             ;;  (js/console.trace)
             ;;  (js/console.groupEnd)
              (if test?#
                (when (seq r#)
-                 (logseq.outliner.op/apply-ops! (state/get-current-repo)
+                 (logseq.outliner.op/apply-ops! (frontend.state/get-current-repo)
                                                 (frontend.db.conn/get-db false)
                                                 r#
-                                                (state/get-date-formatter)
+                                                (frontend.state/get-date-formatter)
                                                 ~opts))
                (when (and worker# (seq r#))
-                 (let [request-id# (state/get-worker-next-request-id)
-                       request# #(.apply-outliner-ops ^Object worker# (state/get-current-repo)
+                 (let [request-id# (frontend.state/get-worker-next-request-id)
+                       request# #(.apply-outliner-ops ^Object worker# (frontend.state/get-current-repo)
                                                       (logseq.db/write-transit-str r#)
                                                       (logseq.db/write-transit-str
                                                        (assoc ~opts
                                                               :request-id request-id#
                                                               :editor-info editor-info#)))
-                       response# (state/add-worker-request! request-id# request#)]
+                       response# (frontend.state/add-worker-request! request-id# request#)]
 
                    response#)))))))))