datahike-browser-tests 1.0.0

package/src/datahike/api/types.cljc

@@ -0,0 +1,261 @@
+(ns datahike.api.types
+  "Malli type schemas for Datahike API.
+
+  This namespace replaces datahike.spec with malli-based schemas.
+  Schemas are used for:
+  - API specification
+  - Runtime validation
+  - Code generation (Java, CLI, TypeScript)
+  - Documentation generation"
+  (:require [malli.core :as m]
+            [malli.util :as mu]
+            [malli.error :as me]
+            [datahike.connector :refer [connection?]]
+            [datahike.datom :refer [datom?]]
+            [datahike.db.utils :as dbu])
+  #?(:clj
+     (:import [java.util Date])))
+
+;; =============================================================================
+;; Helper Predicates
+;; =============================================================================
+
+(defn date? [d]
+  #?(:cljs (instance? js/Date d)
+     :clj  (instance? Date d)))
+
+;; ============================================================================
+;; Core Type Schemas
+;; =============================================================================
+
+(def SDB
+  "Immutable database value."
+  [:fn {:error/message "must be a Datahike database"}
+   dbu/db?])
+
+(def SConfig
+  "Database configuration.
+
+  Can be:
+  - Map with :store key (primary format)
+  - URI string (deprecated)"
+  [:or
+   [:map {:closed false}]
+   :string])
+
+(def SConnection
+  "Database connection reference."
+  [:fn {:error/message "must be a Datahike connection"}
+   connection?])
+
+(def SEId
+  "Entity identifier.
+
+  Can be:
+  - Number (entity ID)
+  - Sequential (lookup ref [:attr value])
+  - Keyword (for schema entities)"
+  [:or [:fn number?]
+   [:sequential :any]
+   :keyword])
+
+(def SDatom
+  "Single datom (immutable fact)."
+  [:fn {:error/message "must be a Datom"}
+   datom?])
+
+(def SDatoms
+  "Collection of datoms."
+  [:sequential SDatom])
+
+(def STxMeta
+  "Transaction metadata - optional collection."
+  [:maybe :any])
+
+(def STransactionReport
+  "Transaction result map.
+
+  Keys:
+  - :db-before - Database before transaction
+  - :db-after - Database after transaction
+  - :tx-data - Datoms added/retracted
+  - :tempids - Temp ID to entity ID mapping
+  - :tx-meta - Transaction metadata (optional)"
+  [:map
+   [:db-before SDB]
+   [:db-after SDB]
+   [:tx-data SDatoms]
+   [:tempids :map]
+   [:tx-meta {:optional true} STxMeta]])
+
+(def STransactions
+  "Transaction data - collection of transaction forms."
+  [:sequential :any])
+
+(def SPullOptions
+  "Pull pattern options map."
+  [:map
+   [:selector [:vector :any]]
+   [:eid SEId]])
+
+(def SQueryArgs
+  "Query arguments map."
+  [:map
+   [:query [:or :string [:vector :any] :map]]
+   [:args {:optional true} [:sequential :any]]
+   [:limit {:optional true} :int]
+   [:offset {:optional true} :int]])
+
+(def SWithArgs
+  "Arguments for 'with' operation."
+  [:map
+   [:tx-data STransactions]
+   [:tx-meta {:optional true} STxMeta]])
+
+(def SIndexLookupArgs
+  "Index lookup arguments."
+  [:map
+   [:index [:enum :eavt :aevt :avet]]
+   [:components {:optional true} [:maybe [:sequential :any]]]])
+
+(def SIndexRangeArgs
+  "Index range query arguments."
+  [:map
+   [:attrid :keyword]
+   [:start :any]
+   [:end :any]])
+
+(def SSchema
+  "Database schema - map of attributes to schema entries."
+  [:map-of :any :any])
+
+(def SMetrics
+  "Database metrics map."
+  [:map
+   [:count :int]
+   [:avet-count :int]
+   [:per-attr-counts :map]
+   [:per-entity-counts :map]
+   [:temporal-count {:optional true} :int]
+   [:temporal-avet-count {:optional true} :int]])
+
+(def time-point?
+  "Time point - transaction ID (int) or Date."
+  [:or :int
+   [:fn {:error/message "must be a Date"}
+    date?]])
+
+;; =============================================================================
+;; Malli Registry
+;; =============================================================================
+
+(def registry
+  "Malli registry containing all Datahike type schemas.
+   This allows schemas to reference each other by keyword and enables
+   proper integration with reitit coercion."
+  (merge
+   (m/default-schemas)
+   {:datahike/SDB SDB
+    :datahike/SConfig SConfig
+    :datahike/SConnection SConnection
+    :datahike/SEId SEId
+    :datahike/SDatom SDatom
+    :datahike/SDatoms SDatoms
+    :datahike/STxMeta STxMeta
+    :datahike/STransactionReport STransactionReport
+    :datahike/STransactions STransactions
+    :datahike/SPullOptions SPullOptions
+    :datahike/SQueryArgs SQueryArgs
+    :datahike/SWithArgs SWithArgs
+    :datahike/SIndexLookupArgs SIndexLookupArgs
+    :datahike/SIndexRangeArgs SIndexRangeArgs
+    :datahike/SSchema SSchema
+    :datahike/SMetrics SMetrics
+    :datahike/time-point? time-point?}))
+
+;; =============================================================================
+;; Type Mappings for Code Generation
+;; =============================================================================
+
+(def malli->java-type
+  "Malli schema to Java type mapping."
+  {:SConfig "Map<String, Object>"
+   :SConnection "datahike.connector.Connection"
+   :SDB "datahike.db.DB"
+   :SEId "Object"
+   :SDatom "datahike.datom.Datom"
+   :SDatoms "List<Datom>"
+   :STransactions "List<Object>"
+   :STransactionReport "Map<String, Object>"
+   :SSchema "Map<Object, Object>"
+   :SMetrics "Map<String, Object>"
+   :SPullOptions "Map<String, Object>"
+   :SQueryArgs "Map<String, Object>"
+   :SIndexLookupArgs "Map<String, Object>"
+   :SIndexRangeArgs "Map<String, Object>"
+   :SWithArgs "Map<String, Object>"
+   ;; Primitives
+   :boolean "boolean"
+   :int "int"
+   :long "long"
+   :double "double"
+   :string "String"
+   :keyword "String"
+   :any "Object"
+   :nil "void"
+   ;; Collections
+   :vector "List"
+   :map "Map"
+   :set "Set"
+   :sequential "List"})
+
+(def malli->typescript-type
+  "Malli schema to TypeScript type mapping."
+  {:SConfig "DatabaseConfig"
+   :SConnection "Connection"
+   :SDB "Database"
+   :SEId "number | [string, any] | string"
+   :SDatom "Datom"
+   :SDatoms "Datom[]"
+   :STransactions "Transaction[]"
+   :STransactionReport "TransactionReport"
+   :SSchema "Record<string, any>"
+   :SMetrics "Metrics"
+   :SPullOptions "PullOptions"
+   :SQueryArgs "QueryArgs"
+   :SIndexLookupArgs "IndexLookupArgs"
+   :SIndexRangeArgs "IndexRangeArgs"
+   :SWithArgs "WithArgs"
+   ;; Primitives
+   :boolean "boolean"
+   :int "number"
+   :long "number"
+   :double "number"
+   :string "string"
+   :keyword "string"
+   :any "any"
+   :nil "null"
+   ;; Collections
+   :vector "Array<any>"
+   :map "Record<string, any>"
+   :set "Set<any>"
+   :sequential "Array<any>"})
+
+;; =============================================================================
+;; Validation Helpers
+;; =============================================================================
+
+(defn validate
+  "Validate data against schema."
+  [schema data]
+  (m/validate schema data))
+
+(defn explain
+  "Explain validation errors."
+  [schema data]
+  (m/explain schema data))
+
+(defn humanize
+  "Get human-readable validation errors."
+  [explanation]
+  (me/humanize explanation))

