datahike-browser-tests 1.0.0

package/pydatahike/tests/test_edn_conversion.py

@@ -0,0 +1,299 @@
+"""Tests for EDN conversion rules.
+
+Tests the universal Python → EDN conversion that follows the rules:
+- Keys: always keywordized
+- Values: : prefix = keyword, else literal
+- Escape: \\: for literal colon strings
+"""
+import pytest
+from datahike.database import _key_to_keyword, _value_to_edn, _dict_to_edn, _python_to_edn
+from datahike import edn, kw
+
+
+class TestKeyConversion:
+    """Test key → keyword conversion."""
+
+    def test_simple_key(self):
+        assert _key_to_keyword("name") == ":name"
+
+    def test_namespaced_key(self):
+        assert _key_to_keyword("person/name") == ":person/name"
+
+    def test_key_with_leading_colon(self):
+        # Leading : is stripped (convenience)
+        assert _key_to_keyword(":db/id") == ":db/id"
+
+    def test_key_with_question_mark(self):
+        assert _key_to_keyword("keep-history?") == ":keep-history?"
+
+    def test_key_with_dash(self):
+        assert _key_to_keyword("schema-flexibility") == ":schema-flexibility"
+
+
+class TestValueConversion:
+    """Test value conversion rules."""
+
+    def test_string_without_colon(self):
+        assert _value_to_edn("Alice") == '"Alice"'
+
+    def test_string_with_colon_prefix(self):
+        # : prefix → keyword
+        assert _value_to_edn(":active") == ":active"
+
+    def test_string_with_escaped_colon(self):
+        # \\: → literal string with :
+        assert _value_to_edn("\\:literal") == '":literal"'
+
+    def test_string_with_quotes(self):
+        # Quotes should be escaped
+        assert _value_to_edn('say "hello"') == '"say \\"hello\\""'
+
+    def test_integer(self):
+        assert _value_to_edn(42) == "42"
+
+    def test_float(self):
+        assert _value_to_edn(3.14) == "3.14"
+
+    def test_boolean_true(self):
+        assert _value_to_edn(True) == "true"
+
+    def test_boolean_false(self):
+        assert _value_to_edn(False) == "false"
+
+    def test_none(self):
+        assert _value_to_edn(None) == "nil"
+
+    def test_list(self):
+        assert _value_to_edn([1, 2, 3]) == "[1 2 3]"
+
+    def test_nested_list(self):
+        assert _value_to_edn([1, [2, 3]]) == "[1 [2 3]]"
+
+    def test_nested_dict(self):
+        result = _value_to_edn({"a": 1})
+        assert result == "{:a 1}"
+
+
+class TestDictConversion:
+    """Test dict → EDN map conversion."""
+
+    def test_simple_dict(self):
+        assert _dict_to_edn({"name": "Alice"}) == '{:name "Alice"}'
+
+    def test_dict_with_keyword_value(self):
+        assert _dict_to_edn({"status": ":active"}) == '{:status :active}'
+
+    def test_dict_with_multiple_keys(self):
+        result = _dict_to_edn({"name": "Alice", "age": 30})
+        # Dict order might vary, check both possibilities
+        assert result in [
+            '{:name "Alice" :age 30}',
+            '{:age 30 :name "Alice"}'
+        ]
+
+    def test_nested_dict(self):
+        result = _dict_to_edn({
+            "store": {
+                "backend": ":mem",
+                "id": "test"
+            }
+        })
+        assert ":store" in result
+        assert ":backend :mem" in result
+        assert ':id "test"' in result
+
+
+class TestCompleteConversion:
+    """Test complete Python → EDN conversion."""
+
+    def test_config_conversion(self):
+        config = {
+            "store": {
+                "backend": ":mem",
+                "id": "test"
+            },
+            "schema-flexibility": ":read",
+            "keep-history?": True
+        }
+        edn = _python_to_edn(config)
+
+        assert ":store" in edn
+        assert ":backend :mem" in edn
+        assert ':id "test"' in edn
+        assert ":schema-flexibility :read" in edn
+        assert ":keep-history? true" in edn
+
+    def test_transaction_data(self):
+        data = [
+            {"name": "Alice", "status": ":active"},
+            {"name": "Bob", "status": ":inactive"}
+        ]
+        edn = _python_to_edn(data)
+
+        assert ':name "Alice"' in edn
+        assert ":status :active" in edn
+        assert ':name "Bob"' in edn
+        assert ":status :inactive" in edn
+
+    def test_schema_transaction(self):
+        schema = [{
+            "db/ident": ":person/name",
+            "db/valueType": ":db.type/string",
+            "db/cardinality": ":db.cardinality/one"
+        }]
+        edn = _python_to_edn(schema)
+
+        assert ":db/ident :person/name" in edn
+        assert ":db/valueType :db.type/string" in edn
+        assert ":db/cardinality :db.cardinality/one" in edn
+
+
+class TestEDNHelpers:
+    """Test explicit EDN type helpers."""
+
+    def test_keyword_simple(self):
+        kw = edn.keyword("name")
+        assert kw.to_edn() == ":name"
+
+    def test_keyword_namespaced(self):
+        kw = edn.keyword("name", "person")
+        assert kw.to_edn() == ":person/name"
+
+    def test_symbol(self):
+        sym = edn.symbol("my-fn")
+        assert sym.to_edn() == "my-fn"
+
+    def test_symbol_namespaced(self):
+        sym = edn.symbol("assoc", "clojure.core")
+        assert sym.to_edn() == "clojure.core/assoc"
+
+    def test_uuid(self):
+        u = edn.uuid("550e8400-e29b-41d4-a716-446655440000")
+        assert u.to_edn() == '#uuid "550e8400-e29b-41d4-a716-446655440000"'
+
+    def test_inst(self):
+        i = edn.inst("2024-01-01T00:00:00Z")
+        assert i.to_edn() == '#inst "2024-01-01T00:00:00Z"'
+
+    def test_forced_string(self):
+        s = edn.string(":literal")
+        assert s.startswith("<STRING>")
+        # When converted to EDN, should be quoted string
+        assert _value_to_edn(s) == '":literal"'
+
+    def test_keyword_in_dict(self):
+        data = {
+            "db/ident": edn.keyword("person/name"),
+            "db/valueType": kw.STRING
+        }
+        result = _python_to_edn(data)
+
+        assert ":db/ident :person/name" in result
+        assert ":db/valueType :db.type/string" in result
+
+
+class TestKeywordConstants:
+    """Test pre-defined keyword constants."""
+
+    def test_db_id(self):
+        assert kw.DB_ID == ":db/id"
+
+    def test_db_ident(self):
+        assert kw.DB_IDENT == ":db/ident"
+
+    def test_value_types(self):
+        assert kw.STRING == ":db.type/string"
+        assert kw.LONG == ":db.type/long"
+        assert kw.BOOLEAN == ":db.type/boolean"
+        assert kw.REF == ":db.type/ref"
+
+    def test_cardinality(self):
+        assert kw.ONE == ":db.cardinality/one"
+        assert kw.MANY == ":db.cardinality/many"
+
+    def test_unique(self):
+        assert kw.UNIQUE_VALUE == ":db.unique/value"
+        assert kw.UNIQUE_IDENTITY == ":db.unique/identity"
+
+    def test_schema_flexibility(self):
+        assert kw.SCHEMA_READ == ":read"
+        assert kw.SCHEMA_WRITE == ":write"
+
+
+class TestEdgeCases:
+    """Test edge cases and special scenarios."""
+
+    def test_empty_dict(self):
+        assert _dict_to_edn({}) == "{}"
+
+    def test_empty_list(self):
+        assert _value_to_edn([]) == "[]"
+
+    def test_deeply_nested(self):
+        data = {
+            "a": {
+                "b": {
+                    "c": {
+                        "d": "value"
+                    }
+                }
+            }
+        }
+        edn = _python_to_edn(data)
+        assert ":a" in edn
+        assert ":b" in edn
+        assert ":c" in edn
+        assert ":d" in edn
+        assert '"value"' in edn
+
+    def test_list_of_dicts(self):
+        data = [
+            {"name": "Alice"},
+            {"name": "Bob"}
+        ]
+        edn = _python_to_edn(data)
+        assert '[' in edn
+        assert '{:name "Alice"}' in edn
+        assert '{:name "Bob"}' in edn
+
+    def test_dict_with_list_value(self):
+        data = {"tags": [":important", ":verified"]}
+        edn = _python_to_edn(data)
+        assert ":tags" in edn
+        assert ":important" in edn
+        assert ":verified" in edn
+
+    def test_string_with_slash(self):
+        # Slash in regular string should be preserved
+        result = _value_to_edn("path/to/file")
+        assert result == '"path/to/file"'
+
+    def test_string_with_backslash(self):
+        # Backslash should be escaped
+        result = _value_to_edn("C:\\path\\to\\file")
+        assert result == '"C:\\\\path\\\\to\\\\file"'
+
+
+class TestCustomBackendScenario:
+    """Test conversion for custom backend configurations."""
+
+    def test_custom_s3_backend(self):
+        config = {
+            "store": {
+                "backend": ":my-s3",
+                "bucket": "my-bucket",
+                "region": "us-west-2",
+                "encryption": {
+                    "type": ":aes256",
+                    "key-id": "secret"
+                }
+            }
+        }
+        edn = _python_to_edn(config)
+
+        assert ":backend :my-s3" in edn
+        assert ':bucket "my-bucket"' in edn
+        assert ':region "us-west-2"' in edn
+        assert ":encryption" in edn
+        assert ":type :aes256" in edn
+        assert ':key-id "secret"' in edn

