datahike-browser-tests 1.0.0

package/src/datahike/experimental/unstructured.cljc

@@ -0,0 +1,126 @@
+(ns datahike.experimental.unstructured
+  "Experimental feature for unstructured data input through schema inference.
+   This namespace provides functions to convert unstructured EDN/JSON-like data 
+   into Datahike's transaction format with automatic schema generation."
+  (:require
+   [datahike.api :as d]
+   [datahike.db.interface :as dbi]))
+
+(defn value->type
+  "Determine the Datahike valueType from a value."
+  [v]
+  (cond
+    (int? v) :db.type/long
+    (float? v) :db.type/float
+    (double? v) :db.type/double
+    (number? v) :db.type/number
+    (string? v) :db.type/string
+    (boolean? v) :db.type/boolean
+    (keyword? v) :db.type/keyword
+    (symbol? v) :db.type/symbol
+    (uuid? v) :db.type/uuid
+    (inst? v) :db.type/instant
+    (map? v) :db.type/ref
+    (bytes? v) :db.type/bytes
+    ;; Handle nil values - default to string for now
+    (nil? v) :db.type/string
+    :else :db.type/string))
+
+(defn infer-value-schema
+  "Create a schema entry for a given attribute and value."
+  [attr v]
+  (cond
+    (vector? v)
+    (when (seq v)
+      {:db/ident attr
+       :db/valueType (value->type (first v))
+       :db/cardinality :db.cardinality/many})
+
+    (map? v)
+    {:db/ident attr
+     :db/valueType :db.type/ref
+     :db/cardinality :db.cardinality/one}
+
+    :else
+    {:db/ident attr
+     :db/valueType (value->type v)
+     :db/cardinality :db.cardinality/one}))
+
+(defn process-unstructured-data
+  "Process unstructured data recursively, converting it to Datahike transactions,
+   while inferring schema. Returns a map with :schema and :tx-data."
+  [data]
+  (let [res (atom [])
+        temp-id (atom 0)
+        schema (atom [])]
+    ((fn eval-data [data]
+       (cond
+         (map? data)
+         (let [new-map (into {} (map (fn [[k v]]
+                                       (when-let [schema-entry (infer-value-schema k v)]
+                                         (swap! schema conj schema-entry))
+                                       [k (eval-data v)])
+                                     data))
+               map-id (swap! temp-id dec)
+               new-map (assoc new-map :db/id map-id)]
+           (swap! res conj new-map)
+           map-id)
+
+         (vector? data)
+         (mapv eval-data data)
+
+         :else
+         data))
+     data)
+    {:schema (vec (distinct (remove nil? @schema)))
+     :tx-data @res}))
+
+(defn check-schema-compatibility
+  "Check if the inferred schema is compatible with the database's existing schema.
+   Returns a map with :compatible? and :conflicts."
+  [db inferred-schema]
+  (let [db-schema (dbi/-schema db)
+        conflicts (atom [])]
+    (doseq [{:keys [db/ident db/valueType db/cardinality] :as attr-schema} inferred-schema]
+      (when-let [existing-schema (get db-schema ident)]
+        (when (not= (:db/valueType existing-schema) valueType)
+          (swap! conflicts conj {:attr ident
+                                 :conflict :value-type
+                                 :existing (:db/valueType existing-schema)
+                                 :inferred valueType}))
+        (when (not= (:db/cardinality existing-schema) cardinality)
+          (swap! conflicts conj {:attr ident
+                                 :conflict :cardinality
+                                 :existing (:db/cardinality existing-schema)
+                                 :inferred cardinality}))))
+    {:compatible? (empty? @conflicts)
+     :conflicts @conflicts}))
+
+(defn prepare-transaction
+  "Prepare a transaction for unstructured data based on the database configuration.
+   For schema-on-read databases, simply returns the transaction data.
+   For schema-on-write databases, adds necessary schema definitions first."
+  [db data]
+  (let [result (process-unstructured-data data)
+        schema-flexibility (get-in (dbi/-config db) [:schema-flexibility])]
+    (if (= schema-flexibility :read)
+      ;; For schema-on-read, just return the transaction data
+      (:tx-data result)
+      ;; For schema-on-write, we need to check compatibility and add schema
+      (let [compatibility (check-schema-compatibility db (:schema result))]
+        (if (:compatible? compatibility)
+          ;; Add schema first, then data
+          (concat (:schema result) (:tx-data result))
+          ;; Not compatible - throw an error with details
+          (throw (ex-info "Schema conflict detected with existing database schema"
+                          {:conflicts (:conflicts compatibility)
+                           :inferred-schema (:schema result)})))))))
+
+(defn transact-unstructured
+  "Public API for transacting unstructured data. Takes a connection and unstructured data.
+   Automatically determines required schema and applies it before inserting the data."
+  [conn data]
+  (let [db (deref conn)
+        tx-data (prepare-transaction db data)]
+    ;; Use the standard transaction API
+    (d/transact conn tx-data)))