package/src/datahike/api.cljc

@@ -0,0 +1,41 @@
+(ns datahike.api
+  "Public API for datahike. Expanded from api.specification."
+  (:refer-clojure :exclude [filter])
+  #?(:cljs (:require-macros [datahike.api :refer [emit-api]]))
+  (:require [datahike.connector :as dc]
+            [datahike.config :as config]
+            [datahike.api.specification :refer [api-specification malli-schema->argslist]]
+            [datahike.api.impl]
+            [datahike.writer :as dw]
+            #?(:clj [datahike.http.writer])
+            [datahike.writing :as writing]
+            [konserve.store]
+            [datahike.constants :as const]
+            [datahike.core :as dcore]
+            [datahike.pull-api :as dp]
+            [datahike.query :as dq]
+            [datahike.schema :as ds]
+            [datahike.tools :as dt]
+            [datahike.db :as db #?@(:cljs [:refer [HistoricalDB AsOfDB SinceDB FilteredDB]])]
+            [datahike.db.interface :as dbi]
+            [datahike.db.transaction :as dbt]
+            [datahike.impl.entity :as de])
+  #?(:clj
+     (:import [clojure.lang Keyword PersistentArrayMap]
+              [datahike.db HistoricalDB AsOfDB SinceDB FilteredDB]
+              [datahike.impl.entity Entity])))
+
+(defmacro ^:private emit-api []
+  `(do
+     ~@(reduce
+        (fn [acc [n {:keys [args doc impl]}]]
+          (conj acc
+                `(def
+                   ~(with-meta n
+                      {:arglists `(malli-schema->argslist (quote ~args))
+                       :doc      doc})
+                   ~impl)))
+        ()
+        (into (sorted-map) api-specification))))
+
+(emit-api)

package/src/datahike/array.cljc

@@ -0,0 +1,99 @@
+(ns ^:no-doc datahike.array
+  #?(:cljs (:require [goog.array]))
+  #?(:clj (:import [java.util Arrays])))
+
+#?(:clj
+   nil
+   #_(defonce ^:private hh-node-ns
+       (try
+         (require 'hitchhiker.tree.node)
+         (find-ns 'hitchhiker.tree.node)
+         (catch Exception _ nil))))
+
+#?(:clj
+   (defn java8? []
+     (try
+       (= 8 (Integer/parseInt (subs (System/getProperty "java.specification.version") 2)))
+       (catch Exception _
+         false))))
+
+#?(:clj
+  ;; meta data doesn't get expanded in macros :/
+   (defn array-compare [a b] (Arrays/compare ^bytes a ^bytes b)))
+
+#?(:clj
+   (defmacro raw-array-compare [a b]
+     (if (java8?)
+       ;; slow fallback for Java 8, but has same semantics
+       `(let [bl# (alength ~b)
+              al# (alength ~a)]
+          (loop [i# 1]
+            (cond (and (> i# bl#) (> i# al#))
+                  0
+
+                  (> i# bl#)
+                  1 ;; b is a prefix of a
+
+                  (> i# al#)
+                  -1 ;; a is a prefix of b
+
+                  :else
+                  (let [ec# (compare (aget ~a (dec i#)) (aget ~b (dec i#)))]
+                    (if (not (zero? ec#))
+                      ec#
+                      (recur (inc i#)))))))
+       `(array-compare ~a ~b))))
+
+#?(:cljs
+   (defn bytes? [x]
+     (and (instance? js/ArrayBuffer (.-buffer x))
+          (number? (.-byteLength x)))))
+
+(defn compare-arrays
+  "Compare two arrays a and b element-wise in ascending order. If one array is a
+prefix of another then it comes first."
+  [a b]
+  #?(:cljs (goog.array/compare3 a b)
+     :clj
+     (if (not (and (bytes? a) (bytes? b)))
+       (try
+         (compare a b)
+         (catch ClassCastException _
+           #_(if hh-node-ns
+               (let [order-fn (ns-resolve hh-node-ns '-order-on-edn-types)]
+                 (- (order-fn a) (order-fn b)))
+             ;; Fallback when hitchhiker-tree not available
+               (compare (class a) (class b)))))
+       (raw-array-compare a b))))
+
+(defn string-from-bytes
+  "Represents a byte array as a string. Two byte arrays are said to be equal iff their corresponding values after applying this function are equal. That way, we rely on the equality and hash code implementations of the String class to compare byte arrays."
+  [x]
+  #?(:cljs (.decode (js/TextDecoder. "utf8") x)
+     :clj
+     (let [n (alength x)
+           dst (char-array n)]
+       (dotimes [i n]
+         (aset dst i (char (aget x i))))
+       (String. dst))))
+
+(defrecord WrappedBytes [string-repr])
+
+(defn wrap-comparable
+  "This functions is such that `(a= x y)` is equivalent to `(= (wrap-comparable x) (wrap-comparable y))`. This lets us also use these semantics in hash-sets or as keys in maps."
+  [x]
+  (if (bytes? x)
+    (WrappedBytes. #?(:clj (string-from-bytes x)
+                      :cljs x))
+    x))
+
+(defn a=
+  "Extension of Clojure's equality to things we also want to treat like values,
+  e.g. certain array types."
+  [a b]
+  (or (= a b)
+      #?(:clj (and (bytes? a)
+                   (bytes? b)
+                   (zero? (compare-arrays a b)))
+         :cljs (or (identical? a b)
+                   (zero? (compare-arrays a b))))))

package/src/datahike/cli.clj

@@ -0,0 +1,166 @@
+(ns datahike.cli
+  (:gen-class)
+  (:require [clojure.java.io :as io]
+            [clojure.pprint :refer [pprint]]
+            [clojure.string :as str]
+            [clojure.tools.cli :refer [parse-opts]]
+            [datahike.api :as d]
+            [datahike.pod :refer [run-pod]]
+            [datahike.codegen.cli :as cli-gen]
+            [clojure.edn :as edn]
+            [jsonista.core :as j]
+            [datahike.json :as json]
+            [clj-cbor.core :as cbor]
+            [taoensso.timbre :as log])
+  (:import [java.util Date]))
+
+;; This file is following https://github.com/clojure/tools.cli
+
+(when-not (= "true" (System/getenv "BABASHKA_POD"))
+  (log/merge-config!
+   {:appenders {:println {:enabled? false} ;; leave a "paper trail"
+                :stderr {:doc "Always prints to *err*"
+                         :enabled? true
+                         :fn (fn log-to-stderr [{:keys [output_]}]
+                               (binding [*out* *err*]
+                                 (println (force output_))))}}}))
+
+(defn get-version []
+  (or
+   ;; Try to read version from resource file (generated at build time)
+   (try
+     (some-> (io/resource "DATAHIKE_VERSION")
+             slurp
+             str/trim)
+     (catch Exception _ nil))
+   ;; Fallback for development builds
+   "development build"))
+
+(defn usage [options-summary]
+  (cli-gen/generate-help options-summary))
+
+(defn error-msg [errors]
+  (str "The following errors occurred while parsing your command:\n\n"
+       (str/join \newline errors)))
+
+(def cli-options
+  ;; An option with a required argument
+  (let [formats #{:json :edn :pprint :cbor}]
+    [["-f" "--format FORMAT" "Output format for the result."
+      :default :edn
+      :parse-fn keyword
+      :validate [formats (str "Must be one of: " (str/join ", " formats))]]
+     ["-if" "--input-format FORMAT" "Input format for the transaction."
+      :default :edn
+      :parse-fn keyword
+      :validate [formats (str "Must be one of: " (str/join ", " formats))]]
+     [nil "--tx-file PATH" "Use this input file for transactions instead of command line or STDIN."
+      :default nil
+      :validate [#(.exists (io/file %)) "Transaction file does not exist."]]
+     ;; A non-idempotent option (:default is applied first)
+     ["-v" nil "Verbosity level"
+      :id :verbosity
+      :default 0
+      :update-fn inc]
+     ;; A boolean option defaulting to nil
+     ["-h" "--help"]
+     [nil "--version" "Show version"]]))
+
+(defn validate-args
+  "Validate command line arguments. Either return a map indicating the program
+  should exit (with a error message, and optional ok status), or a map
+  indicating the command the program should execute and the options provided."
+  [args]
+  (let [{:keys [options arguments errors summary]} (parse-opts args cli-options)
+        pod? (= "true" (System/getenv "BABASHKA_POD"))
+        command-index (cli-gen/build-command-index)]
+    (cond
+      pod?
+      {:action :pod :options options}
+
+      (:help options) ; help => exit OK with usage summary
+      {:exit-message (usage summary) :ok? true :options options}
+
+      (:version options) ; version => exit OK with version string
+      {:exit-message (str "Datahike " (get-version)) :ok? true :options options}
+
+      errors          ; errors => exit with description of errors
+      {:exit-message (error-msg errors) :options options}
+
+      ;; Try to match command (could be multi-part like "db exists")
+      (seq arguments)
+      (let [;; Try 2-part command first (e.g., "db exists")
+            two-part (str/join " " (take 2 arguments))
+            one-part (first arguments)
+
+            [cmd-str remaining-args]
+            (cond
+              (get command-index two-part)
+              [two-part (drop 2 arguments)]
+
+              (get command-index one-part)
+              [one-part (rest arguments)]
+
+              :else
+              [nil arguments])]
+
+        (if cmd-str
+          {:command cmd-str
+           :options options
+           :arguments (vec remaining-args)}
+          {:exit-message (str "Unknown command: " (str/join " " (take 2 arguments))
+                              "\n\nUse 'dthk --help' to see available commands.")
+           :options options}))
+
+      :else           ; No arguments
+      {:exit-message (usage summary)
+       :options options})))
+
+(defn exit [status msg]
+  (println msg)
+  (System/exit status))
+
+(defn report [format out]
+  (case format
+    :json        (println (j/write-value-as-string out))
+    :edn         (println (pr-str out))
+    :pprint      (pprint out)
+    :cbor        (.write System/out ^bytes (cbor/encode out))))
+
+(defn -main [& args]
+  (let [{:keys [action command options arguments exit-message ok?]}
+        (validate-args args)]
+    ;; Set logging level
+    (case (int (:verbosity options))
+      0 (log/set-level! :warn)
+      1 (log/set-level! :info)
+      2 (log/set-level! :debug)
+      3 (log/set-level! :trace)
+      (exit 1 (str "Verbosity level not supported: " (:verbosity options))))
+
+    (cond
+      ;; Exit with message
+      exit-message
+      (exit (if ok? 0 1) exit-message)
+
+      ;; Babashka pod mode
+      (= action :pod)
+      (run-pod args)
+
+      ;; Execute command via generated dispatch
+      command
+      (try
+        (let [result (cli-gen/dispatch-command
+                      (str/split command #"\s+")
+                      arguments
+                      options)]
+          (report (:format options) result))
+        (catch Exception e
+          (println "❌ Error executing command:" (.getMessage e))
+          (when (>= (:verbosity options) 2)
+            (.printStackTrace e))
+          (exit 1 "")))
+
+      ;; No command provided
+      :else
+      (exit 1 (usage (:summary (parse-opts args cli-options)))))))

package/src/datahike/cljs.cljs

@@ -0,0 +1,6 @@
+(ns datahike.cljs
+  "ClojureScript implementations for clojure-only symbols")
+
+;; Conversions
+
+(def Throwable js/Error)