Feature: strings API fns

deps.edn

@@ -9,14 +9,14 @@
          byte-streams/byte-streams       {:mvn/version "0.2.4"}
          cheshire/cheshire               {:mvn/version "5.11.0"}
          instaparse/instaparse           {:mvn/version "1.4.12"}
-         metosin/malli                   {:mvn/version "0.9.2"}
+         metosin/malli                   {:mvn/version "0.10.4"}
          com.fluree/json-ld              {:git/url "https://github.com/fluree/json-ld.git"
                                           :sha     "a909330e33196504ef8a5411aaa0409ab72aaa35"}
 
          ;; logging
          org.clojure/tools.logging       {:mvn/version "1.2.4"}
          ch.qos.logback/logback-classic  {:mvn/version "1.4.5"}
-         org.slf4j/slf4j-api             {:mvn/version "2.0.5"}
+         org.slf4j/slf4j-api             {:mvn/version "2.0.6"}
 
          ;; Lucene
          clucie/clucie                   {:mvn/version "0.4.2"}
@@ -43,23 +43,23 @@
 
  :aliases
  {:build
-  {:deps       {io.github.clojure/tools.build {:git/tag "v0.8.5"
-                                               :git/sha "b73ff34"}
+  {:deps       {io.github.clojure/tools.build {:git/tag "v0.9.4"
+                                               :git/sha "b0ee58b"}
                 slipset/deps-deploy           {:mvn/version "0.2.0"}}
    :ns-default build}
 
   :dev
   {:extra-paths ["dev" "test" "dev-resources" "src-cljs" "src-nodejs" "src-docs"]
-   :extra-deps  {org.clojure/tools.namespace       {:mvn/version "1.3.0"}
+   :extra-deps  {org.clojure/tools.namespace       {:mvn/version "1.4.2"}
                  criterium/criterium               {:mvn/version "0.4.6"}
                  figwheel-sidecar/figwheel-sidecar {:mvn/version "0.5.20"}
-                 thheller/shadow-cljs              {:mvn/version "2.20.12"}
-                 com.magnars/test-with-files {:mvn/version "2021-02-17"}}}
+                 thheller/shadow-cljs              {:mvn/version "2.22.0"}
+                 com.magnars/test-with-files       {:mvn/version "2021-02-17"}}}
 
   :cljtest
   {:extra-paths ["test" "dev-resources"]
-   :extra-deps  {lambdaisland/kaocha         {:mvn/version "1.71.1119"}
-                 org.clojure/test.check      {:mvn/version "1.1.1"}
+   :extra-deps  {lambdaisland/kaocha                   {:mvn/version "1.80.1274"}
+                 org.clojure/test.check                {:mvn/version "1.1.1"}
                  io.github.cap10morgan/test-with-files {:git/tag "v1.0.0"
                                                         :git/sha "9181a2e"}}
    :exec-fn     kaocha.runner/exec-fn
@@ -91,20 +91,20 @@
    :main-opts   ["-m" "cloverage.coverage" "-p" "src" "-s" "test" "--output" "scanning_results/coverage"]}
 
   :eastwood
-  {:extra-deps  {jonase/eastwood {:mvn/version "1.3.0"}}
-   :main-opts   ["-m" "eastwood.lint"
-                 {:source-paths ["src" "src-docs"]
-                  :test-paths   ["test"]
-                  ;; TODO: Un-exclude this when it stops triggering false
-                  ;;       positives on "UnsupportedOperationException empty is
-                  ;;       not supported on Flake" when using the #Flake data
-                  ;;       reader - WSM 2023-02-01
-                  :exclude-linters [:implicit-dependencies]}]}
+  {:extra-deps {jonase/eastwood {:mvn/version "1.3.0"}}
+   :main-opts  ["-m" "eastwood.lint"
+                {:source-paths    ["src" "src-docs"]
+                 :test-paths      ["test"]
+                 ;; TODO: Un-exclude this when it stops triggering false
+                 ;;       positives on "UnsupportedOperationException empty is
+                 ;;       not supported on Flake" when using the #Flake data
+                 ;;       reader - WSM 2023-02-01
+                 :exclude-linters [:implicit-dependencies]}]}
 
   :ancient
   {:extra-deps {com.github.liquidz/antq {:mvn/version "RELEASE"}}
    :main-opts  ["-m" "antq.core"]}
 
   :clj-kondo
-  {:extra-deps {clj-kondo/clj-kondo {:mvn/version "2022.11.02"}}
+  {:extra-deps {clj-kondo/clj-kondo {:mvn/version "2023.02.17"}}
    :main-opts  ["-m" "clj-kondo.main" "--lint" "src" "--config" ".clj-kondo/config.edn"]}}}

dev/user.clj

@@ -46,7 +46,7 @@
       "8ce4eca704d653dec594703c81a84c403c39f262e54ed014ed857438933a2e1c")
 
 
-    (def did (did/private->did-map default-private-key ))
+    (def did (did/private->did-map default-private-key))
 
     (def default-context
       {:id     "@id"
@@ -71,37 +71,37 @@
   (def ledger @(fluree/create file-conn "user/test"))
 
   (def db1 @(fluree/stage
-            (fluree/db ledger)
-            [{:context      {:ex "http://example.org/ns/"}
-              :id           :ex/brian,
-              :type         :ex/User,
-              :schema/name  "Brian"
-              :schema/email "[email protected]"
-              :schema/age   50
-              :ex/favNums   7
-              }
-             {:context      {:ex "http://example.org/ns/"}
-              :id           :ex/alice,
-              :type         :ex/User,
-              :schema/name  "Alice"
-              :schema/email "[email protected]"
-              :schema/age   50
-              :ex/favNums   [42, 76, 9]
-              }
-             {:context      {:ex "http://example.org/ns/"}
-              :id           :ex/cam,
-              :type         :ex/User,
-              :schema/name  "Cam"
-              :schema/email "[email protected]"
-              :schema/age   34
-              :ex/favNums   [5, 10]
-              :ex/friend    [:ex/brian :ex/alice]}]))
+             (fluree/db ledger)
+             [{:context      {:ex "http://example.org/ns/"}
+               :id           :ex/brian,
+               :type         :ex/User,
+               :schema/name  "Brian"
+               :schema/email "[email protected]"
+               :schema/age   50
+               :ex/favNums   7}
+
+              {:context      {:ex "http://example.org/ns/"}
+               :id           :ex/alice,
+               :type         :ex/User,
+               :schema/name  "Alice"
+               :schema/email "[email protected]"
+               :schema/age   50
+               :ex/favNums   [42, 76, 9]}
+
+              {:context      {:ex "http://example.org/ns/"}
+               :id           :ex/cam,
+               :type         :ex/User,
+               :schema/name  "Cam"
+               :schema/email "[email protected]"
+               :schema/age   34
+               :ex/favNums   [5, 10]
+               :ex/friend    [:ex/brian :ex/alice]}]))
 
   (def db2 @(fluree/commit! ledger db1 {:message "hi"}))
 
-  @(fluree/load file-conn (-> ledger :alias))
+  @(fluree/load file-conn (-> ledger :alias)))
+
 