package/src/datahike/experimental/versioning.cljc

@@ -0,0 +1,172 @@
+(ns datahike.experimental.versioning
+  "Git-like versioning tools for Datahike."
+  (:require [konserve.core :as k]
+            [datahike.connections :refer [delete-connection!]]
+            [datahike.core :refer [with]]
+            [datahike.store :refer [store-identity]]
+            [datahike.writing :refer [stored->db db->stored stored-db?
+                                      complete-db-update commit! create-commit-id get-and-clear-pending-kvs!
+                                      write-pending-kvs!]]
+            [superv.async :refer [<? S go-loop-try]]
+            [datahike.db.utils :refer [db?]]
+            [datahike.tools :as dt]
+            [konserve.utils :refer [multi-key-capable?]]))
+
+(defn- branch-check [branch]
+  (when-not (keyword? branch)
+    (dt/raise "Branch must be a keyword." {:type :branch-must-be-uuid :branch branch})))
+
+(defn- db-check [db]
+  (when-not (db? db)
+    (dt/raise "You must provide a DB value." {:type :db-value-required :db db})))
+
+(defn- parent-check [parents]
+  (when-not (pos? (count parents))
+    (dt/raise "You must provide at least one parent."
+              {:type :must-provide-at-least-one-parent :parents parents})))
+
+(defn- commit-id-check [commit-id]
+  (when-not (uuid? commit-id)
+    (dt/raise "Commit-id must be a uuid."
+              {:type :commit-id-must-be-uuid :commit-id commit-id})))
+
+;; ========================= public API =========================
+
+(defn branch-history
+  "Returns a go-channel with the commit history of the branch of the connection in
+  form of all stored db values. Performs backtracking and returns dbs in order."
+  [conn]
+  (let [{:keys [store] {:keys [branch]} :config} @conn]
+    (go-loop-try S [[to-check & r] [branch]
+                    visited #{}
+                    reachable []]
+                 (if to-check
+                   (if (visited to-check) ;; skip
+                     (recur r visited reachable)
+                     (if-let [raw-db (<? S (k/get store to-check))]
+                       (let [{{:keys [datahike/parents]} :meta
+                              :as db} (stored->db raw-db store)]
+                         (recur (concat r parents)
+                                (conj visited to-check)
+                                (conj reachable db)))
+                       reachable))
+                   reachable))))
+
+(defn branch!
+  "Create a new branch from commit-id or existing branch as new-branch."
+  [conn from new-branch]
+  (let [store (:store @conn)
+        branches (k/get store :branches nil {:sync? true})
+        _ (when (branches new-branch)
+            (dt/raise "Branch already exists." {:type :branch-already-exists
+                                                :new-branch new-branch}))
+        db (k/get store from nil {:sync? true})]
+    (when-not (stored-db? db)
+      (throw (ex-info "From does not point to an existing branch or commit."
+                      {:type :from-branch-does-not-point-to-existing-branch-or-commit
+                       :from from})))
+    (k/assoc store new-branch (assoc-in db [:config :branch] new-branch) {:sync? true})
+    (k/update store :branches #(conj (set %) new-branch) {:sync? true})))
+
+(defn delete-branch!
+  "Removes this branch from set of known branches. The branch will still be
+  accessible until the next gc. Remote readers need to release their connections."
+  [conn branch]
+  (when (= branch :db)
+    (dt/raise "Cannot delete main :db branch. Delete database instead."
+              {:type :cannot-delete-main-db-branch}))
+  (let [store (:store @conn)
+        branches (k/get store :branches nil {:sync? true})]
+    (when-not (branches branch)
+      (dt/raise "Branch does not exist." {:type :branch-does-not-exist
+                                          :branch branch}))
+    (delete-connection! [(store-identity (get-in @conn [:config :store])) branch])
+    (k/update store :branches #(disj (set %) branch) {:sync? true})))
+
+(defn force-branch!
+  "Force the branch to point to the provided db value. Branch will be created if
+  it does not exist. Parents need to point to a set of branches or commits.
+
+  Be careful with this command as you can render a db inaccessible by corrupting
+  a branch. You will also conflict with existing connections to the branch so
+  make sure to close them before forcing the branch."
+  [db branch parents]
+  (db-check db)
+  (branch-check branch)
+  (parent-check parents)
+  (let [store (:store db)
+        cid (create-commit-id db)
+        db-with-meta (-> db
+                         (assoc-in [:config :branch] branch)
+                         (assoc-in [:meta :datahike/parents] parents)
+                         (assoc-in [:meta :datahike/commit-id] cid))
+        ;; db->stored now returns [schema-meta-kv-to-write db-to-store]
+        ;; and index flushes will have populated pending-writes
+        [schema-meta-kv-to-write db-to-store] (db->stored db-with-meta true)
+        ;; Get all pending [k v] pairs (e.g., from index flushes)
+        pending-kvs (get-and-clear-pending-kvs! store)]
+
+    ;; Update the set of known branches
+    (k/update store :branches #(conj (set %) branch) {:sync? true})
+
+    ;; Write all data synchronously
+    (if (multi-key-capable? store)
+      (let [writes-map (cond-> (into {} pending-kvs) ; Initialize with pending KVs
+                         schema-meta-kv-to-write (assoc (first schema-meta-kv-to-write) (second schema-meta-kv-to-write))
+                         true                    (assoc cid db-to-store)
+                         true                    (assoc branch db-to-store))]
+        (k/multi-assoc store writes-map {:sync? true}))
+      (do
+        ;; Use the helper function to write pending KVs (synchronously)
+        (write-pending-kvs! store pending-kvs true)
+        ;; Then write schema-meta
+        (when schema-meta-kv-to-write
+          (k/assoc store (first schema-meta-kv-to-write) (second schema-meta-kv-to-write) {:sync? true}))
+        ;; Then write commit-log and branch head
+        (k/assoc store cid db-to-store {:sync? true})
+        (k/assoc store branch db-to-store {:sync? true})))
+    nil))
+
+(defn commit-id
+  "Retrieve the commit-id for this db."
+  [db]
+  (db-check db)
+  (get-in db [:meta :datahike/commit-id]))
+
+(defn parent-commit-ids
+  "Retrieve parent commit ids from db."
+  [db]
+  (db-check db)
+  (get-in db [:meta :datahike/parents]))
+
+(defn commit-as-db
+  "Loads the database stored at this commit id."
+  [store commit-id]
+  (commit-id-check commit-id)
+  (when-let [raw-db (k/get store commit-id nil {:sync? true})]
+    (stored->db raw-db store)))
+
+(defn branch-as-db
+  "Loads the database stored at this branch."
+  [store branch]
+  (branch-check branch)
+  (when-let [raw-db (k/get store branch nil {:sync? true})]
+    (stored->db raw-db store)))
+
+(defn merge!
+  "Create a merge commit to the current branch of this connection for parent
+  commit uuids. It is the responsibility of the caller to make sure that tx-data
+  contains the data to be merged into the branch from the parents. This function
+  ensures that the parent commits are properly tracked.
+   
+   NOTE: Currently merge! requires that you release all connections to conn and reconnect afterwards to reset the writer state. This will be fixed in the future by handling merge! through the writer."
+  ([conn parents tx-data]
+   (merge! conn parents tx-data nil))
+  ([conn parents tx-data tx-meta]
+   (parent-check parents)
+   (let [old @conn
+         db (:db-after (complete-db-update old (with old tx-data tx-meta)))
+         parents (conj parents (get-in old [:config :branch]))
+         commit-db (commit! db parents)]
+     (reset! conn commit-db)
+     true)))

package/src/datahike/externs.js

@@ -0,0 +1,31 @@
+var datahike = {};
+datahike.db = {};
+
+/**
+ * @constructor
+ */
+datahike.db.Datom = function() {};
+datahike.db.Datom.prototype.e;
+datahike.db.Datom.prototype.a;
+datahike.db.Datom.prototype.v;
+datahike.db.Datom.prototype.tx;
+
+
+datahike.impl = {};
+datahike.impl.entity = {};
+
+/**
+ * @constructor
+ */
+datahike.impl.entity.Entity = function() {};
+datahike.impl.entity.Entity.prototype.db;
+datahike.impl.entity.Entity.prototype.eid;
+datahike.impl.entity.Entity.prototype.keys      = function() {};
+datahike.impl.entity.Entity.prototype.entries   = function() {};
+datahike.impl.entity.Entity.prototype.values    = function() {};
+datahike.impl.entity.Entity.prototype.has       = function() {};
+datahike.impl.entity.Entity.prototype.get       = function() {};
+datahike.impl.entity.Entity.prototype.forEach   = function() {};
+datahike.impl.entity.Entity.prototype.key_set   = function() {};
+datahike.impl.entity.Entity.prototype.entry_set = function() {};
+datahike.impl.entity.Entity.prototype.value_set = function() {};

package/src/datahike/gc.cljc

@@ -0,0 +1,69 @@
+(ns datahike.gc
+  (:require [clojure.set :as set]
+            [datahike.index.interface :refer [-mark]]
+            [konserve.core :as k]
+            [konserve.gc :refer [sweep!]]
+            [taoensso.timbre :refer [debug trace]]
+            [superv.async :refer [<? S go-try <<?]]
+            [clojure.core.async  :as async]
+            [datahike.schema-cache :as sc])
+  #?(:clj (:import [java.util Date])))
+
+;; meta-data does not get passed in macros
+(defn get-time [d]
+  (.getTime ^Date d))
+
+(defn- reachable-in-branch [store branch after-date config]
+  (go-try S
+          (let [head-cid (<? S (k/get-in store [branch :meta :datahike/commit-id]))]
+            (loop [[to-check & r] [branch]
+                   visited        #{}
+                   reachable      #{branch head-cid}]
+              (if to-check
+                (if (visited to-check) ;; skip
+                  (recur r visited reachable)
+                  (let [{:keys                         [eavt-key avet-key aevt-key
+                                                        temporal-eavt-key temporal-avet-key temporal-aevt-key
+                                                        schema-meta-key]
+                         {:keys [datahike/parents
+                                 datahike/created-at
+                                 datahike/updated-at]} :meta}
+                        (<? S (k/get store to-check))
+                        in-range? (> (get-time (or updated-at created-at))
+                                     (get-time after-date))]
+                    (recur (concat r (when in-range? parents))
+                           (conj visited to-check)
+                           (set/union reachable #{to-check}
+                                      (when schema-meta-key #{schema-meta-key})
+                                      (-mark eavt-key)
+                                      (-mark aevt-key)
+                                      (-mark avet-key)
+                                      (when (:keep-history? config)
+                                        (set/union
+                                         (-mark temporal-eavt-key)
+                                         (-mark temporal-aevt-key)
+                                         (-mark temporal-avet-key)))))))
+                reachable)))))
+
+(defn gc-storage!
+  "Invokes garbage collection on the database by whitelisting currently known branches.
+  All db snapshots on these branches before remove-before date will also be
+  erased (defaults to beginning of time [no erasure]). The branch heads will
+  always be retained."
+  ([db] (gc-storage! db (#?(:clj Date. :cljs js/Date.) 0)))
+  ([db remove-before]
+   (go-try S
+           (let [now #?(:clj (Date.) :cljs (js/Date.))
+                 _ (debug "starting gc" now)
+                 {:keys [config store]} db
+                 _ (sc/clear-write-cache (:store config)) ; Clear the schema write cache for this store
+                 branches (<? S (k/get store :branches))
+                 _ (trace  "retaining branches" branches)
+                 reachable (->> branches
+                                (map #(reachable-in-branch store % remove-before config))
+                                async/merge
+                                (<<? S)
+                                (apply set/union))
+                 reachable (conj reachable :branches)]
+             (trace  "gc reached: " reachable)
+             (<? S (sweep! store reachable now))))))

package/src/datahike/http/client.clj

@@ -0,0 +1,188 @@
+(ns datahike.http.client
+  (:refer-clojure :exclude [filter])
+  (:require [babashka.http-client :as http]
+            [cognitect.transit :as transit]
+            [jsonista.core :as j]
+            [hasch.core :refer [uuid]]
+            [datahike.api.specification :as api]
+            [clojure.edn :as edn]
+            [datahike.datom :as dd]
+            [datahike.remote :as remote]
+            [datahike.impl.entity :as de]
+            [taoensso.timbre :as log])
+  (:import [java.io ByteArrayOutputStream]))
+
+(def MEGABYTE (* 1024 1024))
+
+(def MAX_OUTPUT_BUFFER_SIZE (* 4 MEGABYTE))
+
+(defn request-edn [method end-point remote-peer data]
+  (let [{:keys [url token]} remote-peer
+        fmt                 "application/edn"
+        url                 (str url "/" end-point)
+        body                (remote/edn-replace-remote-literals (pr-str data))
+        _                   (log/trace "request" url end-point token data body)
+        response
+        (try
+          (http/request (merge
+                         {:uri     url
+                          :method  method
+                          :headers (merge {:content-type fmt
+                                           :accept       fmt}
+                                          (when token
+                                            {:authorization (str "token " token)}))
+                          :body    body}
+                         (when (= method :get)
+                           {:query-params {"args-id" (uuid data)}})))
+          (catch Exception e
+            (let [msg  (ex-message e)
+                  data (ex-data e)
+                  new-data
+                  (update data :body #(edn/read-string {:readers remote/edn-readers} %))]
+              (throw (ex-info msg new-data)))))
+        response            (:body response)]
+    (log/trace "response" response)
+    (edn/read-string {:readers remote/edn-readers} response)))
+
+(defn request-transit
+  ([method end-point remote-peer data]
+   (request-transit method end-point remote-peer data
+                    remote/transit-read-handlers
+                    remote/transit-write-handlers))
+  ([method end-point remote-peer data read-handlers write-handlers]
+   (let [{:keys [url token max-output-buffer-size]}
+         remote-peer
+         fmt      "application/transit+json"
+         url      (str url "/" end-point)
+         out      (ByteArrayOutputStream. (or max-output-buffer-size MAX_OUTPUT_BUFFER_SIZE))
+         writer   (transit/writer out :json {:handlers write-handlers})
+         _        (transit/write writer data)
+         _        (log/trace "request" url end-point token data out)
+         response
+         (try
+           (http/request (merge
+                          {:method method
+                           :uri    url
+                           :headers
+                           (merge {:content-type fmt
+                                   :accept       fmt}
+                                  (when token
+                                    {:authorization (str "token " token)}))
+                           :as     :stream
+                           :body   (.toByteArray out)}
+                          (when (= method :get)
+                            {:query-params {"args-id" (uuid data)}})))
+           (catch Exception e
+             ;; read exception
+             (let [msg  (ex-message e)
+                   data (ex-data e)
+                   new-data
+                   (update data :body
+                           #(when %
+                              (transit/read (transit/reader % :json {:handlers read-handlers}))))]
+               (throw (ex-info msg new-data)))))
+         response (:body response)
+         response (transit/read (transit/reader response :json {:handlers read-handlers}))]
+     (log/trace  "response" response)
+     response)))
+
+(defn request-json
+  ([method end-point remote-peer data]
+   (request-json method end-point remote-peer data remote/json-mapper))
+  ([method end-point remote-peer data mapper]
+   (let [{:keys [url token]}
+         remote-peer
+         fmt      "application/json"
+         url      (str url "/" end-point)
+         out      (j/write-value-as-bytes data mapper)
+         _        (log/trace "request" url end-point token data out)
+         response
+         (try
+           (http/request (merge
+                          {:method method
+                           :uri    url
+                           :headers
+                           (merge {:content-type fmt
+                                   :accept       fmt}
+                                  (when token
+                                    {:authorization (str "token " token)}))
+                           :as     :stream
+                           :body   out}
+                          (when (= method :get)
+                            {:query-params {"args-id" (uuid data)}})))
+           (catch Exception e
+             ;; read exception
+             (let [msg  (if-let [m (ex-message e)] m "Nothing returned. Is the server reachable?")
+                   data (ex-data e)
+                   new-data
+                   (update data :body
+                           #(when %
+                              (j/read-value % mapper)))]
+               (throw (ex-info (or (:msg (:body new-data)) msg)
+                               (or (:ex-data (:body new-data)) new-data))))))
+         response (:body response)
+         response (j/read-value response mapper)]
+     (log/trace  "response" response)
+     response)))
+
+(defn request-json-raw [method end-point remote-peer data]
+  (let [{:keys [url token]}
+        remote-peer
+        fmt      "application/json"
+        url      (str url "/" end-point)
+        out      data
+        _        (log/trace "request" url end-point token data out)
+        response
+        (http/request (merge
+                       {:method method
+                        :uri    url
+                        :headers
+                        (merge {:content-type fmt
+                                :accept       fmt}
+                               (when token
+                                 {:authorization (str "token " token)}))
+                        :as     :stream
+                        :body   out}
+                       (when (= method :get)
+                         {:query-params {"args-id" (uuid data)}})))
+        response (slurp (:body response))]
+    (log/trace  "response" response)
+    response))
+
+(defn get-remote [args]
+  (let [remotes (disj
+                 (into
+                  ;; first arguments can be config maps, e.g. for
+                  ;; create-database; this code could be made explicit by
+                  ;; explicitly dispatching on when the first argument is a
+                  ;; config map
+                  #{(:remote-peer (first args))}
+                  ;; other arguments to API follow hygiene
+                  (map remote/remote-peer (rest args)))
+                 nil)]
+    (if (> (count remotes) 1)
+      (throw (ex-info "Arguments refer to more than one remote-peer." {:remotes remotes
+                                                                       :args args}))
+      (first remotes))))
+
+(doseq [[n {:keys [args doc supports-remote? referentially-transparent?]}] api/api-specification]
+  (eval
+   `(def
+      ~(with-meta n
+         {:arglists `(api/malli-schema->argslist (quote ~args))
+          :doc      doc})
+      (fn [& ~'args]
+        ~(if-not supports-remote?
+           `(throw (ex-info (str ~(str n) " is not supported for remote connections.")
+                            {:type     :remote-not-supported
+                             :function ~(str n)}))
+           `(binding [remote/*remote-peer* (get-remote ~'args)]
+              (let [format# (:format remote/*remote-peer*)]
+                (({:transit request-transit
+                   :edn     request-edn
+                   :json    request-json} (or format# :transit))
+                 ~(if referentially-transparent? :get :post)
+                 ~(api/->url n)
+                 remote/*remote-peer* (vec ~'args)))))))))
+
+(defmethod remote/remote-deref :datahike-server [conn] (db conn))

package/src/datahike/http/writer.clj

@@ -0,0 +1,79 @@
+(ns datahike.http.writer
+  "Remote writer implementation for datahike.http.server through datahike.http.client."
+  (:require [datahike.writer :refer [PWriter create-writer create-database delete-database]]
+            [datahike.http.client :refer [request-json] :as client]
+            [datahike.json :as json]
+            [datahike.connector :as connector]
+            [datahike.tools :as dt :refer [throwable-promise]]
+            [taoensso.timbre :as log]
+            [clojure.core.async :refer [promise-chan put!]]))
+
+(defrecord DatahikeServerWriter [remote-peer conn]
+  PWriter
+  (-dispatch! [_ arg-map]
+    (let [{:keys [op args]} arg-map
+          p (promise-chan)
+          config (:config @(:wrapped-atom conn))]
+      (log/debug "Sending operation to datahike-server:" op)
+      (log/trace "Arguments:" arg-map)
+      (put! p
+            (try
+              (request-json :post
+                            (str op "-writer")
+                            remote-peer
+                            (vec (concat [config] args))
+                            json/mapper)
+              (catch Exception e
+                e)))
+      p))
+  (-shutdown [_])
+  (-streaming? [_] false))
+
+(defmethod create-writer :datahike-server
+  [config connection]
+  (log/debug "Creating datahike-server writer for " connection config)
+  (->DatahikeServerWriter config connection))
+
+(defmethod create-database :datahike-server
+  [& args]
+  (let [p (throwable-promise)
+        {:keys [writer] :as config} (first args)]
+    ;; redirect call to remote-peer as writer config
+    (deliver p (try (->
+                     (request-json :post
+                                   "create-database-writer"
+                                   writer
+                                   (vec (concat [(-> config
+                                                     (assoc :remote-peer writer)
+                                                     (dissoc :writer))]
+                                                (rest args))))
+                     (dissoc :remote-peer))
+                    (catch Exception e
+                      e)))
+    p))
+
+(defmethod delete-database :datahike-server
+  [& args]
+  (let [p (throwable-promise)
+        {:keys [writer] :as config} (first args)]
+    ;; redirect call to remote-peer as writer config
+    (deliver p (try
+                 (-> (request-json :post
+                                   "delete-database-writer"
+                                   writer
+                                   (vec (concat [(-> config
+                                                     (assoc  :remote-peer writer)
+                                                     (dissoc :writer))]
+                                                (rest args))))
+                     (dissoc :remote-peer))
+                 (catch Exception e
+                   e)))
+    p))
+
+;; =============================================================================
+;; Connection Integration
+;; =============================================================================
+
+(defmethod connector/-connect* :datahike-server [config opts]
+  ;; HTTP uses standard connection logic with async+sync behavior
+  (connector/-connect-impl* config opts))