datahike-browser-tests 1.0.0

package/src/datahike/js/api.cljs

@@ -0,0 +1,172 @@
+(ns datahike.js.api
+  "JavaScript API for Datahike with Promise conversion and data transformation"
+  (:refer-clojure :exclude [filter])
+  (:require [datahike.api.specification :refer [api-specification]]
+            [datahike.api.impl]
+            [datahike.store] ;; Register :mem backend
+            [datahike.db.interface]
+            [datahike.datom]
+            [cljs.core.async :refer [<!]]
+            [clojure.string :as str]
+            [clojure.walk :as walk]
+            [goog.object :as gobj])
+  (:require-macros [cljs.core.async.macros :refer [go]]
+                   [datahike.js.api-macros :refer [emit-js-api]]))
+
+;; Register Node.js file backend - conditional require
+;; For Node.js: konserve.node-filestore is added to shadow-cljs :entries
+;; For browser: module is excluded from build
+(when (and (exists? js/require)
+           (fn? js/require))
+  (try
+    (js/require "./konserve.node_filestore")
+    (catch :default _ nil)))
+
+;; =============================================================================
+;; Data Conversion Helpers
+;;
+;; Universal EDN Conversion Rules (consistent across Python, JavaScript, Java):
+;; - Keys: always keywordized
+;; - Values: ":" prefix = keyword, else literal
+;; - Escape: "\\:" for literal colon strings
+;; - Bonus: UUID auto-detection for convenience
+;; =============================================================================
+
+(def ^:private uuid-regex
+  "Regex pattern for UUID strings (8-4-4-4-12 hex digits)"
+  #"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
+
+(defn- uuid-string?
+  "Check if a string is a valid UUID format"
+  [s]
+  (and (string? s) (re-matches uuid-regex s)))
+
+(defn- convert-string
+  "Convert a string to appropriate Clojure type following universal EDN rules:
+  - '\\:literal' -> ':literal' (escaped colon becomes literal string with :)
+  - ':keyword' -> keyword
+  - UUID format -> UUID object (convenience)
+  - otherwise -> string"
+  [s]
+  (cond
+    ;; Escaped colon - strip backslash and return literal string
+    (str/starts-with? s "\\:") (subs s 1)
+    ;; Colon prefix - convert to keyword
+    (str/starts-with? s ":") (keyword (subs s 1))
+    ;; UUID auto-detection (convenience feature)
+    (uuid-string? s) (uuid s)
+    ;; Regular string
+    :else s))
+
+(defn js->clj-recursive
+  "Recursively convert JS objects to Clojure data with keyword keys.
+  Also converts strings like ':keyword' to keywords and UUID strings to UUIDs."
+  [x]
+  (cond
+    ;; Check for JS object first (but not arrays, functions, or null)
+    (and (object? x)
+         (not (array? x))
+         (not (fn? x))
+         (not (nil? x)))
+    (into {} (for [k (js-keys x)]
+               (let [v (gobj/get x k)
+                     ;; Convert keys to keywords, stripping leading : if present
+                     k-kw (if (str/starts-with? k ":")
+                            (keyword (subs k 1))
+                            (keyword k))]
+                 [k-kw (js->clj-recursive v)])))
+
+    ;; Arrays become vectors
+    (array? x)
+    (mapv js->clj-recursive x)
+
+    ;; Strings: convert keywords, UUIDs, or pass through
+    (string? x)
+    (convert-string x)
+
+    ;; Everything else passes through
+    :else x))
+
+(defn clj->js-recursive
+  "Recursively convert Clojure data to JS objects.
+  Converts keywords to strings with ':' prefix.
+  Datahike objects (DB, connections, datoms) pass through unchanged."
+  [x]
+  (cond
+    ;; Datahike DB objects - pass through unchanged
+    (satisfies? datahike.db.interface/IDB x)
+    x
+
+    ;; Datoms - pass through unchanged
+    (= (type x) datahike.datom.Datom)
+    x
+
+    ;; Connections (check for typical connection keys)
+    (and (map? x) (:conn-atom x))
+    x
+
+    ;; Keywords become strings with ":"
+    (keyword? x)
+    (str x)
+
+    ;; Maps become JS objects
+    (map? x)
+    (let [obj (js-obj)]
+      (doseq [[k v] x]
+        (gobj/set obj
+                  (if (keyword? k) (name k) (str k))
+                  (clj->js-recursive v)))
+      obj)
+
+    ;; Sequential collections become arrays
+    (sequential? x)
+    (into-array (map clj->js-recursive x))
+
+    ;; Sets become arrays
+    (set? x)
+    (into-array (map clj->js-recursive x))
+
+    ;; Everything else passes through
+    :else x))
+
+;; =============================================================================
+;; Async/Promise Conversion
+;; =============================================================================
+
+(defn maybe-chan->promise
+  "Convert a core.async channel to a Promise, or return value directly if not a channel.
+  This handles the dynamic async/sync execution in Datahike API.
+
+  Errors returned on the channel (not thrown) are properly rejected by checking
+  if the result is a js/Error or ExceptionInfo."
+  [x]
+  (if (satisfies? cljs.core.async.impl.protocols/Channel x)
+    (js/Promise.
+     (fn [resolve reject]
+       (go
+         (try
+           (let [result (<! x)]
+             ;; Check if result is an error object - reject promise if so
+             (if (or (instance? js/Error result)
+                     (instance? ExceptionInfo result))
+               (reject result)
+               (resolve result)))
+           (catch :default e
+             ;; Catch any exceptions thrown during channel operations
+             (reject e))))))
+    (js/Promise.resolve x)))
+
+;; =============================================================================
+;; Generate All API Functions
+;; =============================================================================
+
+(emit-js-api)
+
+;; =============================================================================
+;; Additional JS-specific Helpers
+;; =============================================================================
+
+(defn ^:export isPromise
+  "Check if a value is a Promise."
+  [x]
+  (instance? js/Promise x))

package/src/datahike/js/api_macros.clj

@@ -0,0 +1,22 @@
+(ns datahike.js.api-macros
+  "Macros for generating JavaScript API."
+  (:require [datahike.api.specification :refer [api-specification]]
+            [datahike.codegen.naming :refer [js-skip-list clj-name->js-name]]))
+
+(defmacro emit-js-api
+  "Generate JavaScript API functions from api-specification.
+  This macro must be in a .clj file since it's used by ClojureScript."
+  []
+  `(do
+     ~@(for [[clj-fn-name {:keys [doc impl]}] api-specification
+             :when (not (contains? js-skip-list clj-fn-name))
+             :let [js-fn-name (symbol (clj-name->js-name clj-fn-name))
+                   impl-fn (symbol (namespace impl) (name impl))]]
+         `(defn ~(with-meta js-fn-name {:export true :doc doc})
+            [& args#]
+            (let [clj-args# (map datahike.js.api/js->clj-recursive args#)
+                  result# (apply ~impl-fn clj-args#)]
+              (-> result#
+                  datahike.js.api/maybe-chan->promise
+                  (.then datahike.js.api/clj->js-recursive)))))))
+

package/src/datahike/js.cljs

@@ -0,0 +1,163 @@
+(ns ^:no-doc datahike.js
+  (:refer-clojure :exclude [filter])
+  (:require
+   [goog.object :as go]
+   [datahike.core :as d]
+   [clojure.walk :as walk]
+   [cljs.reader]))
+
+;; Conversions
+
+(defn- keywordize [s]
+  (if (and (string? s) (= (subs s 0 1) ":"))
+    (keyword (subs s 1))
+    s))
+
+(defn- schema->clj [schema]
+  (->> (js->clj schema)
+       (reduce-kv
+        (fn [m k v] (assoc m k (walk/postwalk keywordize v))) {})))
+
+(declare entities->clj)
+
+(defn- entity-map->clj [e]
+  (walk/postwalk
+   (fn [form]
+     (if (and (map? form) (contains? form ":db/id"))
+       (-> form
+           (dissoc ":db/id")
+           (assoc  :db/id (get form ":db/id")))
+       form))
+   e))
+
+(defn- entity->clj [e]
+  (cond
+    (map? e)
+    (entity-map->clj e)
+
+    (= (first e) ":db.fn/call")
+    (let [[_ f & args] e]
+      (concat [:db.fn/call (fn [& args] (entities->clj (apply f args)))] args))
+
+    (sequential? e)
+    (let [[op & entity] e]
+      (concat [(keywordize op)] entity))))
+
+(defn- entities->clj [entities]
+  (->> (js->clj entities)
+       (map entity->clj)))
+
+(defn- tempids->js [tempids]
+  (let [obj (js-obj)]
+    (doseq [[k v] tempids]
+      (go/set obj (str k) v))
+    obj))
+
+(defn- tx-report->js [report]
+  #js {:db_before (:db-before report)
+       :db_after  (:db-after report)
+       :tx_data   (->> (:tx-data report) into-array)
+       :tempids   (tempids->js (:tempids report))
+       :tx_meta   (:tx-meta report)})
+
+(defn js->Datom [d]
+  (if (array? d)
+    (d/datom (aget d 0) (aget d 1) (aget d 2) (or (aget d 3) d/tx0) (or (aget d 4) true))
+    (d/datom (.-e d) (.-a d) (.-v d) (or (.-tx d) d/tx0) (or (.-added d) true))))
+
+(defn- pull-result->js
+  [result]
+  (->> result
+       (walk/postwalk #(if (keyword? %) (str %) %))
+       clj->js))
+
+;; Public API
+
+(defn ^:export empty_db [& [schema]]
+  (d/empty-db (schema->clj schema)))
+
+(defn ^:export init_db [datoms & [schema]]
+  (d/init-db (map js->Datom datoms) (schema->clj schema)))
+
+(defn ^:export q [query & sources]
+  (let [query   (cljs.reader/read-string query)
+        results (apply d/q query sources)]
+    (clj->js results)))
+
+(defn ^:export pull [db pattern eid]
+  (let [pattern (cljs.reader/read-string pattern)
+        eid (js->clj eid)
+        results (d/pull db pattern eid)]
+    (pull-result->js results)))
+
+(defn ^:export pull_many [db pattern eids]
+  (let [pattern (cljs.reader/read-string pattern)
+        eids (js->clj eids)
+        results (d/pull-many db pattern eids)]
+    (pull-result->js results)))
+
+(defn ^:export db_with [db entities]
+  (d/db-with db (entities->clj entities)))
+
+(defn ^:export entity [db eid]
+  (d/entity db (js->clj eid)))
+
+(def ^:export touch d/touch)
+(def ^:export entity_db d/entity-db)
+(def ^:export filter d/filter)
+(def ^:export is_filtered d/is-filtered)
+
+(defn ^:export create_conn [& [schema]]
+  (d/create-conn (schema->clj schema)))
+
+(def ^:export conn_from_db d/conn-from-db)
+
+(defn ^:export conn_from_datoms
+  ([datoms]        (conn_from_db (init_db datoms)))
+  ([datoms schema] (conn_from_db (init_db datoms schema))))
+
+(defn ^:export db [conn] @conn)
+
+(defn ^:export transact [conn entities & [tx-meta]]
+  (let [entities (entities->clj entities)
+        report   (-> (d/-transact! conn entities tx-meta)
+                     tx-report->js)]
+    (doseq [[_ callback] @(:listeners (meta conn))]
+      (callback report))
+    report))
+
+(defn ^:export reset_conn [conn db & [tx-meta]]
+  (let [report #js {:db_before @conn
+                    :db_after  db
+                    :tx_data   (into-array
+                                (concat
+                                 (map #(assoc % :added false) (d/datoms @conn :eavt))
+                                 (d/datoms db :eavt)))
+                    :tx_meta   tx-meta}]
+    (reset! conn db)
+    (doseq [[_ callback] @(:listeners (meta conn))]
+      (callback report))
+    db))
+
+(def ^:export listen d/listen!)
+(def ^:export unlisten d/unlisten!)
+
+(defn ^:export resolve_tempid [tempids tempid]
+  (go/get tempids (str tempid)))
+
+(defn ^:export datoms [db index & components]
+  (->> (apply d/datoms db (keywordize index) components)
+       into-array))
+
+(defn ^:export seek_datoms [db index & components]
+  (->> (apply d/seek-datoms db (keywordize index) components)
+       into-array))
+
+(defn ^:export index_range [db attr start end]
+  (into-array (d/index-range db attr start end)))
+
+(defn ^:export squuid []
+  (str (d/squuid)))
+
+(defn ^:export squuid_time_millis [uuid]
+  (d/squuid-time-millis (cljs.core/uuid uuid)))

package/src/datahike/json.cljc

@@ -0,0 +1,209 @@
+(ns datahike.json
+  "JSON related translations."
+  (:require [clojure.edn :as edn]
+            [clojure.walk :as walk]
+            [datahike.store :refer [store-identity]]
+            [datahike.readers :as readers]
+            [datahike.connector]
+            [datahike.datom :as dd]
+            [datahike.schema :as s]
+            [jsonista.core :as j]
+            [jsonista.tagged :as jt])
+  #?(:clj
+     (:import [datahike.datom Datom]
+              [datahike.impl.entity Entity]
+              [com.fasterxml.jackson.core JsonGenerator]
+              [datahike.db HistoricalDB AsOfDB SinceDB])))
+
+(defn config->store-id [config]
+  [(store-identity (:store config))
+   (:branch config)])
+
+(defn db->map [db]
+  (let [{:keys [config meta max-eid max-tx]} db]
+    {:store-id  (config->store-id config)
+     :commit-id (:datahike/commit-id meta)
+     :max-eid   max-eid
+     :max-tx    max-tx}))
+
+(declare mapper)
+
+(defn write-to-generator [f]
+  (fn [x ^JsonGenerator gen]
+    (.writeRawValue gen (j/write-value-as-string (f x) mapper))))
+
+(def json-base-handlers
+  {clojure.lang.Keyword
+   {:tag    "!kw"
+    :encode jt/encode-keyword
+    :decode keyword}
+
+   clojure.lang.Symbol
+   {:tag    "!sym"
+    :encode jt/encode-str
+    :decode symbol}
+
+   clojure.lang.PersistentHashSet
+   {:tag    "!set"
+    :encode jt/encode-collection
+    :decode set}
+
+   java.util.UUID
+   {:tag    "!uuid"
+    :encode jt/encode-str
+    :decode #(java.util.UUID/fromString %)}
+
+   java.util.Date
+   {:tag    "!date"
+    :encode #(jt/encode-str (.getTime ^java.util.Date %1) %2)
+    :decode #(java.util.Date. (Long/parseLong %))}})
+
+(def mapper-opts
+  {:encode-key-fn true
+   :decode-key-fn true
+   :modules       [(jt/module
+                    {:handlers
+                     (merge
+                      json-base-handlers
+                      {datahike.connector.Connection
+                       {:tag    "!datahike/Connection"
+                        :encode (write-to-generator #(config->store-id (:config @(:wrapped-atom %))))
+                        :decode datahike.readers/connection-from-reader}
+
+                       datahike.datom.Datom
+                       {:tag    "!datahike/Datom"
+                        :encode (write-to-generator
+                                 (fn [^Datom d]
+                                   [(.-e d) (.-a d) (.-v d) (dd/datom-tx d) (dd/datom-added d)]))
+                        :decode datahike.readers/datom-from-reader}
+
+                       datahike.db.TxReport
+                       {:tag    "!datahike/TxReport"
+                        :encode (write-to-generator #(into {} %))
+                        :decode datahike.db/map->TxReport}
+
+                       datahike.db.DB
+                       {:tag    "!datahike/DB"
+                        :encode (write-to-generator db->map)
+                        :decode datahike.readers/db-from-reader}
+
+                       datahike.db.HistoricalDB
+                       {:tag    "!datahike/HistoricalDB"
+                        :encode (write-to-generator
+                                 (fn [{:keys [origin-db]}]
+                                   {:origin origin-db}))
+                        :decode datahike.readers/history-from-reader}
+
+                       datahike.db.SinceDB
+                       {:tag    "!datahike/SinceDB"
+                        :encode (write-to-generator
+                                 (fn [{:keys [origin-db time-point]}]
+                                   {:origin     origin-db
+                                    :time-point time-point}))
+                        :decode datahike.readers/since-from-reader}
+
+                       datahike.db.AsOfDB
+                       {:tag    "!datahike/AsOfDB"
+                        :encode (write-to-generator
+                                 (fn [{:keys [origin-db time-point]}]
+                                   {:origin     origin-db
+                                    :time-point time-point}))
+                        :decode datahike.readers/as-of-from-reader}
+
+                       datahike.impl.entity.Entity
+                       {:tag    "!datahike/Entity"
+                        :encode (write-to-generator
+                                 (fn [^Entity e]
+                                   (assoc (into {} e)
+                                          :db (.-db e)
+                                          :eid (.-eid e))))
+                        :decode datahike.readers/entity-from-reader}})})]})
+
+(def mapper (j/object-mapper mapper-opts))
+
+;; import from datahike-server for JSON transact support with this code you can
+;; pass normal JSON maps or arrays of Datoms and strings will be automatically
+;; converted to keywords depending on their position
+
+(def number-re #"\d+(\.\d+)?")
+(def number-format-instance (java.text.NumberFormat/getInstance))
+
+(defn- filter-value-type-attrs [valtypes schema]
+  (into #{} (filter #(-> % schema :db/valueType valtypes) (keys schema))))
+
+(def ^:private filter-kw-attrs
+  (partial filter-value-type-attrs #{:db.type/keyword :db.type/value :db.type/cardinality :db.type/unique}))
+
+(def keyword-valued-schema-attrs (filter-kw-attrs s/implicit-schema-spec))
+
+(defn- xf-val [f v]
+  (if (vector? v) (map f v) (f v)))
+
+(declare handle-id-or-av-pair)
+
+(defn- xf-ref-val [v valtype-attrs-map db]
+  (if (vector? v)
+    (walk/prewalk #(handle-id-or-av-pair % valtype-attrs-map db) v)
+    v))
+
+(defn keywordize-string [s]
+  (if (string? s) (keyword s) s))
+
+(defn ident-for [^datahike.db.DB db a]
+  (if (and (number? a) (some? db)) (.-ident-for db a) a))
+
+(defn cond-xf-val
+  [a-ident v {:keys [ref-attrs long-attrs keyword-attrs symbol-attrs] :as valtype-attrs-map} db]
+  (cond
+    (contains? ref-attrs a-ident) (xf-ref-val v valtype-attrs-map db)
+    (contains? long-attrs a-ident) (xf-val long v)
+    (contains? keyword-attrs a-ident) (xf-val keyword v)
+    (contains? symbol-attrs a-ident) (xf-val symbol v)
+    :else v))
+
+(defn handle-id-or-av-pair
+  ([v valtype-attrs-map]
+   (handle-id-or-av-pair v valtype-attrs-map nil))
+  ([v valtype-attrs-map db]
+   (if (and (vector? v) (= (count v) 2))
+     (let [a (keywordize-string (first v))]
+       [a (cond-xf-val (ident-for db a) (nth v 1) valtype-attrs-map db)])
+     v)))
+
+(defn- xf-tx-data-map [m valtype-attrs-map db]
+  (into {}
+        (map (fn [[a v]]
+               [a (if (= :db/id a)
+                    (handle-id-or-av-pair [a v] valtype-attrs-map db)
+                    (cond-xf-val a v valtype-attrs-map db))])
+             m)))
+
+(defn- xf-tx-data-vec [tx-vec valtype-attrs-map db]
+  (let [op (first tx-vec)
+        [e a v] (rest tx-vec)
+        a (keywordize-string a)]
+    (vec (filter some? (list (keyword op)
+                             (handle-id-or-av-pair e valtype-attrs-map db)
+                             a
+                             (cond-xf-val (ident-for db a) v valtype-attrs-map db))))))
+
+(defn get-valtype-attrs-map [schema]
+  (let [ref-valued-attrs (filter-value-type-attrs #{:db.type/ref} schema)
+        long-valued-attrs (filter-value-type-attrs #{:db.type/long} schema)
+        kw-valued-attrs (clojure.set/union keyword-valued-schema-attrs (filter-kw-attrs schema))
+        sym-valued-attrs (filter-value-type-attrs #{:db.type/symbol} schema)]
+    {:ref-attrs ref-valued-attrs
+     :long-attrs long-valued-attrs
+     :keyword-attrs kw-valued-attrs
+     :symbol-attrs sym-valued-attrs}))
+
+(defn xf-data-for-tx [tx-data db]
+  (let [valtype-attrs-map (get-valtype-attrs-map (:schema db))]
+    (map #(let [xf-fn (cond (map? %) xf-tx-data-map
+                            (vector? %) xf-tx-data-vec
+                            ; Q: Is this error appropriate?
+                            :else (throw (ex-info "Only maps and vectors allowed in :tx-data and :tx-meta"
+                                                  {:event :handlers/transact :data tx-data})))]
+            (xf-fn % valtype-attrs-map db))
+         tx-data)))
+