package/pydatahike/tests/test_query.py

@@ -0,0 +1,99 @@
+"""Tests for query and data retrieval operations."""
+import json
+import pytest
+from datahike import (
+    create_database,
+    delete_database,
+    transact,
+    q,
+    pull,
+    database,
+)
+
+
+def test_transact_and_query_json(mem_config_flexible):
+    """Test transact and query with JSON format."""
+    with database(mem_config_flexible) as cfg:
+        # Transact data using JSON format
+        tx_data = json.dumps([
+            {"name": "Alice", "age": 30},
+            {"name": "Bob", "age": 25}
+        ])
+        result = transact(cfg, tx_data, input_format='json')
+        assert result is not None
+
+        # Query for Alice
+        query_result = q(
+            '[:find ?e ?name :where [?e :name ?name] [?e :name "Alice"]]',
+            [('db', cfg)],
+            output_format='json'
+        )
+        assert len(query_result) > 0
+
+
+def test_pull_entity(mem_config_flexible):
+    """Test pull API to retrieve entity."""
+    with database(mem_config_flexible) as cfg:
+        # Transact data
+        tx_data = json.dumps([{"name": "Alice", "age": 30}])
+        transact(cfg, tx_data, input_format='json')
+
+        # Query to get entity ID
+        query_result = q(
+            '[:find ?e ?name :where [?e :name ?name] [?e :name "Alice"]]',
+            [('db', cfg)],
+            output_format='json'
+        )
+
+        # Extract entity ID from result
+        actual_results = query_result[1] if query_result[0] == '!set' else query_result
+        entity_id = actual_results[0][0]
+
+        # Pull entity
+        entity = pull(cfg, '[*]', entity_id, output_format='json')
+        assert entity.get('name') == 'Alice' or entity.get(':name') == 'Alice'
+
+
+def test_query_with_multiple_results(mem_config_flexible):
+    """Test query returning multiple results."""
+    with database(mem_config_flexible) as cfg:
+        # Transact multiple entities
+        tx_data = json.dumps([
+            {"name": "Alice", "age": 30},
+            {"name": "Bob", "age": 25},
+            {"name": "Charlie", "age": 35}
+        ])
+        transact(cfg, tx_data, input_format='json')
+
+        # Query all names
+        query_result = q(
+            '[:find ?name :where [?e :name ?name]]',
+            [('db', cfg)],
+            output_format='json'
+        )
+
+        # Should have 3 results
+        actual_results = query_result[1] if query_result[0] == '!set' else query_result
+        assert len(actual_results) == 3
+
+
+def test_query_with_parameters(mem_config_flexible):
+    """Test query with input parameters."""
+    with database(mem_config_flexible) as cfg:
+        # Transact data
+        tx_data = json.dumps([
+            {"name": "Alice", "age": 30},
+            {"name": "Bob", "age": 25}
+        ])
+        transact(cfg, tx_data, input_format='json')
+
+        # Query with parameter
+        query_result = q(
+            '[:find ?e :in $ ?name :where [?e :name ?name]]',
+            [('db', cfg), ('param', '"Alice"')],
+            output_format='json'
+        )
+
+        # Should find Alice
+        actual_results = query_result[1] if query_result[0] == '!set' else query_result
+        assert len(actual_results) > 0

