datahike-browser-tests 1.0.0

package/README.md

@@ -0,0 +1,273 @@
+<p align="center">
+  <a align="center" href="https://datahike.io" target="_blank">
+    <img alt="Datahike" src="./doc/assets/datahike-logo.svg" height="128em">
+  </a>
+</p>
+<p align="center">
+<a href="https://clojurians.slack.com/archives/CB7GJAN0L"><img src="https://badgen.net/badge/-/slack?icon=slack&label"/></a>
+<a href="https://clojars.org/org.replikativ/datahike"> <img src="https://img.shields.io/clojars/v/org.replikativ/datahike.svg" /></a>
+<a href="https://circleci.com/gh/replikativ/datahike"><img src="https://circleci.com/gh/replikativ/datahike.svg?style=shield"/></a>
+<a href="https://github.com/replikativ/datahike/tree/main"><img src="https://img.shields.io/github/last-commit/replikativ/datahike/main"/></a>
+</p>
+
+**Branch databases, not just code.**
+
+[Datahike](https://datahike.io) is a durable [Datalog](https://en.wikipedia.org/wiki/Datalog) database with
+Datomic-compatible APIs and git-like semantics. Built on persistent data structures and structural sharing,
+database snapshots are immutable values that can be held, shared, and queried anywhere—without locks or copying.
+
+**Key capabilities:**
+- 🌐 **[Distributed Index Space](./doc/distributed.md)**: Read scaling without database connections—readers access persistent indices directly
+- 🗄️ **[Flexible storage](./doc/storage-backends.md)**: File, LMDB, S3, JDBC, Redis, IndexedDB via konserve
+- 🌍 **[Cross-platform](./doc/README.md#language-bindings-beta)**: JVM, Node.js, Browser (Clojure, ClojureScript, JavaScript, Java APIs)
+- ⚡ **[Real-time sync](./doc/distributed.md)**: WebSocket streaming with Kabel for browser ↔ server
+- 🕰️ **[Time-travel](./doc/time_variance.md)**: Query any historical state, full transaction audit trail
+- 🔒 **[GDPR-ready](./doc/time_variance.md#data-purging)**: Complete data excision for regulatory compliance
+- 🚀 **[Production-proven](https://gitlab.com/arbetsformedlingen/taxonomy-dev)**: Tested with billions of datoms, deployed in government services
+
+**Distributed by design**: Datahike is part of the [replikativ](https://github.com/replikativ) ecosystem for decentralized data architectures.
+
+## Why Datalog?
+
+Modern applications model increasingly complex relationships—social networks, organizational hierarchies, supply chains, knowledge graphs. Traditional SQL forces you to express graph queries through explicit joins, accumulating complexity as relationships grow. Datalog uses **pattern matching over relationships**: describe what you're looking for, not how to join tables.
+
+As systems evolve, SQL schemas accumulate join complexity. What starts as simple tables becomes nested subqueries and ad-hoc graph features. Datalog treats relationships as first-class: transitive queries, recursive rules, and multi-database joins are natural to express. The result is maintainable queries that scale with relationship complexity. See [Why Datalog?](./doc/datalog-vs-sql.md) for detailed comparisons.
+
+**Time is fundamental to information**: Most value derives from how facts evolve over time. Datahike's immutable design treats the database as an append-only log of facts—queryable at any point in history, enabling audit trails, debugging through time-travel, and GDPR-compliant data excision. Immutability also powers Distributed Index Space: database snapshots are values that can be shared, cached, and queried without locks.
+
+You can find [API documentation on cljdoc](https://cljdoc.org/d/org.replikativ/datahike) and articles on Datahike on our company's [blog page](https://datahike.io/notes/).
+
+[![cljdoc](https://badgen.net/badge/cljdoc/datahike/blue)](https://cljdoc.org/d/org.replikativ/datahike)
+
+We presented Datahike also at meetups,for example at:
+
+- [2021 Bay Area Clojure meetup](https://www.youtube.com/watch?v=GG-S-xrDS5M)
+- [2019 scicloj online meetup](https://www.youtube.com/watch?v=Hjo4TEV81sQ).
+- [2019 Vancouver Meetup](https://www.youtube.com/watch?v=A2CZwOHOb6U).
+- [2018 Dutch clojure meetup](https://www.youtube.com/watch?v=W6Z1mkvqp3g).
+
+## Usage
+
+Add to your dependencies:
+
+[![Clojars Project](http://clojars.org/org.replikativ/datahike/latest-version.svg)](http://clojars.org/org.replikativ/datahike)
+
+We provide a stable API for the JVM that we extend by first providing experimental/beta features that then get merged into the API over time.
+
+```clojure
+(require '[datahike.api :as d])
+
+
+;; use the filesystem as storage medium
+(def cfg {:store {:backend :file 
+                  :id #uuid "550e8400-e29b-41d4-a716-446655440000"
+                  :path "/tmp/example"}})
+
+;; create a database at this place, per default configuration we enforce a strict
+;; schema and keep all historical data
+(d/create-database cfg)
+
+(def conn (d/connect cfg))
+
+;; the first transaction will be the schema we are using
+;; you may also add this within database creation by adding :initial-tx
+;; to the configuration
+(d/transact conn [{:db/ident :name
+                   :db/valueType :db.type/string
+                   :db/cardinality :db.cardinality/one }
+                  {:db/ident :age
+                   :db/valueType :db.type/long
+                   :db/cardinality :db.cardinality/one }])
+
+;; lets add some data and wait for the transaction
+(d/transact conn [{:name  "Alice", :age   20 }
+                  {:name  "Bob", :age   30 }
+                  {:name  "Charlie", :age   40 }
+                  {:age 15 }])
+
+;; search the data
+(d/q '[:find ?e ?n ?a
+       :where
+       [?e :name ?n]
+       [?e :age ?a]]
+  @conn)
+;; => #{[3 "Alice" 20] [4 "Bob" 30] [5 "Charlie" 40]}
+
+;; add new entity data using a hash map
+(d/transact conn {:tx-data [{:db/id 3 :age 25}]})
+
+;; if you want to work with queries like in
+;; https://grishaev.me/en/datomic-query/,
+;; you may use a hashmap
+(d/q {:query '{:find [?e ?n ?a ]
+               :where [[?e :name ?n]
+                       [?e :age ?a]]}
+      :args [@conn]})
+;; => #{[5 "Charlie" 40] [4 "Bob" 30] [3 "Alice" 25]}
+
+;; query the history of the data
+(d/q '[:find ?a
+       :where
+       [?e :name "Alice"]
+       [?e :age ?a]]
+  (d/history @conn))
+;; => #{[20] [25]}
+
+;; you might need to release the connection for specific stores
+(d/release conn)
+
+;; clean up the database if it is not need any more
+(d/delete-database cfg)
+```
+
+The API namespace provides compatibility to a subset of Datomic functionality
+and should work as a drop-in replacement on the JVM. The rest of Datahike will
+be ported to core.async to coordinate IO in a platform-neutral manner.
+
+## Documentation
+
+**[📖 Complete Documentation Index](./doc/README.md)** - Organized by topic and skill level
+
+**Quick links:**
+- [Configuration](./doc/config.md) - Database setup and backend options
+- [Why Datalog?](./doc/datalog-vs-sql.md) - Query comparisons and when to use Datalog
+- [Language Bindings](./doc/README.md#language-bindings-beta) - Java, JavaScript, Python, CLI, and more (beta)
+- [Time Variance](./doc/time_variance.md) - Time-travel queries and GDPR-compliant purging
+
+
+For simple examples have a look at the projects in the `examples` folder.
+
+## Example Projects
+
+### Applications
+
+- **[Beleg](https://github.com/replikativ/beleg)** - Invoice and CRM system with web UI, LaTeX PDF generation, and Datahike persistence. Works as both an example project demonstrating Datahike patterns and a practical solution for contractors and small businesses. Features customers, tasks, offers, and invoices. Successor to the [original Datahike invoice demo](https://www.youtube.com/watch?v=W6Z1mkvqp3g) from Dutch Clojure Meetup 2018.
+
+## ClojureScript & JavaScript Support
+
+Datahike has **beta ClojureScript support** for both **Node.js** (file backend) and **browsers** (IndexedDB with TieredStore for memory hierarchies).
+
+**JavaScript API** (beta):
+
+Install from npm:
+```bash
+npm install datahike@next
+```
+
+Example usage:
+```javascript
+const d = require('datahike');
+const crypto = require('crypto');
+
+const config = {
+  store: {
+    backend: ':memory',
+    id: crypto.randomUUID()
+  },
+  'schema-flexibility': ':read'
+};
+
+await d.createDatabase(config);
+const conn = await d.connect(config);
+await d.transact(conn, [{ name: 'Alice' }]);
+const db = await d.db(conn);
+const results = await d.q('[:find ?n :where [?e :name ?n]]', db);
+console.log(results);
+// => [['Alice']]
+```
+
+See [JavaScript API documentation](./doc/javascript-api.md) for details.
+
+**Browser with real-time sync**: Combine IndexedDB storage with [Kabel](https://github.com/replikativ/kabel) WebSocket middleware for offline-capable applications.
+
+**Native CLI tool** (`dthk`) (beta): Compiled with GraalVM native-image for instant startup. Ships with file backend support, scriptable for quick queries and automation. Available in [releases](https://github.com/replikativ/datahike/releases). See [CLI documentation](./doc/cli.md).
+
+**Babashka pod** (beta): Native-compiled pod available in the [Babashka pod registry](https://github.com/babashka/pod-registry) for shell scripting. See [Babashka pod documentation](./doc/bb-pod.md).
+
+**Java API** (beta): Comprehensive bindings with fluent builder pattern and automatic collection conversion. See [Java API documentation](./doc/java-api.md) for the full API guide and [examples](./examples/java/).
+
+**libdatahike** (beta): *C/C++ native bindings* enable embedding Datahike in non-JVM applications. See [libdatahike documentation](./doc/libdatahike.md).
+
+**Python bindings** (beta): High-level Pythonic API with automatic EDN conversion. See [Python documentation](./pydatahike/README.md).
+
+## Production Use
+
+### Swedish Public Employment Service
+
+The [Swedish Public Employment Service](https://arbetsformedlingen.se) (Arbetsförmedlingen) has been using Datahike in production since 2024 to serve the [JobTech Taxonomy](https://gitlab.com/arbetsformedlingen/taxonomy-dev/backend/jobtech-taxonomy-api) (Arbetsmarknadstaxonomin) - a labour market terminology database with 40,000+ concepts representing occupations, skills, and education standards, accessed daily by thousands of case workers across Sweden.
+
+**Technical Highlights**:
+- **Scale**: 60+ schema attributes with multi-language support (Swedish, English)
+- **Architecture**: Multi-backend abstraction supporting both Datomic and Datahike
+- **API**: GraphQL interface with Apache Lucene full-text search
+- **Compliance**: Full transaction history for regulatory audit trail
+- **Resilience**: S3-based backup/restore for disaster recovery
+- **Migration**: Successfully migrated from Datomic after extensive testing (U1 → I1 → Production)
+
+**Resources**:
+- **Source Code**: [jobtech-taxonomy-api](https://gitlab.com/arbetsformedlingen/taxonomy-dev/backend/jobtech-taxonomy-api) (2,851+ commits)
+- **Benchmarks**: [Performance comparison suite](https://gitlab.com/arbetsformedlingen/taxonomy-dev/backend/experimental/datahike-benchmark) (Datahike vs Datomic)
+- **Migration Story**: [Plan.md](https://gitlab.com/arbetsformedlingen/taxonomy-dev/backend/jobtech-taxonomy-api/-/blob/develop/test/datahike/Plan.md) - detailed deployment journey
+
+This represents one of the most comprehensive open-source Datahike deployments, demonstrating production-readiness at government scale.
+
+### Stub - Accounting for African Entrepreneurs
+
+[Stub](https://stub.africa/) is a comprehensive accounting and invoicing platform serving 5,000+ small businesses across South Africa. Built by [Alexander Oloo](https://github.com/alekcz) with Datahike powering the core data layer.
+
+**Features**: Invoicing with payment integration, double-entry bookkeeping, bank sync (Capitec, FNB, Absa, Nedbank), VAT tracking, inventory management, and financial reporting.
+
+### Heidelberg University - Emotion Tracking
+
+Heidelberg University uses Datahike in an internal emotion tracking application for psychological research (source not publicly available).
+
+## Proximum: Vector Search for Datahike
+
+[Proximum](https://datahike.io/proximum) is a high-performance HNSW vector index designed for Datahike's persistent data model. It brings semantic search and RAG capabilities to Datahike while maintaining immutability and full audit history.
+
+**Key features**:
+- Fast HNSW (Hierarchical Navigable Small World) vector search
+- Immutable index snapshots—same git-like semantics as Datahike
+- Persistent data structures without mutation or locks
+- Dual-licensed: EPL-2.0 (open source) and commercial license
+
+See [datahike.io/proximum](https://datahike.io/proximum) for details. Integration as secondary index into Datahike coming soon.
+
+## Composable Ecosystem
+
+Datahike is **compositional by design**—built from independent, reusable libraries that work together but can be used separately in your own systems. Each component is open source and maintained as part of the [replikativ](https://github.com/replikativ) project.
+
+**Core libraries:**
+- **[konserve](https://github.com/replikativ/konserve)**: Pluggable key-value store abstraction with backends for File, LMDB, S3, JDBC, Redis, IndexedDB, and more. Use it for any persistent storage needs beyond Datahike.
+- **[kabel](https://github.com/replikativ/kabel)**: WebSocket transport with middleware support. Build real-time communication layers for any application.
+- **[hasch](https://github.com/replikativ/hasch)**: Content-addressable hashing for Clojure data structures. Create immutable references to data.
+- **[incognito](https://github.com/replikativ/incognito)**: Extensible serialization for custom types. Serialize any Clojure data across networks or storage.
+- **[superv.async](https://github.com/replikativ/superv.async)**: Supervision and error handling for core.async. Build robust asynchronous systems.
+
+**Advanced:**
+- **[replikativ](https://github.com/replikativ/replikativ)**: CRDT-based data synchronization for eventually consistent systems. Build collaborative applications with automatic conflict resolution.
+- **[distributed-scope](https://github.com/simm-is/distributed-scope)**: Remote function invocation with Clojure semantics across processes.
+
+This modularity enables **custom solutions** across languages and runtimes: embed konserve in Python applications, use kabel for non-database real-time systems, or build entirely new databases on the same storage layer. Datahike demonstrates how these components work together, but you're not locked into our choices.
+
+## Roadmap and Participation
+
+Instead of providing a static roadmap, we work closely with the community to decide what will be worked on next in a dynamic and interactive way.
+
+**How it works:**
+
+Go to [GitHub Discussions](https://github.com/replikativ/datahike/discussions/categories/ideas) and upvote the _ideas_ you'd like to see in Datahike. When we have capacity for a new feature, we address the most upvoted items.
+
+You can also propose ideas yourself—either by adding them to Discussions or by creating a pull request. Note that due to backward compatibility considerations, some PRs may take time to integrate.
+
+
+## Commercial Support
+
+We are happy to provide commercial support. If you are interested in a particular
+feature, please contact us at [contact@datahike.io](mailto:contact@datahike.io).
+
+## License
+
+Copyright © 2014–2026 Christian Weilbach et al.
+
+Licensed under Eclipse Public License (see [LICENSE](LICENSE)).

package/bb/deps.edn

@@ -0,0 +1,9 @@
+{:paths ["src" "resources"]
+ :deps {org.babashka/spec.alpha {:git/url "https://github.com/babashka/spec.alpha"
+                                 :git/sha "644a7fc216e43d5da87b07471b0f87d874107d1a"}
+        ;; https://github.com/babashka/tools.bbuild
+        io.github.babashka/tools.bbuild {:git/sha "73e4d0a26c65cdf1d4c7bf7e9e46e6e5f1978a37"}
+        ;; https://github.com/borkdude/gh-release-artifact
+        io.github.borkdude/gh-release-artifact {:git/sha "05f8d8659e6805d513c59447ff41dc8497878462"}
+        selmer/selmer {:mvn/version "1.12.55"}
+        cheshire/cheshire {:mvn/version "5.13.0"}}}

package/bb/resources/github-fingerprints

@@ -0,0 +1,3 @@
+github.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOMqqnkVzrm0SdG6UOoqKLsabgH5C9okWi0dh2l9GKJl
+github.com ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBEmKSENjQEezOmxkZMy7opKgwFB9nkt5YRrYMjNuG5N87uRgg6CLrbo5wAdT/y6v0mKV0U2w0WZ2YB/++Tpockg=
+github.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCj7ndNxQowgcQnjshcLrqPEiiphnt+VTTvDP6mHBL9j1aNUkY4Ue1gvwnGLVlOhGeYrnZaMgRK6+PKCUXaDbC7qtbW8gIkhL7aGCsOr/C56SJMy/BCZfxd1nWzAOxSDPgVsmerOBYfNqltV9/hWCqBywINIR+5dIg6JTJ72pcEpEjcYgXkE2YEFXV1JHnsKgbLWNlhScqb2UmyRkQyytRLtL+38TGxkxCflmO+5Z8CSSNY7GidjMIZ7Q4zMjA2n1nGrlTDkzwDCsw+wqFPGQA179cnfGWOWRVruj16z6XyvxvjJwbz0wQZ75XK5tKSb7FNyeIEs4TT4jk+S4dhPeAUC5y+bDYirYgM4GC7uEnztnZyaVWQ7B381AK4Qdrwt51ZqExKbQpTUNn+EjqoTwvqNj4kqx5QUCI0ThS/YkOxJCXmPUWZbhjpCg56i+2aB6CmK2JGhn57K5mj0MNdBXA4/WnwH6XoPWJzK5Nyu2zB3nAZp+S5hpQs+p1vN1/wsjk=

package/bb/resources/native-image-tests/run-bb-pod-tests.clj

@@ -0,0 +1,162 @@
+#!/usr/bin/env bb
+
+(require '[babashka.pods :as pods]
+         '[clojure.test :refer [run-tests deftest testing is]])
+(import '[java.util Date])
+
+(pods/load-pod "./dthk")
+
+(require '[datahike.pod :as d])
+
+(def config {:keep-history? true,
+             :search-cache-size 10000,
+             :index :datahike.index/persistent-set,
+             :store {:id #uuid "550e8400-e29b-41d4-a716-446655440763", :backend :memory :scope "test.datahike.io"},
+             :store-cache-size 1000,
+             :attribute-refs? false,
+             :writer {:backend :self},
+             :crypto-hash? false,
+             :schema-flexibility :read,
+             :branch :db})
+
+(deftest pod-workflow
+
+  (testing "delete-database"
+    (is (= nil
+           (d/delete-database config))))
+
+  (testing "create-database"
+    (is (= {:keep-history? true
+            :search-cache-size 10000
+            :index :datahike.index/persistent-set
+            :store {:id #uuid "550e8400-e29b-41d4-a716-446655440763", :backend :memory :scope "test.datahike.io"}
+            :store-cache-size 1000
+            :attribute-refs? false
+            :writer {:backend :self}
+            :crypto-hash? false
+            :schema-flexibility :read
+            :branch :db}
+           (d/create-database config))))
+
+  (testing "database-exists?"
+    (is (= true
+           (d/database-exists? config))))
+
+  (let [conn (d/connect config)]
+    (testing "connect"
+      (is (string? conn))
+      (is (clojure.string/starts-with? conn "conn:")))
+    (testing "transact"
+      (is (= [:tempids :db-before :db-after :tx-meta :tx-data]
+             (keys (d/transact conn [{:name  "Alice", :age   20}
+                                     {:name  "Bob", :age   30}
+                                     {:name  "Charlie", :age   40}
+                                     {:age 15}])))))
+    ; (testing "transact with bad arg"
+    ;   (is (thrown? clojure.lang.ExceptionInfo
+    ;                (keys (d/transact
+    ;                       "foo"
+    ;                       [{:name  "Alice", :age   20}
+    ;                        {:name  "Bob", :age   30}
+    ;                        {:name  "Charlie", :age   40}
+    ;                        {:age 15}])))))
+    (testing "with-db"
+      (is (= #{[2 "Bob" 30] [1 "Alice" 20] [3 "Charlie" 40]}
+             (d/with-db [db (d/db conn)]
+               (d/q {:query '{:find [?e ?n ?a]
+                              :where
+                              [[?e :name ?n]
+                               [?e :age ?a]]}
+                     :args [(d/db conn)]})))))
+    (testing "release-db"
+      (let [db (d/db conn)]
+        (is (= {}
+               (d/release-db db)))))
+    (testing "q"
+      (is (= #{[2 "Bob" 30] [1 "Alice" 20] [3 "Charlie" 40]}
+             (d/q {:query '{:find [?e ?n ?a]
+                            :where
+                            [[?e :name ?n]
+                             [?e :age ?a]]}
+                   :args [(d/db conn)]})
+             (d/q '[:find ?e ?n ?a
+                    :where
+                    [?e :name ?n]
+                    [?e :age ?a]]
+                  (d/db conn)))))
+    (let [timestamp (Date.)]
+      (Thread/sleep 1)
+      (d/transact conn {:tx-data [{:db/id 3 :age 25}]})
+      (d/transact conn [{:name "FOO"  :age "BAR"}])
+      (testing "pull"
+        (is (= {:db/id 1, :age 20, :name "Alice"}
+               (d/pull (d/db conn) '[*] 1))))
+      (testing "pull-many"
+        (is (= [{:db/id 1, :age 20, :name "Alice"}
+                {:db/id 2, :age 30, :name "Bob"}
+                {:db/id 3, :age 25, :name "Charlie"}]
+               (d/pull-many (d/db conn) '[*] [1 2 3]))))
+      (testing "metrics"
+        (is (= {:per-attr-counts {:age 5, :name 4, :db/txInstant 3}
+                :per-entity-counts {1 2, 2 2, 3 2, 4 1, 5 2, 536870913 1, 536870914 1, 536870915 1}
+                :count 12, :avet-count 0, :temporal-count 11, :temporal-avet-count 0}
+               (d/metrics (d/db conn)))))
+      (testing "as-of tx-id"
+        (is (= #{[3 "Charlie" 25] [2 "Bob" 30] [5 "FOO" "BAR"] [1 "Alice" 20]}
+               (d/q '[:find ?e ?n ?a
+                      :where
+                      [?e :name ?n]
+                      [?e :age ?a]]
+                    (d/as-of (d/db conn) 536870916)))))
+      (testing "as-of timestamp"
+        (is (= #{[2 "Bob" 30] [1 "Alice" 20] [3 "Charlie" 40]}
+               (d/q '[:find ?e ?n ?a
+                      :where
+                      [?e :name ?n]
+                      [?e :age ?a]]
+                    (d/as-of (d/db conn) timestamp)))))
+      (testing "since tx-id"
+        (is (= #{[5 "FOO" "BAR"]}
+               (d/q '[:find ?e ?n ?a
+                      :where
+                      [?e :name ?n]
+                      [?e :age ?a]]
+                    (d/since (d/db conn) 536870914)))))
+      (testing "since timestamp"
+        (is (= #{[5 "FOO" "BAR"]}
+               (d/q '[:find ?e ?n ?a
+                      :where
+                      [?e :name ?n]
+                      [?e :age ?a]]
+                    (d/since (d/db conn) timestamp)))))
+      (testing "history"
+        (is (= #{[3 "Charlie" 25] [2 "Bob" 30] [5 "FOO" "BAR"] [1 "Alice" 20] [3 "Charlie" 40]}
+               (d/q '[:find ?e ?n ?a
+                      :where
+                      [?e :name ?n]
+                      [?e :age ?a]]
+                    (d/history (d/db conn))))))
+      (testing "datoms"
+        (is (= '((1 :age 20 536870913 true))
+               (d/datoms (d/db conn) :eavt 1 :age 20)))
+        (is (= '((2 :age 30 536870913 true) (2 :name "Bob" 536870913 true))
+               (d/datoms (d/db conn) {:index :eavt :components [2]}))))
+      (testing "schema"
+        (d/transact conn {:tx-data [{:db/ident :name :db/valueType :db.type/string :db/unique :db.unique/identity
+                                     :db/index true :db/cardinality :db.cardinality/one}
+                                    {:db/ident :age :db/valueType :db.type/long :db/cardinality :db.cardinality/one}]})
+        (is (= {:name {:db/ident :name, :db/valueType :db.type/string, :db/unique :db.unique/identity
+                       :db/index true, :db/cardinality :db.cardinality/one, :db/id 6}
+                :age {:db/ident :age, :db/valueType :db.type/long, :db/cardinality :db.cardinality/one, :db/id 7}}
+               (d/schema (d/db conn))))
+        (testing "entity"
+          (is (= {:age "BAR" :name "FOO"}
+                 (d/entity (d/db conn) 5))))))))
+
+(defn -main [& _args]
+  (let [{:keys [fail error]} (run-tests)]
+    (when (and fail error (pos? (+ fail error)))
+      (System/exit 1))))
+
+(when (= *file* (System/getProperty "babashka.file"))
+  (apply -main *command-line-args*))

package/bb/resources/native-image-tests/run-libdatahike-tests

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o pipefail
+set -o nounset
+
+export LD_LIBRARY_PATH=./libdatahike/target
+export DYLD_LIBRARY_PATH=./libdatahike/target
+
+rm -rf "/tmp/libdatahike-test"
+./libdatahike/compile-cpp
+./libdatahike/target/test_cpp

package/bb/resources/native-image-tests/run-native-image-tests

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+set -o errexit
+set -o pipefail
+
+TMPSTORE=/tmp/dh-test-store
+CONFIG=bb/resources/native-image-tests/testconfig.edn
+ATTR_REF_CONFIG=bb/resources/native-image-tests/testconfig.attr-refs.edn
+
+trap "rm -rf $TMPSTORE" EXIT
+
+./dthk delete-database edn:$ATTR_REF_CONFIG
+./dthk create-database edn:$ATTR_REF_CONFIG
+
+./dthk database-exists edn:$ATTR_REF_CONFIG
+
+# test that warnings etc. get logged to stderr
+LOG_OUTPUT="$(./dthk query '[:find ?e . :where [?e :nonexistent _]]' db:$ATTR_REF_CONFIG 2>&1 >/dev/null | grep ':nonexistent has not been found')"
+if [ -z "$LOG_OUTPUT" ]
+then
+  echo "Exception: binary did not log to stderr"
+  exit 1
+fi
+
+./dthk delete-database edn:$CONFIG
+./dthk create-database edn:$CONFIG
+
+./dthk database-exists edn:$CONFIG
+
+# Add test data with tx transact (benchmark command no longer available)
+for i in {1..100}; do
+  ./dthk transact conn:$CONFIG "[[:db/add -$i :name \"User-$i\"]]"
+done
+./dthk transact conn:$CONFIG '[[:db/add -1 :name "Judea"]]'
+QUERY_OUT=`./dthk query '[:find (count ?e) . :where [?e :name _]]' db:$CONFIG`
+
+if [ $QUERY_OUT -eq 101 ]
+then
+  echo "Test successful."
+else
+  echo "Exception: Query did not return correct value."
+  exit 1
+fi
+
+# test history input parsing
+./dthk query '[:find (count ?e) . :where [?e :name _]]' history:$CONFIG
+./dthk query '[:find (count ?e) . :where [?e :name _]]' since:0:$CONFIG
+./dthk query '[:find (count ?e) . :where [?e :name _]]' asof:0:$CONFIG
+
+# other calls
+./dthk pull db:$CONFIG "[:db/id, :name]" "1"
+./dthk pull-many db:$CONFIG "[:db/id, :name]" "[1]"
+./dthk entity db:$CONFIG "1"
+./dthk datoms db:$CONFIG "{:index :eavt :components [1]}"
+./dthk schema db:$CONFIG
+./dthk reverse-schema db:$CONFIG
+./dthk metrics db:$CONFIG
+
+# test serialization
+./dthk query '[:find ?e . :where [?e :name ?n]]' db:$CONFIG --format cbor >> /tmp/test
+./dthk query '[:find ?i :in $ ?i . :where [?e :name ?n]]' db:$CONFIG cbor:/tmp/test # => 1
+
+# test arbitrary :in[puts] as positional args
+QUERY_OUT=`./dthk query '[:find (pull ?e [*]) . :in $ ?name :where [?e :name ?name]]' db:$CONFIG '"Judea"'`
+if [ "$QUERY_OUT" = '{:db/id 101, :name "Judea"}' ]
+then
+  echo "Positional input test successful."
+else
+  echo "Exception: Query did not return correct value."
+  exit 1
+fi
+
+./dthk delete-database edn:$CONFIG
+./dthk delete-database edn:$ATTR_REF_CONFIG

package/bb/resources/native-image-tests/run-python-tests

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o pipefail
+set -o nounset
+
+echo "Setting up Python test environment..."
+
+# Set library paths so Python can find libdatahike.so
+export LD_LIBRARY_PATH=./libdatahike/target
+export DYLD_LIBRARY_PATH=./libdatahike/target
+
+# Install pytest (use pip3 explicitly to avoid Python 2.7)
+echo "Installing pytest..."
+pip3 install --user pytest
+
+# Run Python tests using python3 -m pytest to avoid PATH issues
+echo "Running Python tests..."
+cd pydatahike
+python3 -m pytest -v tests/
+
+echo "Python tests completed successfully!"

package/bb/resources/native-image-tests/testconfig.attr-refs.edn

@@ -0,0 +1,6 @@
+{:store  {:backend :file
+          :path "/tmp/dh-test-store"
+          :id #uuid "650e8400-e29b-41d4-a716-446655440001"}
+ :keep-history? true
+ :attribute-refs? true
+ :schema-flexibility :write}

package/bb/resources/native-image-tests/testconfig.edn

@@ -0,0 +1,5 @@
+{:store  {:backend :file
+          :path "/tmp/dh-test-store"
+          :id #uuid "550e8400-e29b-41d4-a716-446655440000"}
+ :keep-history? true
+ :schema-flexibility :read}

package/bb/resources/template/.settings/org.eclipse.jdt.apt.core.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.apt.aptEnabled=false

package/bb/resources/template/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,9 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
+org.eclipse.jdt.core.compiler.processAnnotations=disabled
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=1.8

package/bb/resources/template/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

package/bb/resources/template/pom.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <version>0.0.0</version>
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.replikativ</groupId>
+  <artifactId>datahike</artifactId>
+  <packaging>jar</packaging>
+  <name>datahike</name>
+  <description>A durable datalog implementation adaptable for distribution.</description>
+  <url>https://datahike.io</url>
+  <licenses>
+    <license>
+      <name>Eclipse</name>
+      <url>http://www.eclipse.org/legal/epl-v10.html</url>
+    </license>
+  </licenses>
+  <scm>
+    <connection>scm:git:git@github.com:replikativ/datahike.git</connection>
+    <developerConnection>scm:git:git@github.com/replikativ/datahike.git</developerConnection>
+    <url>https://github.com/replikativ/datahike</url>
+  </scm>
+</project>