datahike-browser-tests 1.0.0

package/java/src/datahike/java/Keywords.java

@@ -0,0 +1,161 @@
+package datahike.java;
+
+import clojure.lang.Keyword;
+
+/**
+ * Pre-defined Datahike keyword constants.
+ *
+ * <p>Use these constants for common Datahike schema and transaction attributes
+ * to avoid typos and get IDE autocompletion.</p>
+ *
+ * <p>Example:</p>
+ * <pre>{@code
+ * import static datahike.java.Keywords.*;
+ * import static datahike.java.EDN.*;
+ *
+ * Map<String, Object> schema = Map.of(
+ *     DB_IDENT, keyword("person", "name"),
+ *     DB_VALUE_TYPE, STRING,
+ *     DB_CARDINALITY, ONE,
+ *     DB_DOC, "Person's full name"
+ * );
+ * }</pre>
+ */
+public class Keywords {
+
+    /**
+     * Forbids instance creation.
+     */
+    private Keywords() {}
+
+    // =========================================================================
+    // Entity Attributes
+    // =========================================================================
+
+    /** Entity ID: :db/id */
+    public static final Keyword DB_ID = Keyword.intern("db", "id");
+
+    /** Entity identifier: :db/ident */
+    public static final Keyword DB_IDENT = Keyword.intern("db", "ident");
+
+    // =========================================================================
+    // Schema Attributes
+    // =========================================================================
+
+    /** Value type: :db/valueType */
+    public static final Keyword DB_VALUE_TYPE = Keyword.intern("db", "valueType");
+
+    /** Cardinality: :db/cardinality */
+    public static final Keyword DB_CARDINALITY = Keyword.intern("db", "cardinality");
+
+    /** Documentation: :db/doc */
+    public static final Keyword DB_DOC = Keyword.intern("db", "doc");
+
+    /** Uniqueness constraint: :db/unique */
+    public static final Keyword DB_UNIQUE = Keyword.intern("db", "unique");
+
+    /** Component attribute: :db/isComponent */
+    public static final Keyword DB_IS_COMPONENT = Keyword.intern("db", "isComponent");
+
+    /** Disable history: :db/noHistory */
+    public static final Keyword DB_NO_HISTORY = Keyword.intern("db", "noHistory");
+
+    /** Index attribute: :db/index */
+    public static final Keyword DB_INDEX = Keyword.intern("db", "index");
+
+    /** Fulltext index: :db/fulltext */
+    public static final Keyword DB_FULLTEXT = Keyword.intern("db", "fulltext");
+
+    // =========================================================================
+    // Value Types
+    // =========================================================================
+
+    /** String type: :db.type/string */
+    public static final Keyword STRING = Keyword.intern("db.type", "string");
+
+    /** Boolean type: :db.type/boolean */
+    public static final Keyword BOOLEAN = Keyword.intern("db.type", "boolean");
+
+    /** Long type: :db.type/long */
+    public static final Keyword LONG = Keyword.intern("db.type", "long");
+
+    /** Big integer type: :db.type/bigint */
+    public static final Keyword BIGINT = Keyword.intern("db.type", "bigint");
+
+    /** Float type: :db.type/float */
+    public static final Keyword FLOAT = Keyword.intern("db.type", "float");
+
+    /** Double type: :db.type/double */
+    public static final Keyword DOUBLE = Keyword.intern("db.type", "double");
+
+    /** Big decimal type: :db.type/bigdec */
+    public static final Keyword BIGDEC = Keyword.intern("db.type", "bigdec");
+
+    /** Instant type: :db.type/instant */
+    public static final Keyword INSTANT = Keyword.intern("db.type", "instant");
+
+    /** UUID type: :db.type/uuid */
+    public static final Keyword UUID_TYPE = Keyword.intern("db.type", "uuid");
+
+    /** Keyword type: :db.type/keyword */
+    public static final Keyword KEYWORD_TYPE = Keyword.intern("db.type", "keyword");
+
+    /** Symbol type: :db.type/symbol */
+    public static final Keyword SYMBOL_TYPE = Keyword.intern("db.type", "symbol");
+
+    /** Reference type: :db.type/ref */
+    public static final Keyword REF = Keyword.intern("db.type", "ref");
+
+    /** Bytes type: :db.type/bytes */
+    public static final Keyword BYTES = Keyword.intern("db.type", "bytes");
+
+    // =========================================================================
+    // Cardinality Values
+    // =========================================================================
+
+    /** Cardinality one: :db.cardinality/one */
+    public static final Keyword ONE = Keyword.intern("db.cardinality", "one");
+
+    /** Cardinality many: :db.cardinality/many */
+    public static final Keyword MANY = Keyword.intern("db.cardinality", "many");
+
+    // =========================================================================
+    // Uniqueness Values
+    // =========================================================================
+
+    /** Unique value constraint: :db.unique/value */
+    public static final Keyword UNIQUE_VALUE = Keyword.intern("db.unique", "value");
+
+    /** Unique identity constraint: :db.unique/identity */
+    public static final Keyword UNIQUE_IDENTITY = Keyword.intern("db.unique", "identity");
+
+    // =========================================================================
+    // Transaction Metadata
+    // =========================================================================
+
+    /** Transaction entity: :db/tx */
+    public static final Keyword TX = Keyword.intern("db", "tx");
+
+    /** Transaction timestamp: :db/txInstant */
+    public static final Keyword TX_INSTANT = Keyword.intern("db", "txInstant");
+
+    // =========================================================================
+    // Schema Flexibility Values
+    // =========================================================================
+
+    /** Schema flexibility read mode: :read */
+    public static final Keyword SCHEMA_READ = Keyword.intern("read");
+
+    /** Schema flexibility write mode: :write */
+    public static final Keyword SCHEMA_WRITE = Keyword.intern("write");
+
+    // =========================================================================
+    // Storage Backends
+    // =========================================================================
+
+    /** Memory backend: :memory */
+    public static final Keyword BACKEND_MEMORY = Keyword.intern("memory");
+
+    /** File backend: :file */
+    public static final Keyword BACKEND_FILE = Keyword.intern("file");
+}