package/pydatahike/tests/test_schema.py

@@ -0,0 +1,55 @@
+"""Tests for schema operations."""
+import pytest
+from datahike import (
+    transact,
+    schema,
+    q,
+    database,
+)
+
+
+def test_explicit_schema(mem_config):
+    """Test transact and query with explicit schema."""
+    with database(mem_config) as cfg:
+        # Transact schema using EDN format
+        schema_tx = '''[
+            {: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}
+        ]'''
+        transact(cfg, schema_tx, input_format='edn')
+
+        # Check schema was added
+        db_schema = schema(cfg, output_format='json')
+        assert db_schema is not None
+
+        # Transact data using EDN
+        tx_data = '[{:name "Charlie" :age 35} {:name "Diana" :age 28}]'
+        transact(cfg, tx_data, input_format='edn')
+
+        # Query
+        query_result = q(
+            '[:find ?e ?name ?age :where [?e :name ?name] [?e :age ?age]]',
+            [('db', cfg)],
+            output_format='json'
+        )
+        actual_results = query_result[1] if query_result[0] == '!set' else query_result
+        assert len(actual_results) == 2
+
+
+def test_schema_flexibility_read(mem_config_flexible):
+    """Test schema-flexibility :read allows dynamic attributes."""
+    with database(mem_config_flexible) as cfg:
+        # Transact data without predefined schema
+        tx_data = '[{:dynamic-attr "test" :another-attr 42}]'
+        transact(cfg, tx_data, input_format='edn')
+
+        # Query should work
+        query_result = q(
+            '[:find ?e ?val :where [?e :dynamic-attr ?val]]',
+            [('db', cfg)]
+        )
+        assert len(query_result) > 0