-  )
 
 ;; TODO - general
 ;; if an subject is a component, do we allow it to be explicitly assigned as a ref to another component?

src/fluree/db/api/query.cljc

@@ -9,6 +9,7 @@
             [fluree.db.query.range :as query-range]
             [fluree.db.util.core :as util]
             [fluree.db.util.async :as async-util :refer [<? go-try]]
+            [fluree.db.util.log :as log]
             [fluree.db.json-ld.policy :as perm]
             [fluree.db.json-ld.credential :as cred]))
 
@@ -23,15 +24,15 @@
                            (pr-str query-map))
                       {:status 400
                        :error  :db/invalid-query}))
-
-      (let [{:keys [opts]}                                         query-map
+      (let [{:strs [opts]}                                         query-map
             db*                                                    (if-let [policy-opts (perm/policy-opts opts)]
                                                                      (<? (perm/wrap-policy db policy-opts))
                                                                      db)
-            {:keys [context history t commit-details] :as _parsed} (history/history-query-parser query-map)
+            {:strs [context history t commit-details] :as parsed} (history/history-query-parser query-map)
+            _ (log/debug "parsed history query:" parsed)
 
             ;; from and to are positive ints, need to convert to negative or fill in default values
-            {:keys [from to at]} t
+            {:strs [from to at]} t
             [from-t to-t]        (if at
                                    (let [t (cond (= "latest" at) (:t db*)
                                                  (string? at)   (<? (time-travel/datetime->t db* at))
@@ -55,18 +56,18 @@
                 flake-slice-ch (query-range/time-range db* idx = pattern {:from-t from-t :to-t to-t})
                 flake-ch       (async/chan 1 cat)
 
-                _ (async/pipe flake-slice-ch flake-ch)
+                _                    (async/pipe flake-slice-ch flake-ch)
 
-                flakes (async/<! (async/into [] flake-ch))
+                flakes               (async/<! (async/into [] flake-ch))
 
                 history-results-chan (history/history-flakes->json-ld db* parsed-context error-ch flakes)]
 
             (if commit-details
               ;; annotate with commit details
               (async/alt!
-                 (async/into [] (history/add-commit-details db* parsed-context error-ch history-results-chan))
-                 ([result] result)
-                 error-ch ([e] e))
+               (async/into [] (history/add-commit-details db* parsed-context error-ch history-results-chan))
+               ([result] result)
+               error-ch ([e] e))
 
               ;; we're already done
               (async/alt!
@@ -84,13 +85,12 @@
   "Execute a query against a database source, or optionally
   additional sources if the query spans multiple data sets.
   Returns core async channel containing result or exception."
-  [sources query]
+  [sources {:strs [opts t] :as query}]
   (go-try
     (let [{query :subject, issuer :issuer}
           (or (<? (cred/verify query))
               {:subject query})
 
-          {:keys [opts t]} query
           db               (if (async-util/channel? sources) ;; only support 1 source currently
                              (<? sources)
                              sources)
@@ -105,16 +105,34 @@
                                (assoc-in [:policy :cache] (atom {})))
           opts*         (-> opts
                             (assoc :issuer issuer)
-                            (dissoc :meta))
+                            (dissoc "meta"))
           start         #?(:clj (System/nanoTime)
                            :cljs (util/current-time-millis))
-          result        (<? (fql/query db** (assoc query :opts opts*)))]
-      (if (:meta opts)
-        {:status 200
-         :result result
-         :time   (util/response-time-formatted start)}
+          result        (<? (fql/query db** (assoc query "opts" opts*)))]
+      (if (get opts "meta")
+        {"status" 200
+         "result" result
+         "time"   (util/response-time-formatted start)}
         result))))
 
+(defn- multi-query-map
+  "Processes each query in a multi-query and associates them into `m` under the
+  `alias` key. `global-opts` is first so closures can be created around that for
+   the whole multi-query."
+  [global-opts m alias query]
+  (let [query-opts         (get query "opts")
+        _                  (when (perm/policy-opts query-opts)
+                             (throw (ex-info "Applying policy via `:opts` on individual queries in a multi-query is not supported."
+                                             {:status 400
+                                              :error  :db/invalid-query})))
+        query-meta         (get query-opts "meta")
+        default-meta       (get global-opts "meta")
+        meta?              (or default-meta query-meta)
+        remove-meta?       (and meta? (not query-meta)) ;; query didn't ask for meta, but multiquery did so must strip it
+        opts*              {"meta" meta? ::remove-meta? remove-meta?}
+        query*             (assoc query "opts" opts*)]
+    (assoc m alias query*)))
+
 (defn multi-query
   "Performs multiple queries in a map, with the key being the alias for the query
   and the value being the query itself. Each query result will be in a response
@@ -132,67 +150,47 @@
            - errors - map of query alias to their respective error"
   [source flureeQL]
   (go-try
-   (let [global-opts         (:opts flureeQL)
-         db                  (if-let [policy-opts (perm/policy-opts global-opts)]
+    (let [global-opts        (get flureeQL "opts")
+          db                 (if-let [policy-opts (perm/policy-opts global-opts)]
                                (<? (perm/wrap-policy source policy-opts))
                                source)
-         global-context-type (:context-type global-opts)
-
-         global-meta         (:meta global-opts) ;; if true, need to collect meta for each query to total up
-         ;; update individual queries for :meta if not otherwise specified
-         queries             (reduce-kv
-                              (fn [acc alias query]
-                                (let [query-opts (:opts query)]
-                                  (if-let [policy-opts (perm/policy-opts query-opts)]
-                                    (throw (ex-info "Applying policy via `:opts` on individual queries in a multi-query is not supported."
-                                                    {:status 400
-                                                     :error  :db/invalid-query}))
-                                        (let [query-meta   (:meta query-opts)
-                                              context-type (-> query-opts
-                                                               :context-type
-                                                               (or global-context-type))
-                                              meta?        (or global-meta query-meta)
-                                              remove-meta? (and meta? (not query-meta)) ;; query didn't ask for meta, but multiquery did so must strip it
-                                              opts*        (-> (:opts query)
-                                                               (assoc :meta meta? :-remove-meta? remove-meta?)
-                                                               (cond-> context-type (assoc :context-type context-type)))
-                                              query*       (assoc query :opts opts*)]
-                                            (assoc acc alias query*)))))
-                              {} (dissoc flureeQL :opts))
-         start-time #?(:clj (System/nanoTime) :cljs (util/current-time-millis))
-         ;; kick off all queries in parallel, each alias now mapped to core async channel
-         pending-resp       (map (fn [[alias q]] [alias (query db q)]) queries)]
-     (loop [[[alias port] & r] pending-resp
-            status-global nil                            ;; overall status.
-            response      {}]
-       (if (nil? port)                                   ;; done?
-         (if global-meta
-           {:result response
-            :status status-global
-            :time   (util/response-time-formatted start-time)}
-           response)
-         (let [{:keys [meta -remove-meta?]} (get-in queries [alias :opts])
-               res            (async/<! port)
-               error?         (:error res)               ;; if error key is present in response, it is an error
-               status-global* (when meta
-                                (let [status (:status res)]
-                                  (cond
-                                    (nil? status-global)
-                                    status
-
-                                    (= status-global status)
-                                    status
-
-                                    ;; any 200 response with any other is a 207
-                                    (or (= 200 status) (= 200 status-global) (= 207 status-global))
-                                    207
-
-                                    ;; else take the max status
-                                    :else
-                                    (max status status-global))))
-               response*      (if error?
-                                (assoc-in response [:errors alias] res)
-                                (assoc response alias (if -remove-meta?
-                                                        (:result res)
-                                                        res)))]
-           (recur r status-global* response*)))))))
+          queries            (reduce-kv (partial multi-query-map global-opts)
+                                        {} (dissoc flureeQL "opts"))
+          _                  (log/debug "multi-query queries:" queries)
+          start-time #?(:clj (System/nanoTime) :cljs (util/current-time-millis))
+          ;; kick off all queries in parallel, each alias now mapped to core async channel
+          pending-resp       (map (fn [[alias q]] [alias (query db q)]) queries)]
+      (loop [[[alias port] & r] pending-resp
+             status-global nil ;; overall status.
+             response      {}]
+        (if (nil? port) ;; done?
+          (if (get global-opts "meta")
+            {"result" response
+             "status" status-global
+             "time"   (util/response-time-formatted start-time)}
+            response)
+          (let [{:strs [meta] remove-meta? ::remove-meta?} (get-in queries [alias "opts"])
+                res            (async/<! port)
+                error?         (:error res) ;; if error key is present in response, it is an error
+                status-global* (when meta
+                                 (let [status (get res "status")]
+                                   (cond
+                                     (nil? status-global)
+                                     status
+
+                                     (= status-global status)
+                                     status
+
+                                     ;; any 200 response with any other is a 207
+                                     (or (= 200 status) (= 200 status-global) (= 207 status-global))
+                                     207
+
+                                     ;; else take the max status
+                                     :else
+                                     (max status status-global))))
+                response*      (if error?
+                                 (assoc-in response ["errors" alias] res)
+                                 (assoc response alias (if remove-meta?
+                                                         (get res "result")
+                                                         res)))]
+            (recur r status-global* response*)))))))