package/java/src/datahike/java/SchemaFlexibility.java

@@ -0,0 +1,52 @@
+package datahike.java;
+
+import clojure.lang.Keyword;
+
+/**
+ * Schema flexibility modes for Datahike databases.
+ *
+ * <p>Controls how the database handles attributes not defined in the schema:</p>
+ * <ul>
+ *   <li>{@link #READ} - Strict mode: Only allow reads of undefined attributes, reject writes</li>
+ *   <li>{@link #WRITE} - Flexible mode: Allow both reads and writes of undefined attributes</li>
+ * </ul>
+ *
+ * @see <a href="https://github.com/replikativ/datahike/blob/main/doc/schema.md">Schema Documentation</a>
+ */
+public enum SchemaFlexibility {
+    /**
+     * Read-only flexibility: Allow reading undefined attributes but reject writes.
+     * This is the recommended mode for production use with schemaless data.
+     */
+    READ(Keywords.SCHEMA_READ),
+
+    /**
+     * Write flexibility: Allow both reading and writing undefined attributes.
+     * Use this for fully schemaless databases or during prototyping.
+     */
+    WRITE(Keywords.SCHEMA_WRITE);
+
+    private final Keyword keyword;
+
+    SchemaFlexibility(Keyword keyword) {
+        this.keyword = keyword;
+    }
+
+    /**
+     * Returns the Clojure keyword representation.
+     *
+     * @return the keyword for this schema flexibility mode
+     */
+    public Keyword toKeyword() {
+        return keyword;
+    }
+
+    /**
+     * Returns the string representation suitable for EDN/config maps.
+     *
+     * @return the string representation (e.g., ":read", ":write")
+     */
+    public String toEDNString() {
+        return keyword.toString();
+    }
+}

package/java/src/datahike/java/Util.java