package/resources/clj-kondo.exports/io.replikativ/datahike/config.edn

@@ -0,0 +1,5 @@
+;; clj-kondo export configuration for Datahike
+;; AUTO-GENERATED from api-specification
+;; To regenerate: bb codegen-clj-kondo
+
+{:var-definitions {datahike.api {unlisten {:arglists (quote ([arg0 arg1])), :doc "Removes registered listener from connection."}, delete-database {:arglists (quote ([arg0] [])), :doc "Deletes a database given via configuration map."}, pull {:arglists (quote ([arg0 arg1] [arg0 arg1 arg2])), :doc "Fetches data using recursive declarative pull pattern."}, entity {:arglists (quote ([arg0 arg1])), :doc "Retrieves an entity by its id. Returns lazy map-like structure."}, metrics {:arglists (quote ([arg0])), :doc "Returns database metrics (datom counts, index sizes, etc)."}, reverse-schema {:arglists (quote ([arg0])), :doc "Returns reverse schema definition (attribute id to ident mapping)."}, datoms {:arglists (quote ([arg0 arg1] [arg0 arg1 arg2])), :doc "Index lookup. Returns sequence of datoms matching index components."}, load-entities {:arglists (quote ([arg0 arg1])), :doc "Load entities directly (bulk load)."}, is-filtered {:arglists (quote ([arg0])), :doc "Returns true if database was filtered using filter, false otherwise."}, q {:arglists (quote ([arg0] [arg0 arg1])), :doc "Executes a datalog query."}, schema {:arglists (quote ([arg0])), :doc "Returns current schema definition."}, index-range {:arglists (quote ([arg0 arg1])), :doc "Returns part of :avet index between start and end values."}, pull-many {:arglists (quote ([arg0 arg1] [arg0 arg1 arg2])), :doc "Same as pull, but accepts sequence of ids and returns sequence of maps."}, since {:arglists (quote ([arg0 arg1])), :doc "Returns database state since given time point (Date or transaction ID). Contains only datoms added since that point."}, query-stats {:arglists (quote ([arg0] [arg0 arg1])), :doc "Executes query and returns execution statistics."}, entity-db {:arglists (quote ([arg0])), :doc "Returns database that entity was created from."}, gc-storage {:arglists (quote ([arg0 arg1] [arg0])), :doc "Invokes garbage collection on connection's store. Removes old snapshots before given time point."}, create-database {:arglists (quote ([arg0] [])), :doc "Creates a database via configuration map."}, db {:arglists (quote ([arg0])), :doc "Returns the underlying immutable database value from a connection. Prefer using @conn directly."}, connect {:arglists (quote ([arg0] [arg0 arg1] [])), :doc "Connects to a Datahike database via configuration map."}, release {:arglists (quote ([arg0])), :doc "Releases a database connection."}, history {:arglists (quote ([arg0])), :doc "Returns full historical state of database including all assertions and retractions."}, transact! {:arglists (quote ([arg0 arg1])), :doc "Same as transact, but asynchronously returns a future."}, database-exists? {:arglists (quote ([arg0] [])), :doc "Checks if a database exists via configuration map."}, transact {:arglists (quote ([arg0 arg1])), :doc "Applies transaction to the database and updates connection."}, as-of {:arglists (quote ([arg0 arg1])), :doc "Returns database state at given time point (Date or transaction ID)."}, seek-datoms {:arglists (quote ([arg0 arg1] [arg0 arg1 arg2])), :doc "Like datoms, but returns datoms starting from specified components through end of index."}, filter {:arglists (quote ([arg0 arg1])), :doc "Returns filtered view over database. Only includes datoms where (pred db datom) is true."}, listen {:arglists (quote ([arg0 arg1] [arg0 arg1 arg2])), :doc "Listen for changes on connection. Callback called with transaction report on each transact."}, db-with {:arglists (quote ([arg0 arg1])), :doc "Applies transaction to immutable db value, returns new db. Same as (:db-after (with db tx-data))."}, with {:arglists (quote ([arg0 arg1] [arg0 arg1] [arg0 arg1 arg2])), :doc "Applies transaction to immutable db value. Returns transaction report."}, tempid {:arglists (quote ([arg0] [arg0 arg1])), :doc "Allocates temporary id (negative integer). Prefer using negative integers directly."}}}, :linters {:type-mismatch {:namespaces {datahike.api {unlisten {:arities {2 {:args [:any :any], :ret :any}}}, delete-database {:arities {1 {:args [:any], :ret :any}, 0 {:args [], :ret :any}}}, pull {:arities {2 {:args [:any :any], :ret :any}, 3 {:args [:any :vector :any], :ret :any}}}, entity {:arities {2 {:args [:any :any], :ret :any}}}, metrics {:arities {1 {:args [:any], :ret :any}}}, reverse-schema {:arities {1 {:args [:any], :ret :any}}}, datoms {:arities {2 {:args [:any :any], :ret :any}, 3 {:args [:any :keyword :any], :ret :any}}}, load-entities {:arities {2 {:args [:any :any], :ret :any}}}, is-filtered {:arities {1 {:args [:any], :ret :boolean}}}, q {:arities {1 {:args [:any], :ret :any}, 2 {:args [:any :any], :ret :any}}}, schema {:arities {1 {:args [:any], :ret :any}}}, index-range {:arities {2 {:args [:any :any], :ret :any}}}, pull-many {:arities {2 {:args [:any :any], :ret :seqable}, 3 {:args [:any :vector :any], :ret :seqable}}}, since {:arities {2 {:args [:any :any], :ret :any}}}, query-stats {:arities {1 {:args [:any], :ret :any}, 2 {:args [:any :any], :ret :any}}}, entity-db {:arities {1 {:args [:any], :ret :any}}}, gc-storage {:arities {2 {:args [:any :any], :ret :any}, 1 {:args [:any], :ret :any}}}, create-database {:arities {1 {:args [:any], :ret :any}, 0 {:args [], :ret :any}}}, db {:arities {1 {:args [:any], :ret :any}}}, connect {:arities {1 {:args [:any], :ret :any}, 2 {:args [:any :any], :ret :any}, 0 {:args [], :ret :any}}}, release {:arities {1 {:args [:any], :ret :nil}}}, history {:arities {1 {:args [:any], :ret :any}}}, transact! {:arities {2 {:args [:any :any], :ret :any}}}, database-exists? {:arities {1 {:args [:any], :ret :boolean}, 0 {:args [], :ret :boolean}}}, transact {:arities {2 {:args [:any :any], :ret :any}}}, as-of {:arities {2 {:args [:any :any], :ret :any}}}, seek-datoms {:arities {2 {:args [:any :any], :ret :any}, 3 {:args [:any :keyword :any], :ret :any}}}, filter {:arities {2 {:args [:any :any], :ret :any}}}, listen {:arities {2 {:args [:any :any], :ret :any}, 3 {:args [:any :any :any], :ret :any}}}, db-with {:arities {2 {:args [:any :any], :ret :any}}}, with {:arities {2 {:args [:any :any], :ret :any}, 3 {:args [:any :any :any], :ret :any}}}, tempid {:arities {1 {:args [:any], :ret :any}, 2 {:args [:any :int], :ret :int}}}}}}}}

