datahike-browser-tests 1.0.0

package/examples/java/src/main/java/examples/TimeTravelExample.java

@@ -0,0 +1,121 @@
+package examples;
+
+import datahike.java.Datahike;
+import datahike.java.Database;
+import datahike.java.SchemaFlexibility;
+
+import java.time.Instant;
+import java.util.*;
+
+/**
+ * Example demonstrating time-travel queries.
+ *
+ * Shows:
+ * - Querying historical database states
+ * - Using asOf for point-in-time queries
+ * - Using since for change tracking
+ * - Querying full history with all versions
+ */
+public class TimeTravelExample {
+    public static void main(String[] args) throws InterruptedException {
+        System.out.println("=== Time Travel Example ===\n");
+
+        // Configure database with history enabled
+        Map<String, Object> config = Database.memory(UUID.randomUUID())
+            .keepHistory(true)
+            .schemaFlexibility(SchemaFlexibility.READ)
+            .build();
+
+        Datahike.createDatabase(config);
+        Object conn = Datahike.connect(config);
+
+        // 1. Initial state - add Alice
+        System.out.println("1. Initial state - adding Alice...");
+        Datahike.transact(conn, List.of(
+            Map.of("name", "Alice", "status", "active")
+        ));
+
+        Date t1 = new Date();
+        System.out.println("Timestamp T1: " + t1);
+
+        Thread.sleep(100);  // Small delay for distinct timestamps
+
+        // 2. Add Bob
+        System.out.println("\n2. Adding Bob...");
+        Datahike.transact(conn, List.of(
+            Map.of("name", "Bob", "status", "active")
+        ));
+
+        Date t2 = new Date();
+        System.out.println("Timestamp T2: " + t2);
+
+        Thread.sleep(100);
+
+        // 3. Update Alice's status
+        System.out.println("\n3. Updating Alice's status...");
+        Set<?> aliceResult = (Set<?>) Datahike.q(
+            "[:find ?e :where [?e :name \"Alice\"]]",
+            Datahike.deref(conn)
+        );
+
+        Object aliceId = ((List<?>) aliceResult.iterator().next()).get(0);
+        Datahike.transact(conn, List.of(
+            Map.of(":db/id", aliceId, "status", "inactive")
+        ));
+
+        Date t3 = new Date();
+        System.out.println("Timestamp T3: " + t3);
+
+        // 4. Query current state
+        System.out.println("\n4. Current state:");
+        Set<?> currentState = (Set<?>) Datahike.q(
+            "[:find ?name ?status :where [?e :name ?name] [?e :status ?status]]",
+            Datahike.deref(conn)
+        );
+        currentState.forEach(System.out::println);
+
+        // 5. Query as of T1 (only Alice existed)
+        System.out.println("\n5. State as of T1 (only Alice):");
+        Object dbAtT1 = Datahike.asOf(Datahike.deref(conn), t1);
+        Set<?> stateAtT1 = (Set<?>) Datahike.q(
+            "[:find ?name ?status :where [?e :name ?name] [?e :status ?status]]",
+            dbAtT1
+        );
+        stateAtT1.forEach(System.out::println);
+
+        // 6. Query as of T2 (both existed, Alice was active)
+        System.out.println("\n6. State as of T2 (both, Alice active):");
+        Object dbAtT2 = Datahike.asOf(Datahike.deref(conn), t2);
+        Set<?> stateAtT2 = (Set<?>) Datahike.q(
+            "[:find ?name ?status :where [?e :name ?name] [?e :status ?status]]",
+            dbAtT2
+        );
+        stateAtT2.forEach(System.out::println);
+
+        // 7. Query changes since T2
+        System.out.println("\n7. Changes since T2:");
+        Object dbSinceT2 = Datahike.since(Datahike.deref(conn), t2);
+        Set<?> changesSinceT2 = (Set<?>) Datahike.q(
+            "[:find ?name ?status :where [?e :name ?name] [?e :status ?status]]",
+            dbSinceT2
+        );
+        System.out.println("Changed entities:");
+        changesSinceT2.forEach(System.out::println);
+
+        // 8. Query full history (includes all versions)
+        System.out.println("\n8. Full history of Alice's status:");
+        Object historyDb = Datahike.history(Datahike.deref(conn));
+        Set<?> aliceHistory = (Set<?>) Datahike.q(
+            "[:find ?status :where [?e :name \"Alice\"] [?e :status ?status]]",
+            historyDb
+        );
+        System.out.println("All status values for Alice:");
+        aliceHistory.forEach(System.out::println);
+
+        // Cleanup
+        Datahike.deleteDatabase(config);
+
+        System.out.println("\n=== Example completed successfully! ===");
+        System.exit(0);
+    }
+}