@@ -0,0 +1,219 @@
+package datahike.java;
+
+import clojure.java.api.Clojure;
+import clojure.lang.IFn;
+import clojure.lang.APersistentMap;
+import clojure.lang.APersistentVector;
+import clojure.lang.Keyword;
+import clojure.lang.RT;
+
+public class Util {
+    public  static final IFn derefFn = Clojure.var("clojure.core", "deref");
+    private static final IFn hashMapFn = Clojure.var("clojure.core", "hash-map");
+    private static final IFn vectorFn = Clojure.var("clojure.core", "vec");
+    private static final IFn readStringFn = Clojure.var("clojure.edn", "read-string");
+
+    /** Converts a keyword given as a string into a clojure keyword */
+    public static Keyword kwd(String str) {
+        return (Keyword)Clojure.read(str);
+    }
+
+    /** Creates a new clojure HashMap from the arguments of the form: key1, val1, key2, val2, ... */
+    public static APersistentMap map(Object... keyVals) {
+        Object[] converted = new Object[keyVals.length];
+        for (int i = 0; i < keyVals.length; i += 2) {
+            // Convert keys (always keywordize)
+            Object key = keyVals[i];
+            if (key instanceof String) {
+                String strKey = (String) key;
+                converted[i] = strKey.startsWith(":") ? kwd(strKey) : Keyword.intern(strKey);
+            } else {
+                converted[i] = key;
+            }
+
+            // Convert values (apply EDN rules)
+            if (i + 1 < keyVals.length) {
+                converted[i + 1] = convertValue(keyVals[i + 1]);
+            }
+        }
+        return (APersistentMap) hashMapFn.applyTo(RT.seq(converted));
+    }
+
+    /** Creates a new clojure vector with EDN conversion applied to items */
+    public static APersistentVector vec(Object... items) {
+        // Convert each item using EDN rules
+        Object[] converted = new Object[items.length];
+        for (int i = 0; i < items.length; i++) {
+            converted[i] = convertValue(items[i]);
+        }
+        return vecRaw(converted);
+    }
+
+    /** Creates a new clojure vector without conversion (internal use) */
+    private static APersistentVector vecRaw(Object... items) {
+        // No need to use 'applyTo here, as 'vectorFn taking a collection as an argument will produce a clj vector
+        // containing *each* of the collection elements.
+        return (APersistentVector) vectorFn.invoke(items);
+    }
+
+    /**
+     * Converts a value following universal EDN conversion rules:
+     * - String starting with ":" → keyword
+     * - String starting with "\\:" → literal string with ":" (escaped)
+     * - String without ":" → string
+     * - Numbers, booleans, null → as-is
+     * - Maps → recursively convert
+     * - Lists/Arrays → recursively convert
+     *
+     * This is public to allow reuse from Clojure interop layer.
+     */
+    public static Object convertValue(Object value) {
+        if (value == null) {
+            return null;
+        }
+
+        // Handle strings with EDN conversion rules
+        if (value instanceof String) {
+            String str = (String) value;
+
+            // Escaped colon - strip backslash and return as string
+            if (str.startsWith("\\:")) {
+                return str.substring(1);  // Return ":literal" from "\\:literal"
+            }
+
+            // Colon prefix - convert to keyword
+            if (str.startsWith(":")) {
+                return kwd(str);
+            }
+
+            // Regular string - return as-is
+            return str;
+        }
+
+        // Recursively convert nested maps
+        if (value instanceof java.util.Map && !(value instanceof APersistentMap)) {
+            return mapToPersistentMap((java.util.Map<String, Object>) value);
+        }
+
+        // Recursively convert lists/arrays
+        if (value instanceof java.util.List) {
+            java.util.List<?> list = (java.util.List<?>) value;
+            Object[] converted = new Object[list.size()];
+            for (int i = 0; i < list.size(); i++) {
+                converted[i] = convertValue(list.get(i));
+            }
+            return vecRaw(converted);
+        }
+
+        if (value instanceof Object[]) {
+            Object[] arr = (Object[]) value;
+            Object[] converted = new Object[arr.length];
+            for (int i = 0; i < arr.length; i++) {
+                converted[i] = convertValue(arr[i]);
+            }
+            return vecRaw(converted);
+        }
+
+        // Numbers, booleans, and other types - return as-is
+        return value;
+    }
+
+    /** Converts a Java Map to a Clojure persistent map */
+    public static APersistentMap mapToPersistentMap(java.util.Map<String, Object> javaMap) {
+        if (javaMap == null) {
+            return null;
+        }
+        Object[] keyVals = new Object[javaMap.size() * 2];
+        int i = 0;
+        for (java.util.Map.Entry<String, Object> entry : javaMap.entrySet()) {
+            Object key = entry.getKey();
+            // If key is already a Keyword, use it as-is
+            if (key instanceof Keyword) {
+                keyVals[i++] = key;
+            } else if (key instanceof String) {
+                String strKey = (String) key;
+                // Convert string keys to keywords (auto-prefix with : if not present)
+                keyVals[i++] = strKey.startsWith(":") ? kwd(strKey) : Keyword.intern(strKey);
+            } else {
+                // Use key as-is for other types
+                keyVals[i++] = key;
+            }
+
+            // Convert values using universal EDN rules
+            keyVals[i++] = convertValue(entry.getValue());
+        }
+        return (APersistentMap) hashMapFn.applyTo(RT.seq(keyVals));
+    }
+
+    /**
+     * Convert Clojure persistent map to Java HashMap.
+     * Used for return values that need to be Java-friendly.
+     *
+     * @param clojureMap Clojure persistent map
+     * @return Java HashMap with string keys
+     */
+    public static java.util.Map<String, Object> clojureMapToJavaMap(APersistentMap clojureMap) {
+        if (clojureMap == null) {
+            return null;
+        }
+        java.util.Map<String, Object> javaMap = new java.util.HashMap<>();
+        for (Object entry : clojureMap) {
+            java.util.Map.Entry<?, ?> e = (java.util.Map.Entry<?, ?>) entry;
+            String key = e.getKey().toString();
+            javaMap.put(key, e.getValue());
+        }
+        return javaMap;
+    }
+
+    /**
+     * Normalize Java collections to Clojure collections for API processing.
+     *
+     * <p><b>Escape hatch (automatic):</b> If data is already a Clojure persistent
+     * collection, returns immediately with O(1) instanceof check. Advanced users
+     * can use {@link #vec} and {@link #map} for zero-overhead calls.</p>
+     *
+     * <p><b>Conversion rules (applied recursively):</b></p>
+     * <ul>
+     *   <li>java.util.List → clojure.lang.PersistentVector</li>
+     *   <li>java.util.Map → clojure.lang.PersistentHashMap</li>
+     *   <li>Map keys (String) → keywords ("name" → :name, ":name" → :name)</li>
+     *   <li>Values (String) → keywords only if prefixed with ":"</li>
+     *   <li>Primitives, Clojure types → unchanged</li>
+     * </ul>
+     *
+     * <p>This function is general and consistent - applied uniformly to all
+     * Java API method parameters that accept collections.</p>
+     *
+     * @param data The data to normalize (List, Map, or other types)
+     * @return Clojure-compatible data structure
+     */
+    public static Object normalizeCollections(Object data) {
+        // Escape hatch: already Clojure persistent collection - O(1) check
+        if (data instanceof clojure.lang.IPersistentCollection) {
+            return data;
+        }
+
+        // Java List → Clojure vector with recursive conversion
+        if (data instanceof java.util.List) {
+            java.util.List<?> list = (java.util.List<?>) data;
+            Object[] converted = new Object[list.size()];
+            for (int i = 0; i < list.size(); i++) {
+                converted[i] = convertValue(list.get(i));
+            }
+            return vecRaw(converted);
+        }
+
+        // Java Map → Clojure map with recursive conversion
+        if (data instanceof java.util.Map && !(data instanceof APersistentMap)) {
+            return mapToPersistentMap((java.util.Map<String, Object>) data);
+        }
+
+        // Other types → apply EDN value conversion rules
+        return convertValue(data);
+    }
+
+    /** Read string into edn data structure. */
+    public static Object ednFromString(String str) {
+        return readStringFn.invoke(str);
+    }
+}