package/resources/example_server.edn

@@ -0,0 +1,4 @@
+{:port     4444
+ :level    :debug
+ :dev-mode true
+ :token    "securerandompassword"}

package/shadow-cljs.edn

@@ -0,0 +1,56 @@
+{:deps {:aliases [:cljs :test]}
+ :src-paths ["src" "test"]
+ :dev-http {8022 "target/browser-integration-test"}
+ :builds {:repl
+          {:target :node-script
+           :output-to "target/out/repl.js"
+           :main shadow.cljs.devtools.cli
+           :compiler-options {:infer-externs true
+                              :warnings-as-errors false
+                              :warnings {:fn-deprecated false
+                                         :protocol-multiple-impls false}}}
+          :node-test
+          {:target :node-script
+           :output-to "target/out/node-test.js"
+           :main datahike.test.nodejs-test/-main
+           :compiler-options {:optimizations :advanced
+                              :infer-externs :auto
+                              :elide-asserts false}}
+
+          :browser-integration-test
+          {:target :browser-test
+           :test-dir "target/browser-integration-test"
+           :ns-regexp "datahike.kabel.browser-integration-test"
+           :compiler-options {:optimizations :advanced
+                              :infer-externs :auto
+                              :elide-asserts false
+                              :warnings-as-errors false
+                              :warnings {:fn-deprecated false}}}
+          
+          :browser-ci
+          {:target :karma
+           :output-to "target/browser-ci.js"
+           :ns-regexp "datahike.kabel.browser-integration-test"
+           :compiler-options {:optimizations :advanced
+                              :infer-externs :auto
+                              :elide-asserts false
+                              :warnings-as-errors false
+                              :warnings {:fn-deprecated false}}}
+          
+          :browser-release
+          {:target :browser
+           :output-to "npm-package/browser/datahike.js"
+           :output-dir "npm-package/browser"
+           :modules {:main {:entries [datahike.js.api]}}
+           :compiler-options {:optimizations :advanced
+                              :infer-externs :auto
+                              :output-feature-set :es2020}}
+          
+          :npm-release
+          {:target :npm-module
+           :output-dir "npm-package"
+           :entries [datahike.js.api
+                     konserve.node-filestore]
+           :compiler-options {:optimizations :advanced
+                              :infer-externs :auto
+                              :output-feature-set :es6}}}}

package/src/data_readers.clj

@@ -0,0 +1,7 @@
+{datahike/Datom        datahike.readers/datom-from-reader
+ datahike/DB           datahike.readers/db-from-reader
+ datahike/HistoricalDB datahike.readers/history-from-reader
+ datahike/SinceDB      datahike.readers/since-from-reader
+ datahike/AsOfDB       datahike.readers/as-of-from-reader
+ datahike/Connection   datahike.readers/connection-from-reader
+ db/id                 datahike.readers/tempid}