refactor: move rules deps usage into helper fn

Dries up task dependency that was copied in query-dsl

deps/db/src/logseq/db/frontend/rules.cljc

@@ -245,11 +245,17 @@
 
 (defn extract-rules
   "Given a rules map and the rule names to extract, returns a vector of rules to
-  be passed to datascript.core/q. Can handle rules with multiple or single clauses"
+  be passed to datascript.core/q. Can handle rules with multiple or single clauses.
+  Takes following options:
+   * :deps - A map of rule names to their dependencies. Only one-level of dependencies are resolved.
+   No dependencies are detected by default though we could add it later e.g. find-rules-in-where"
   ([rules-m] (extract-rules rules-m (keys rules-m)))
-  ([rules-m rules]
-   (vec
-    (mapcat #(let [val (rules-m %)]
-              ;; if vector?, rule has multiple clauses
-               (if (vector? (first val)) val [val]))
-            rules))))
+  ([rules-m rules & {:keys [deps]}]
+   (let [rules-with-deps (concat rules
+                                 (when (map? deps)
+                                   (mapcat deps rules)))]
+     (vec
+      (mapcat #(let [val (rules-m %)]
+                 ;; if vector?, rule has multiple clauses
+                 (if (vector? (first val)) val [val]))
+              rules-with-deps)))))

src/main/frontend/db/query_custom.cljs

@@ -28,10 +28,7 @@
   [{:keys [query] :as query-m} {:keys [db-graph?]}]
   (let [{:keys [where in]} (datalog-util/query-vec->map query)
         query-dsl-rules (if db-graph? rules/db-query-dsl-rules rules/query-dsl-rules)
-        rules-found* (datalog-util/find-rules-in-where where (-> query-dsl-rules keys set))
-        rules-found (cond-> rules-found*
-                      db-graph?
-                      (concat (mapcat rules/rules-dependencies rules-found*)))]
+        rules-found (datalog-util/find-rules-in-where where (-> query-dsl-rules keys set))]
     (if (seq rules-found)
       (if (and (= '% (last in)) (vector? (last (:inputs query-m))))
         ;; Add to existing :inputs rules
@@ -41,7 +38,10 @@
                   (assoc (vec inputs)
                          ;; last position is rules
                          (dec (count inputs))
-                         (->> (rules/extract-rules query-dsl-rules rules-found)
+                         (->> (rules/extract-rules query-dsl-rules
+                                                   rules-found
+                                                   (when db-graph?
+                                                     {:deps rules/rules-dependencies}))
                               (into (last inputs))
                               ;; user could give rules that we already have
                               distinct
@@ -59,7 +59,10 @@
             (update :rules
                     (fn [rules]
                       (into (or rules [])
-                            (rules/extract-rules query-dsl-rules rules-found))))))
+                            (rules/extract-rules query-dsl-rules
+                                                   rules-found
+                                                   (when db-graph?
+                                                     {:deps rules/rules-dependencies})))))))
       query-m)))
 
 (defn custom-query

src/main/frontend/db/query_dsl.cljs

@@ -298,7 +298,7 @@
     (when (seq markers)
       (if db-graph?
         {:query (list 'task '?b (set markers))
-         :rules [:task :property]}
+         :rules [:task]}
         (let [markers (set (map (comp string/upper-case name) markers))]
           {:query (list 'task '?b markers)
            :rules [:task]})))))
@@ -564,7 +564,7 @@ Some bindings in this fn:
                       (add-bindings! (if (= key :and) (rest result) result))))]
       {:query result'
        :rules (if db-graph?
-                (rules/extract-rules rules/db-query-dsl-rules rules)
+                (rules/extract-rules rules/db-query-dsl-rules rules {:deps rules/rules-dependencies})
                 (mapv rules/query-dsl-rules rules))
        :sort-by @sort-by
        :blocks? (boolean @blocks?)