package/karma.conf.js

@@ -0,0 +1,19 @@
+module.exports = function (config) {
+    config.set({
+        browsers: ['ChromeHeadless'],
+        basePath: 'target',
+        files: ['browser-ci.js'],
+        frameworks: ['cljs-test'],
+        plugins: ['karma-cljs-test', 'karma-chrome-launcher'],
+        colors: true,
+        logLevel: config.LOG_INFO,
+        client: {
+            args: ["shadow.test.karma.init"]
+        },
+        singleRun: true,
+        // Integration tests need longer timeouts due to database ops and network calls
+        browserDisconnectTimeout: 180000,  // 3 minutes
+        browserNoActivityTimeout: 180000,  // 3 minutes  
+        captureTimeout: 300000              // 5 minutes
+    })
+};

package/libdatahike/compile-cpp

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -eo pipefail
+
+g++ libdatahike/src/test_cpp.cpp -L libdatahike/target -I libdatahike/target -ldatahike -o libdatahike/target/test_cpp
+
+echo "Created libdatahike/target/test_cpp"

package/libdatahike/src/datahike/impl/LibDatahikeBase.java

@@ -0,0 +1,203 @@
+package datahike.impl;
+
+import org.graalvm.nativeimage.c.function.CFunctionPointer;
+import org.graalvm.nativeimage.c.function.InvokeCFunctionPointer;
+import org.graalvm.nativeimage.c.type.CCharPointer;
+import org.graalvm.nativeimage.c.type.CCharPointerPointer;
+import org.graalvm.nativeimage.c.type.CConst;
+import org.graalvm.nativeimage.c.type.CTypeConversion;
+import datahike.java.Datahike;
+import datahike.java.Util;
+import datahike.impl.libdatahike;
+import clojure.lang.APersistentMap;
+import clojure.lang.Keyword;
+import java.io.StringWriter;
+import java.io.PrintWriter;
+import java.util.Date;
+import java.util.Base64;
+
+/**
+ * Base infrastructure for native C bindings.
+ *
+ * This class provides the core utilities for:
+ * - Exception handling and formatting
+ * - Input format parsing (db, history, since, asof, json, edn, cbor)
+ * - Output format serialization (json, edn, cbor)
+ * - C type conversions
+ *
+ * The actual C entry points are generated in LibDatahike.java.
+ */
+public class LibDatahikeBase {
+
+    // =========================================================================
+    // Callback Interface
+    // =========================================================================
+
+    /**
+     * C function pointer interface for reading return values.
+     * All native entry points use this callback pattern to return results.
+     */
+    public interface OutputReader extends CFunctionPointer {
+        @InvokeCFunctionPointer
+        void call(@CConst CCharPointer output);
+    }
+
+    // =========================================================================
+    // Exception Handling
+    // =========================================================================
+
+    /**
+     * Format an exception as a C string for callback.
+     * Format: "exception:{message}\nStacktrace:\n{stacktrace}"
+     */
+    protected static @CConst CCharPointer toException(Exception e) {
+        StringWriter sw = new StringWriter();
+        e.printStackTrace(new PrintWriter(sw));
+        String st = sw.toString();
+        return toCCharPointer("exception:".concat(e.toString()).concat("\nStacktrace:\n").concat(st));
+    }
+
+    // =========================================================================
+    // C Type Conversions
+    // =========================================================================
+
+    /**
+     * Parse EDN configuration string to Clojure map.
+     */
+    public static APersistentMap readConfig(CCharPointer db_config) {
+        return (APersistentMap) Util.ednFromString(CTypeConversion.toJavaString(db_config));
+    }
+
+    /**
+     * Convert Java String to C char pointer.
+     */
+    public static @CConst CCharPointer toCCharPointer(String result) {
+        CTypeConversion.CCharPointerHolder holder = CTypeConversion.toCString(result);
+        CCharPointer value = holder.get();
+        return value;
+    }
+
+    /**
+     * Convert byte array to Base64-encoded C char pointer.
+     * Used for CBOR output format.
+     */
+    public static @CConst CCharPointer toCCharPointer(byte[] result) {
+        CTypeConversion.CCharPointerHolder holder = CTypeConversion.toCBytes(Base64.getEncoder().encode(result));
+        CCharPointer value = holder.get();
+        return value;
+    }
+
+    // =========================================================================
+    // Input Format Handling
+    // =========================================================================
+
+    /**
+     * Load input based on format specification.
+     *
+     * Supported formats:
+     * - "db" : Connect and deref to get current database
+     * - "history" : Get full history database
+     * - "since:{timestamp_ms}" : Get database since timestamp
+     * - "asof:{timestamp_ms}" : Get database as-of timestamp
+     * - "json" : Parse as JSON
+     * - "edn" : Parse as EDN
+     * - "cbor" : Parse as CBOR (base64 encoded)
+     */
+    protected static Object loadInput(@CConst CCharPointer input_format,
+                                       @CConst CCharPointer raw_input) {
+        String format = CTypeConversion.toJavaString(input_format);
+        String formats[] = format.split(":");
+        switch (formats[0]) {
+        case "db":
+            return Datahike.deref(Datahike.connect(readConfig(raw_input)));
+        case "history":
+            return Datahike.history(Datahike.deref(Datahike.connect(readConfig(raw_input))));
+        case "since":
+            return Datahike.since(Datahike.deref(Datahike.connect(readConfig(raw_input))),
+                                  new Date(Long.parseLong(formats[1])));
+        case "asof":
+            return Datahike.asOf(Datahike.deref(Datahike.connect(readConfig(raw_input))),
+                                 new Date(Long.parseLong(formats[1])));
+        case "json":
+            return libdatahike.parseJSON(CTypeConversion.toJavaString(raw_input));
+        case "edn":
+            return libdatahike.parseEdn(CTypeConversion.toJavaString(raw_input));
+        case "cbor":
+            return libdatahike.parseCBOR(CTypeConversion.toJavaString(raw_input).getBytes());
+        default:
+            throw new IllegalArgumentException("Input format not supported: " + format);
+        }
+    }
+
+    /**
+     * Load multiple inputs for query operations.
+     */
+    protected static Object[] loadInputs(@CConst long num_inputs,
+                                          @CConst CCharPointerPointer input_formats,
+                                          @CConst CCharPointerPointer raw_inputs) {
+        Object[] inputs = new Object[(int) num_inputs];
+        for (int i = 0; i < num_inputs; i++) {
+            inputs[i] = loadInput(input_formats.read(i), raw_inputs.read(i));
+        }
+        return inputs;
+    }
+
+    // =========================================================================
+    // Output Format Handling
+    // =========================================================================
+
+    /**
+     * Serialize output based on format specification.
+     *
+     * Supported formats:
+     * - "json" : Serialize as JSON string
+     * - "edn" : Serialize as EDN string
+     * - "cbor" : Serialize as CBOR (base64 encoded)
+     */
+    protected static @CConst CCharPointer toOutput(@CConst CCharPointer output_format,
+                                                    Object output) {
+        String format = CTypeConversion.toJavaString(output_format);
+        switch (format) {
+        case "json":
+            return toCCharPointer(libdatahike.toJSONString(output));
+        case "edn":
+            return toCCharPointer(libdatahike.toEdnString(output));
+        case "cbor":
+            return toCCharPointer(libdatahike.toCBOR(output));
+        default:
+            throw new IllegalArgumentException("Output format not supported: " + format);
+        }
+    }
+
+    // =========================================================================
+    // Helper Methods for Generated Code
+    // =========================================================================
+
+    /**
+     * Parse keyword from EDN string (e.g., ":eavt" -> Keyword).
+     */
+    protected static Keyword parseKeyword(CCharPointer kwd_edn) {
+        return Util.kwd(CTypeConversion.toJavaString(kwd_edn));
+    }
+
+    /**
+     * Parse EDN to Iterable (for eids, etc).
+     */
+    protected static Iterable<?> parseIterable(CCharPointer edn) {
+        return (Iterable<?>) libdatahike.parseEdn(CTypeConversion.toJavaString(edn));
+    }
+
+    /**
+     * Convert datoms to vectors for serialization.
+     */
+    protected static Iterable<?> datomsToVecs(Iterable<?> datoms) {
+        return libdatahike.datomsToVecs(datoms);
+    }
+
+    /**
+     * Convert entity to map for serialization.
+     */
+    protected static Object entityToMap(Object entity) {
+        return libdatahike.intoMap(entity);
+    }
+}