package/flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1752950548,
+        "narHash": "sha256-NS6BLD0lxOrnCiEOcvQCDVPXafX1/ek1dfJHX1nUIzc=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "c87b95e25065c028d31a94f06a62927d18763fdf",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

package/flake.nix

@@ -0,0 +1,27 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
+  };
+
+  outputs = { self, nixpkgs }:
+    let
+      lib = nixpkgs.lib;
+      allSystems = [
+        "aarch64-darwin"
+        "aarch64-linux"
+        "x86_64-linux"
+      ];
+      pkgsFor = lib.genAttrs allSystems (system: import nixpkgs { inherit system; config.allowUnfree = true; });
+      overEachSystem = f: lib.genAttrs allSystems (system: f { inherit system; pkgs = pkgsFor.${system}; });
+    in {
+      formatter = overEachSystem ({ system, pkgs }: pkgs.nixfmt-rcf-style);
+      devShells = overEachSystem ({ system, pkgs }: {
+        default = pkgs.mkShellNoCC {
+          packages = [
+            pkgs.clojure
+            pkgs.babashka
+          ];
+        };
+      });
+    };
+}

package/http-server/datahike/http/middleware.clj

@@ -0,0 +1,75 @@
+(ns datahike.http.middleware
+  (:require
+   [buddy.auth :refer [authenticated?]]
+   [buddy.auth.backends :as buddy-auth-backends]
+   [buddy.auth.middleware :as buddy-auth-middleware]
+   [clojure.edn :as edn]
+   [clojure.walk :as cw]
+   [datahike.json :as json]
+   [datahike.readers :refer [edn-readers]]
+   [muuntaja.core :as m]
+   [taoensso.timbre :refer [info trace]])
+  (:import
+   [clojure.lang ExceptionInfo]))
+
+(defn auth
+  "Middleware used in routes that require authentication. If request is not
+   authenticated a 401 not authorized response will be returned.
+   Dev mode always authenticates."
+  [config handler]
+  (fn [request]
+    (if (or (:dev-mode config) (authenticated? request))
+      (handler request)
+      {:status 401 :error "Not authorized"})))
+
+(defn token-auth
+  "Middleware used on routes requiring token authentication"
+  [config handler]
+  (buddy-auth-middleware/wrap-authentication
+   handler
+   (buddy-auth-backends/token {:token-name "token"
+                               :authfn     (fn [_ token]
+                                             (let [valid-token?  (not (nil? token))
+                                                   correct-auth? (= (:token config) token)]
+                                               (when (and correct-auth? valid-token?)
+                                                 "authenticated-user")))})))
+
+;; TOOD map more errors
+(defn cause->status-code [cause]
+  400)
+
+(defn encode-plain-value [muuntaja-with-opts]
+  (fn [handler]
+    (fn [request]
+      (let [format   (:content-type request)
+            encoder  (m/encoder muuntaja-with-opts format)
+            response (handler request)
+            ret      (if (not (instance? java.io.ByteArrayInputStream (:body response)))
+                       (update response :body #(encoder %))
+                       response)]
+        ret))))
+
+(defn patch-swagger-json [handler]
+  (fn [request]
+    (let [response (handler request)]
+      (if (get-in response [:body :swagger])
+        (cw/postwalk (fn [n]
+                       (if (set? n) (vec n) n))
+                     response)
+        response))))
+
+(defn support-embedded-edn-in-json [handler]
+  (fn [request]
+    (let [{:keys [content-type body-params uri]} request]
+      (if (= content-type "application/json")
+        (if (.endsWith ^String uri "transact")
+          (let [[conn tx-data] body-params
+                new-body-params [conn (json/xf-data-for-tx tx-data @conn)]]
+            (trace "transact transformation" new-body-params)
+            (handler (assoc request :body-params new-body-params)))
+          (let [[f & r]         body-params
+                new-body-params (vec (concat [(if (string? f) (edn/read-string {:readers edn-readers} f) f)] r))]
+            (trace "old-body-params" body-params)
+            (trace "new-body-params" new-body-params)
+            (handler (assoc request :body-params new-body-params))))
+        (handler request)))))

package/http-server/datahike/http/server.clj

@@ -0,0 +1,269 @@
+(ns datahike.http.server
+  "HTTP server implementation for Datahike."
+  (:gen-class)
+  (:refer-clojure :exclude [read-string filter])
+  (:require
+   [clojure.string :as str]
+   [clojure.edn :as edn]
+   [clojure.core.async :as async]
+   [datahike.connections :refer [*connections*]]
+   [datahike.api.specification :refer [api-specification ->url]]
+   [datahike.api.types :as types]
+   [datahike.http.middleware :as middleware]
+   [datahike.readers :refer [edn-readers]]
+   [datahike.transit :as transit]
+   [datahike.json :as json]
+   [datahike.api :refer :all :as api]
+   [datahike.writing]
+   [datahike.writer]
+   [reitit.ring :as ring]
+   [reitit.coercion.malli]
+   [malli.util :as mu]
+   [reitit.swagger :as swagger]
+   [reitit.swagger-ui :as swagger-ui]
+   [reitit.ring.coercion :as coercion]
+   [reitit.ring.middleware.muuntaja :as muuntaja]
+   [reitit.ring.middleware.exception :as exception]
+   [reitit.ring.middleware.multipart :as multipart]
+   [reitit.ring.middleware.parameters :as parameters]
+   [ring.middleware.cors :refer [wrap-cors]]
+   [muuntaja.core :as m]
+   [datahike.tools :refer [datahike-version]]
+   [datahike.impl.entity :as de]
+   [taoensso.timbre :as log]
+   [ring.adapter.jetty :refer [run-jetty]])
+  (:import [datahike.datom Datom]))
+
+(defn generic-handler [config f]
+  (fn [request]
+    (try
+      (let [{{body :body} :parameters
+             :keys [headers params method]} request
+            _ (log/trace "request body" f body)
+          ;; TODO move this to client
+            ret-body
+            (cond (= f #'api/create-database)
+                ;; remove remote-peer and re-add
+                  (assoc
+                   (apply f (dissoc (first body) :remote-peer) (rest body))
+                   :remote-peer (:remote-peer (first body)))
+
+                  (= f #'api/delete-database)
+                  (apply f (dissoc (first body) :remote-peer) (rest body))
+
+                  :else
+                  (apply f body))]
+        (log/trace "return body" ret-body)
+        (merge
+         {:status 200
+          :body
+          (when-not (headers "no-return-value")
+            ret-body)}
+         (when (and (= method :get)
+                    (get params "args-id")
+                    (get-in config [:cache :get :max-age]))
+           {:headers {"Cache-Control" (str (when-not (:token config) "public, ")
+                                           "max-age=" (get-in config [:cache :get :max-age]))}})))
+      (catch Exception e
+        {:status 500
+         :body   {:msg (ex-message e)
+                  :ex-data (ex-data e)}}))))
+
+(declare create-routes)
+
+(defn extract-first-sentence [doc]
+  (str (first (str/split doc #"\.\s")) "."))
+
+(defn has-cat-operators?
+  "Check if args list contains :cat-specific operators like [:* ...], [:+ ...], [:alt ...], etc.
+   These operators are only valid in :cat schemas, not in :tuple schemas."
+  [args]
+  (some #(and (vector? %) (#{:* :+ :? :alt :altn} (first %))) args))
+
+(defn extract-input-schema
+  "Extract input schema from malli function schema for HTTP body validation.
+   Converts [:=> [:cat Type1 Type2] ret] to [:tuple Type1 Type2]
+   or [:function [:=> [:cat T1] ret] [:=> [:cat T1 T2] ret]] to [:or [:tuple T1] [:tuple T1 T2]]
+
+   The HTTP body is a tuple/vector of arguments that matches the function signature.
+   For zero-arity functions, we use [:= []] to match an empty vector.
+   For functions with :cat operators ([:* ...], [:alt ...], etc), we use [:sequential :any]
+   since tuples can't express these dynamic patterns."
+  [schema]
+  (cond
+    ;; Multi-arity: [:function [:=> [:cat ...] ret] ...]
+    (and (vector? schema) (= :function (first schema)))
+    (let [input-schemas (for [arity-schema (rest schema)
+                              :when (and (vector? arity-schema)
+                                         (= :=> (first arity-schema)))
+                              :let [[_ input-schema _] arity-schema
+                                    args (when (and (vector? input-schema)
+                                                    (= :cat (first input-schema)))
+                                           (rest input-schema))]]
+                          (cond
+                            (not (seq args)) [:= []]  ;; Zero-arity
+                            (has-cat-operators? args) [:sequential :any]  ;; Has :cat operators - can't use tuple
+                            :else (vec (cons :tuple args))))]  ;; Fixed arity
+      (if (> (count input-schemas) 1)
+        (vec (cons :or input-schemas))
+        (first input-schemas)))
+
+    ;; Single arity: [:=> [:cat Type1 Type2] ret]
+    (and (vector? schema) (= :=> (first schema)))
+    (let [[_ input-schema _] schema]
+      (if (and (vector? input-schema) (= :cat (first input-schema)))
+        (let [args (rest input-schema)]
+          (cond
+            (not (seq args)) [:= []]  ;; Zero-arity
+            (has-cat-operators? args) [:sequential :any]  ;; Has :cat operators
+            :else (vec (cons :tuple args))))  ;; Fixed arity
+        [:sequential :any]))
+
+    ;; Fallback
+    :else [:sequential :any]))
+
+;; This code expands and evals the server route construction given the
+;; API specification.
+(eval
+ `(defn ~'create-routes [~'config]
+    ~(vec
+      (for [[n {:keys [args doc supports-remote? referentially-transparent?]}] api-specification
+            :when supports-remote?]
+        `[~(str "/" (->url n))
+          {:swagger {:tags ["API"]}
+           ~(if referentially-transparent? :get :post)
+           {:operationId ~(str n)
+            :summary     ~(extract-first-sentence doc)
+            :description ~doc
+            :parameters  {:body ~(extract-input-schema args)}
+            :handler     (generic-handler ~'config ~(resolve n))}}]))))
+
+(def muuntaja-with-opts
+  (m/create
+   (-> m/default-options
+       (assoc-in [:formats "application/edn" :decoder-opts]
+                 {:readers edn-readers})
+       (assoc-in [:formats "application/json" :decoder-opts]
+                 json/mapper-opts)
+       (assoc-in [:formats "application/json" :encoder-opts]
+                 json/mapper-opts)
+       (assoc-in [:formats "application/transit+json" :decoder-opts]
+                 {:handlers transit/read-handlers})
+       (assoc-in [:formats "application/transit+json" :encoder-opts]
+                 {:handlers transit/write-handlers}))))
+
+(defn default-route-opts [muuntaja-with-opts]
+  {:data      {:coercion   (reitit.coercion.malli/create
+                            {:compile mu/closed-schema
+                             :strip-extra-keys true
+                             :default-values true
+                             :options {:registry types/registry}})
+               :muuntaja   muuntaja-with-opts
+               :middleware [swagger/swagger-feature
+                            parameters/parameters-middleware
+                            muuntaja/format-negotiate-middleware
+                            muuntaja/format-response-middleware
+                            exception/exception-middleware
+                            muuntaja/format-request-middleware
+                            (middleware/encode-plain-value muuntaja-with-opts)
+                            middleware/support-embedded-edn-in-json
+                            coercion/coerce-response-middleware
+                            coercion/coerce-request-middleware
+                            multipart/multipart-middleware
+                            middleware/patch-swagger-json]}})
+
+(defn internal-writer-routes [server-connections]
+  [["/delete-database-writer"
+    {:post {:parameters  {:body [:sequential :any]},
+            :summary     "Internal endpoint. DO NOT USE!"
+            :no-doc      true
+            :handler     (fn [{{:keys [body]} :parameters}]
+                           (binding [*connections* server-connections]
+                             (let [cfg (dissoc (first body) :remote-peer :writer)]
+                               (try
+                                 (try
+                                   (api/release (api/connect cfg) true)
+                                   (catch Exception _))
+                                 {:status 200
+                                  :body   (async/<!! (apply datahike.writing/delete-database cfg (rest body)))}
+                                 (catch Exception e
+                                   {:status 500
+                                    :body   {:msg (ex-message e)
+                                             :ex-data (ex-data e)}})))))
+            :operationId "delete-database"},
+     :swagger {:tags ["Internal"]}}]
+   ["/create-database-writer"
+    {:post {:parameters  {:body [:sequential :any]},
+            :summary     "Internal endpoint. DO NOT USE!"
+            :no-doc      true
+            :handler     (fn [{{:keys [body]} :parameters}]
+                           (let [cfg (dissoc (first body) :remote-peer :writer)]
+                             (try
+                               {:status 200
+                                :body   (async/<!! (apply datahike.writing/create-database
+                                                          cfg
+                                                          (rest body)))}
+                               (catch Exception e
+                                 {:status 500
+                                  :body   {:msg (ex-message e)
+                                           :ex-data (ex-data e)}}))))
+            :operationId "create-database"},
+     :swagger {:tags ["Internal"]}}]
+   ["/transact!-writer"
+    {:post {:parameters  {:body [:sequential :any]},
+            :summary     "Internal endpoint. DO NOT USE!"
+            :no-doc      true
+            :handler     (fn [{{:keys [body]} :parameters}]
+                           (binding [*connections* server-connections]
+                             (try
+                               (let [conn (api/connect (dissoc (first body) :remote-peer :writer)) ;; TODO maybe release?
+                                     res @(apply datahike.writer/transact! conn (rest body))]
+                                 {:status 200
+                                  :body   res})
+                               (catch Exception e
+                                 {:status 500
+                                  :body   {:msg (ex-message e)
+                                           :ex-data (ex-data e)}}))))
+            :operationId "transact"},
+     :swagger {:tags ["Internal"]}}]])
+
+(defn app [config route-opts server-connections]
+  (-> (ring/ring-handler
+       (ring/router
+        (concat
+         [["/swagger.json"
+           {:get {:no-doc  true
+                  :swagger {:info {:title       "Datahike API"
+                                   :description "Transaction and query functions for Datahike.\n\nThe signatures match those of the Clojure API. All functions take their arguments passed as a vector/list in the POST request body."}}
+                  :handler (swagger/create-swagger-handler)}}]]
+         (map (fn [route]
+                (let [method (if (:get (second route)) :get :post)]
+                  (assoc-in route [1 method :middleware]
+                            [(partial middleware/token-auth config)
+                             (partial middleware/auth config)])))
+              (concat (create-routes config)
+                      (internal-writer-routes server-connections)))) route-opts)
+       (ring/routes
+        (swagger-ui/create-swagger-ui-handler
+         {:path   "/"
+          :config {:validatorUrl     nil
+                   :operationsSorter "alpha"}})
+        (ring/create-default-handler)))
+      (wrap-cors :access-control-allow-origin (or (:access-control-allow-origin config)
+                                                  [#"http://localhost" #"http://localhost:8080"])
+                 :access-control-allow-methods [:get :put :post :delete])))
+
+(defn start-server [config]
+  (run-jetty (app config (default-route-opts muuntaja-with-opts) (atom {})) config))
+
+(defn stop-server [^org.eclipse.jetty.server.Server server]
+  (.stop server))
+
+(defn -main [& args]
+  (let [{:keys [level token] :as config} (edn/read-string (slurp (first args)))]
+    (when level (log/set-level! level))
+    (when (#{:trace :debug :info nil} level)
+      (println "Datahike HTTP Server" datahike-version "- https://datahike.io"))
+    (log/info "Config:" (if token (assoc config :token "REDACTED") config))
+    (start-server config)
+    (log/info "Server started.")))