enhance(cli): add api mode for export-edn command

Also changes :graph from being a required arg to an option

Author: logseq-cldwalker

deps/cli/README.md

@@ -116,12 +116,15 @@ $ logseq query '(task DOING)' -a my-token
   :uuid "68795144-e5f6-48e8-849d-79cd6473b952"}
   ...
 
-# Export DB graph as markdown
+# Export local graph as markdown
 $ logseq export yep
 Exported 41 pages to yep_markdown_1756128259.zip
 
-# Export DB graph as EDN
-$ logseq export-edn woot -f woot.edn
+# Export current graph as EDN
+$ logseq export-edn -a my-token
+Exported 16 properties, 3 classes and 16 pages to yep_1763407592.edn
+# Export local graph as EDN to specified file
+$ logseq export-edn -g woot -f woot.edn
 Exported 16 properties, 1 classes and 36 pages to woot.edn
 
 # Import into current graph with EDN

deps/cli/src/logseq/cli.cljs

@@ -91,9 +91,8 @@
     :args->opts [:graph] :require [:graph]
     :spec cli-spec/export}
    {:cmds ["export-edn"] :desc "Export DB graph as EDN"
-    :description "Export a graph to EDN like the in-app graph EDN export. See https://github.com/logseq/docs/blob/master/db-version.md#edn-data-export for more about this export type."
+    :description "Export a local graph to EDN or the current in-app graph if --api-server-token is given. See https://github.com/logseq/docs/blob/master/db-version.md#edn-data-export for more about this export type."
     :fn (lazy-load-fn 'logseq.cli.commands.export-edn/export)
-    :args->opts [:graph] :require [:graph]
     :spec cli-spec/export-edn}
    {:cmds ["append"] :desc "Appends text to current page"
     :fn (lazy-load-fn 'logseq.cli.commands.append/append)

deps/cli/src/logseq/cli/commands/export_edn.cljs

@@ -2,20 +2,44 @@
   "Export edn command"
   (:require ["fs" :as fs]
             [clojure.pprint :as pprint]
+            [logseq.cli.util :as cli-util]
+            [logseq.common.util :as common-util]
             [logseq.db.common.sqlite-cli :as sqlite-cli]
             [logseq.db.sqlite.export :as sqlite-export]
-            [logseq.common.util :as common-util]
-            [logseq.cli.util :as cli-util]))
+            [logseq.db.sqlite.util :as sqlite-util]
+            [promesa.core :as p]))
+
+(defn- write-export-edn-map [export-map {:keys [graph file]}]
+  (let [file' (or file (str graph "_" (quot (common-util/time-ms) 1000) ".edn"))]
+    (println (str "Exported " (cli-util/summarize-build-edn export-map) " to " file'))
+    (fs/writeFileSync file' (with-out-str (pprint/pprint export-map)))))
 
-(defn export [{{:keys [graph] :as options} :opts}]
+(defn- build-export-options [options]
+  (cond-> {:export-type (:export-type options)}
+    (= :graph (:export-type options))
+    (assoc :graph-options (dissoc options :file :export-type :graph))))
+
+(defn- local-export [{{:keys [graph] :as options} :opts}]
+  (when-not graph
+    (cli-util/error "Command missing required option 'graph'"))
   (if (fs/existsSync (cli-util/get-graph-path graph))
     (let [conn (apply sqlite-cli/open-db! (cli-util/->open-db-args graph))
-          export-map (sqlite-export/build-export @conn
-                                                 (cond-> {:export-type (:export-type options)}
-                                                   (= :graph (:export-type options))
-                                                   (assoc :graph-options (dissoc options :file :export-type :graph))))
-          file (or (:file options) (str graph "_" (quot (common-util/time-ms) 1000) ".edn"))]
-      (println (str "Exported " (cli-util/summarize-build-edn export-map) " to " file))
-      (fs/writeFileSync file
-                        (with-out-str (pprint/pprint export-map))))
-    (cli-util/error "Graph" (pr-str graph) "does not exist")))
+          export-map (sqlite-export/build-export @conn (build-export-options options))]
+      (write-export-edn-map export-map options))
+    (cli-util/error "Graph" (pr-str graph) "does not exist")))
+
+(defn- api-export
+  [{{:keys [api-server-token] :as options} :opts}]
+  (let [opts (build-export-options options)]
+    (-> (p/let [resp (cli-util/api-fetch api-server-token "logseq.cli.export_edn" [(clj->js opts)])]
+          (if (= 200 (.-status resp))
+            (p/let [body (.json resp)
+                    export-map (sqlite-util/transit-read (aget body "export-body"))]
+              (write-export-edn-map export-map (assoc options :graph (.-graph body))))
+            (cli-util/api-handle-error-response resp)))
+        (p/catch cli-util/command-catch-handler))))
+
+(defn export [{{:keys [api-server-token]} :opts :as m}]
+  (if api-server-token
+    (api-export m)
+    (local-export m)))

deps/cli/src/logseq/cli/commands/import_edn.cljs

@@ -20,7 +20,7 @@
       (p/catch cli-util/command-catch-handler)))
 
 (defn- local-import [{:keys [graph]} import-map]
-  (if (and graph (fs/existsSync (cli-util/get-graph-path graph)))
+  (if (fs/existsSync (cli-util/get-graph-path graph))
     (let [conn (apply sqlite-cli/open-db! (cli-util/->open-db-args graph))
           {:keys [init-tx block-props-tx misc-tx]}
           (sqlite-export/build-import import-map @conn {})

deps/cli/src/logseq/cli/spec.cljs

@@ -7,7 +7,11 @@
           :desc "File to save export"}})
 
 (def export-edn
-  {:include-timestamps? {:alias :T
+  {:api-server-token {:alias :a
+                      :desc "API server token to export current graph"}
+   :graph {:alias :g
+           :desc "Local graph to export"}
+   :include-timestamps? {:alias :T
                          :desc "Include timestamps in export"}
    :file {:alias :f
           :desc "File to save export"}
@@ -27,24 +31,24 @@
 
 (def import-edn
   {:api-server-token {:alias :a
-                      :desc "API server token to query current graph"}
+                      :desc "API server token to import into current graph"}
    :graph {:alias :g
            :desc "Local graph to import into"}
    :file {:alias :f
           :require true
           :desc "EDN File to import"}})
 
 (def query
-  {:graphs {:alias :g
+  {:api-server-token {:alias :a
+                      :desc "API server token to query current graph"}
+   :graphs {:alias :g
             :coerce []
             :desc "Additional graphs to local query"}
    :properties-readable {:alias :p
                          :coerce :boolean
                          :desc "Make properties on local, entity queries show property values instead of ids"}
    :title-query {:alias :t
-                 :desc "Invoke local query on :block/title"}
-   :api-server-token {:alias :a
-                      :desc "API server token to query current graph"}})
+                 :desc "Invoke local query on :block/title"}})
 
 (def search
   {:api-server-token {:alias :a

src/main/logseq/api.cljs

@@ -214,6 +214,7 @@
 (def ^:export get_page_data cli-based-api/get-page-data)
 (def ^:export upsert_nodes cli-based-api/upsert-nodes)
 (def ^:export import_edn cli-based-api/import-edn)
+(def ^:export export_edn cli-based-api/export-edn)
 
 ;; file based graph APIs
 (def ^:export get_current_graph_templates file-based-api/get_current_graph_templates)

src/main/logseq/api/db_based/cli.cljs

@@ -5,8 +5,10 @@
             [frontend.modules.outliner.ui :as ui-outliner-tx]
             [frontend.state :as state]
             [logseq.cli.common.mcp.tools :as cli-common-mcp-tools]
+            [logseq.db.sqlite.util :as sqlite-util]
             [promesa.core :as p]
-            [logseq.db.sqlite.util :as sqlite-util]))
+            [clojure.string :as string]
+            [logseq.common.config :as common-config]))
 
 (defn list-tags
   [options]
@@ -59,4 +61,16 @@
                            {:outliner-op :batch-import-edn}
                            (outliner-op/batch-import-edn! edn-data {}))]
     (when error (throw (ex-info error {})))
-    (ui-handler/re-render-root!)))
+    (ui-handler/re-render-root!)))
+
+(defn export-edn
+  "Given sqlite.export options, exports the current graph as a json map with the
+  :export-body key containing a transit string of the export EDN"
+  [options*]
+  (p/let [options (-> (js->clj options* :keywordize-keys true)
+                      (update :export-type (fnil keyword :graph)))
+          result (state/<invoke-db-worker :thread-api/export-edn (state/get-current-repo) options)]
+    (when (= :export-edn-error result)
+      (throw (ex-info "Export EDN error" {})))
+    {:export-body (sqlite-util/transit-write result)
+     :graph (string/replace-first (state/get-current-repo) common-config/db-version-prefix "")}))