datahike-browser-tests 1.0.0

package/libdatahike/src/datahike/impl/libdatahike.clj

@@ -0,0 +1,59 @@
+(ns datahike.impl.libdatahike
+  (:require [clojure.edn :as edn]
+            [jsonista.core :as j]
+            [datahike.json :as json]
+            [clj-cbor.core :as cbor]
+            [taoensso.timbre :as timbre])
+  (:import [datahike.datom Datom]
+           [datahike.connector Connection])
+  (:gen-class
+   :methods [^{:static true} [parseJSON [String] Object]
+             ^{:static true} [parseEdn [String] Object]
+             ^{:static true} [parseCBOR [bytes] Object]
+             ^{:static true} [toEdnString [Object] String]
+             ^{:static true} [toJSONString [Object] String]
+             ^{:static true} [toCBOR [Object] bytes]
+             ^{:static true} [datomsToVecs [Iterable] Iterable]
+             ^{:static true} [intoMap [Object] Object]
+             ^{:static true} [transformJSONForTx [Object Object] Object]]))
+
+(timbre/set-level! :warn)
+
+(defn -parseJSON [s]
+  (j/read-value s json/mapper))
+
+(defn -toJSONString [obj]
+  (j/write-value-as-string obj json/mapper))
+
+(defn -parseEdn [s]
+  (edn/read-string s))
+
+(defn -toEdnString [obj]
+  (pr-str obj))
+
+(defn -parseCBOR [^bytes b]
+  (cbor/decode b))
+
+(defn ^bytes -toCBOR [edn]
+  (cbor/encode edn))
+
+(defn -datomsToVecs [datoms]
+  (mapv #(vec (seq ^Datom %)) datoms))
+
+(defn -intoMap [edn]
+  (into {} edn))
+
+(defn -transformJSONForTx [tx-data db-or-conn]
+  "Transform JSON transaction data based on schema.
+   Converts values to appropriate types (e.g., Integer → Long for :db.type/long attributes).
+
+   Args:
+     tx-data: Java List from parseJSON containing transaction data
+     db-or-conn: Connection or DB value
+
+   Returns:
+     Transformed tx-data with schema-aware type conversions"
+  (let [db (if (instance? Connection db-or-conn)
+             @db-or-conn
+             db-or-conn)]
+    (json/xf-data-for-tx tx-data db)))

package/libdatahike/src/test_cpp.cpp

@@ -0,0 +1,61 @@
+#include <iostream>
+#include <libdatahike.h>
+#include <assert.h>
+
+const char* config_str = "{:store {:backend :file :path \"/tmp/libdatahike-test\" :id #uuid \"f11e0000-0000-0000-0000-000000000001\"} :schema-flexibility :write}";
+const char* schema_str = "[{:db/ident :name :db/valueType :db.type/string :db/cardinality :db.cardinality/one}]";
+const char* tx_str = "[{:name \"Alice\"}]";
+const char* query_str = "[:find ?e ?v :where [?e :name ?v]]";
+
+void default_reader(char* edn) {
+  std::cout << "result: " << edn << std::endl;
+}
+
+void database_exists_reader(char* database_exists_result_edn) {
+  std::cout << "database exists result: " << database_exists_result_edn << std::endl;
+  std::string true_str = "true";
+  assert(true_str.compare(database_exists_result_edn) == 0);
+}
+
+void transact_reader(char* transact_result_edn) {
+  std::cout << "transact result: " << transact_result_edn << std::endl;
+}
+
+void query_reader(char* query_result_edn) {
+  std::cout << "query result: " << query_result_edn << std::endl;
+  std::string expected_q_result = "#{[2 \"Alice\"]}";
+  assert(expected_q_result.compare(query_result_edn) == 0);
+}
+
+
+int main(int argc, char* argv[]) {
+  graal_isolate_t *isolate = NULL;
+  graal_isolatethread_t *thread = NULL;
+
+  if (graal_create_isolate(NULL, &isolate, &thread) != 0) {
+    fprintf(stderr, "Initialization error.\n");
+    return 1;
+  }
+
+  void (*default_reader_pointer)(char*);
+  default_reader_pointer = &default_reader;
+  create_database((long)thread, config_str, "edn", (const void*)default_reader_pointer);
+
+  void (*database_exists_reader_pointer)(char*);
+  database_exists_reader_pointer = &database_exists_reader;
+  database_exists((long)thread, config_str, "edn", (const void*)database_exists_reader_pointer);
+
+  void (*transact_reader_pointer)(char*);
+  transact_reader_pointer = &transact_reader;
+  transact((long)thread, config_str, "edn", schema_str, "edn", (const void*)transact_reader);
+  transact((long)thread, config_str, "edn", tx_str, "edn", (const void*)transact_reader);
+
+  long num_inputs = 1;
+  const char *input_format = "db";
+  const char *output_format = "edn";
+  void (*query_reader_pointer)(char*);
+  query_reader_pointer = &query_reader;
+  q((long)thread, query_str, num_inputs, &input_format, &config_str,
+        output_format, (const void*)query_reader_pointer);
+  return 0;
+}

package/npm-package/PUBLISHING.md

@@ -0,0 +1,140 @@
+# NPM Publication Guide
+
+This guide explains how to publish Datahike to npm.
+
+## Prerequisites
+
+1. npm account (create at https://www.npmjs.com/signup)
+2. Login to npm: `npm login`
+
+## Files Included in Package
+
+The `package.json` specifies which files to include:
+- All `.js` files (compiled ClojureScript)
+- All `.js.map` files (source maps)
+- `index.d.ts` (TypeScript definitions)
+- `README.md` (documentation)
+- `LICENSE` (EPL-1.0)
+
+## Pre-Publication Checklist
+
+1. **Build the npm package** (this handles version, types, and compilation)
+   ```bash
+   bb npm-build
+   ```
+   
+   This single command will:
+   - Update `package.json` version from `config.edn` (major.minor.commit-count)
+   - Regenerate TypeScript definitions
+   - Compile ClojureScript with shadow-cljs
+   
+   Alternatively, run individual steps:
+   ```bash
+   bb npm-version        # Update package.json version only
+   bb codegen-ts         # Generate TypeScript definitions only
+   npx shadow-cljs compile npm-release  # Compile ClojureScript only
+   ```
+
+2. **Run tests**
+   ```bash
+   cd npm-package
+   node test.js
+   ```
+
+3. **Verify package contents**
+   ```bash
+   cd npm-package
+   npm pack --dry-run
+   ```
+
+## Publishing
+
+### Publish to npm
+
+```bash
+cd npm-package
+npm publish
+```
+
+### Tag a release
+
+After publishing, tag the git commit:
+```bash
+git tag v0.7.0-alpha1
+git push --tags
+```
+
+## Post-Publication
+
+1. Verify the package on npm: https://www.npmjs.com/package/datahike
+2. Test installation: `npm install datahike@latest`
+3. Create GitHub release with changelog
+
+## Testing the Package Locally
+
+Before publishing, test the package locally:
+
+```bash
+# In npm-package directory
+npm pack
+
+# This creates datahike-0.7.0-alpha1.tgz
+# In another project:
+npm install /path/to/datahike/npm-package/datahike-0.7.0-alpha1.tgz
+```
+
+## Version Strategy
+
+Datahike uses a **centralized version management** system:
+- **Source of truth**: `config.edn` contains `{:version {:major X :minor Y}}`
+- **Full version**: Automatically calculated as `major.minor.commit-count` (e.g., `0.6.1634`)
+- **Synchronized**: Same version used for JVM (Maven/Clojars), ClojureScript, and npm
+
+To increment the version:
+```bash
+bb inc major   # Increment major version (breaking changes)
+bb inc minor   # Increment minor version (new features)
+```
+
+The `bb npm-build` command automatically syncs the current version to `package.json`.
+
+## Troubleshooting
+
+### "Module not found" errors
+Check that `package.json` `main` field points to the correct entry file:
+```json
+"main": "datahike.js.api.js"
+```
+
+### TypeScript types not recognized
+Ensure `types` field in `package.json` is correct:
+```json
+"types": "index.d.ts"
+```
+
+### Missing dependencies
+Datahike is compiled to standalone JavaScript - no runtime dependencies needed.
+
+## Updating the Package
+
+1. Make code changes in ClojureScript source
+2. Build package: `bb npm-build` (handles compilation, types, and version)
+3. Update CHANGELOG.md if needed
+4. Run tests: `node test.js`
+5. Publish: `npm publish`
+
+## Quick Release Checklist
+
+1. Ensure all changes are committed
+2. Increment version if needed: `bb inc [major|minor]`
+3. Build package: `bb npm-build`
+4. Test: `cd npm-package && node test.js`
+5. Verify: `npm pack --dry-run`
+6. Login: `npm login`
+7. Publish: `npm publish`
+
+## Links
+
+- npm package: https://www.npmjs.com/package/datahike
+- npm docs: https://docs.npmjs.com/
+- TypeScript declarations: https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html

package/npm-package/README.md

@@ -0,0 +1,226 @@
+# Datahike - JavaScript API
+
+Durable Datalog database for JavaScript and Node.js, powered by ClojureScript.
+
+## Features
+
+- **Datalog Queries**: Expressive query language inspired by Datomic
+- **Schema Support**: Optional schema with validation
+- **Time Travel**: Access database history and temporal queries
+- **Pluggable Backends**: Memory, file, or custom storage
+- **Promise-based API**: Native JavaScript async/await support
+- **TypeScript Support**: Complete type definitions included
+
+## Installation
+
+```bash
+npm install datahike
+```
+
+## Quick Start
+
+```javascript
+const d = require('datahike');
+const crypto = require('crypto');
+
+async function example() {
+  // Create database configuration (requires UUID for :id)
+  const config = {
+    store: {
+      backend: ':memory',
+      id: crypto.randomUUID()
+    }
+  };
+
+  // Create and connect to database
+  await d.createDatabase(config);
+  const conn = await d.connect(config);
+
+  // Define schema
+  // Keys: WITHOUT colon, Values: WITH colon
+  const schema = [
+    {
+      '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'
+    }
+  ];
+  await d.transact(conn, schema);
+
+  // Add data (data keys without colons)
+  const data = [
+    { name: 'Alice', age: 30 },
+    { name: 'Bob', age: 25 }
+  ];
+  await d.transact(conn, data);
+
+  // Query with Datalog
+  const db = await d.db(conn);
+  const results = await d.q(
+    '[:find ?name ?age :where [?e :name ?name] [?e :age ?age]]',
+    db
+  );
+
+  console.log(results); // [['Alice', 30], ['Bob', 25]]
+
+  // Disconnect
+  d.release(conn);
+  await d.deleteDatabase(config);
+}
+
+example();
+```
+
+## Documentation
+
+### Configuration
+
+**⚠️ Note:** Keyword syntax may change in future versions to simplify the API.
+
+```javascript
+const crypto = require('crypto');
+
+const config = {
+  store: {
+    backend: ':memory',       // or ':file'
+    id: crypto.randomUUID()   // Required: UUID identifier
+  },
+  // Optional configuration:
+  'keep-history': true,           // default: true
+  'schema-flexibility': ':write'  // or ':read'
+};
+
+// File backend example (Node.js only)
+const fileConfig = {
+  store: {
+    backend: ':file',
+    path: './data'
+  }
+};
+```
+
+### Keywords
+
+**Current keyword rules:**
+- **Schema keys**: WITHOUT `:` prefix (`'db/ident'`, not `':db/ident'`)
+- **Schema values**: WITH `:` prefix (`':name'`, `':db.type/string'`)
+- **Data keys**: WITHOUT `:` prefix (`name`, `age`)
+- **Pull patterns**: WITH `:` prefix (`[':name', ':age']`)
+
+### Datalog Queries
+
+Queries use EDN string format (Datalog DSL):
+
+```javascript
+// Find relationships
+await d.q('[:find ?e ?name :where [?e :name ?name]]', db);
+
+// Find collection
+await d.q('[:find [?name ...] :where [_ :name ?name]]', db);
+
+// With predicates
+await d.q('[:find ?name :where [?e :name ?name] [?e :age ?age] [(> ?age 25)]]', db);
+
+// Parameterized
+await d.q('[:find ?e :in $ ?name :where [?e :name ?name]]', db, 'Alice');
+```
+
+### Pull API
+
+Retrieve entity data by pattern:
+
+```javascript
+// Pull single entity
+await d.pull(db, ['*'], entityId);
+
+// Pull with specific attributes
+await d.pull(db, [':name', ':age'], entityId);
+
+// Pull many entities
+await d.pullMany(db, ['*'], [id1, id2, id3]);
+```
+
+### Transactions
+
+Add or retract data:
+
+```javascript
+// Entity maps (data keys without colons)
+const data = [
+  { name: 'Charlie', age: 35 }
+];
+await d.transact(conn, data);
+
+// Tuple form
+await d.transact(conn, [
+  [':db/add', entityId, ':age', 36]
+]);
+
+// Retract
+await d.transact(conn, [
+  [':db/retract', entityId, ':age', 35]
+]);
+```
+
+### Temporal Queries
+
+Access database history:
+
+```javascript
+// Database at specific time
+const historicalDb = d.asOf(d.db(conn), date);
+
+// Full history
+const historyDb = d.history(d.db(conn));
+```
+
+## API Reference
+
+See [TypeScript definitions](index.d.ts) for complete API documentation.
+
+### Core Functions
+
+- `createDatabase(config)` - Create new database
+- `deleteDatabase(config)` - Delete database
+- `databaseExists(config)` - Check if database exists
+- `connect(config)` - Connect to database
+- `release(conn)` - Close connection
+- `db(conn)` - Get current database value
+- `transact(conn, txData)` - Execute transaction
+- `q(query, ...args)` - Execute Datalog query
+- `pull(db, pattern, entityId)` - Pull entity by pattern
+- `pullMany(db, pattern, entityIds)` - Pull multiple entities
+- `entity(db, entityId)` - Get entity (returns ClojureScript entity)
+- `datoms(db, index, ...components)` - Access datoms directly
+- `seekDatoms(db, index, ...components)` - Seek in index
+- `schema(db)` - Get database schema
+- `reverse_schema(db)` - Get reverse schema
+- `metrics(db)` - Get database metrics
+
+### Temporal Functions
+
+- `asOf(db, timePoint)` - Database at specific time
+- `since(db, timePoint)` - Changes since time
+- `history(db)` - Full database history
+
+## Known Limitations
+
+- **Query API**: Requires EDN string format (no JavaScript object syntax)
+- **Entity API**: Returns ClojureScript objects (use Pull API for plain JavaScript objects)
+- **Keyword syntax**: May change in future versions for simplification
+- **Advanced Datalog**: Some advanced features may have limited support
+
+## License
+
+Eclipse Public License 1.0
+
+## Links
+
+- [GitHub Repository](https://github.com/replikativ/datahike)
+- [Documentation](https://github.com/replikativ/datahike/tree/master/doc)
+- [ClojureScript API Docs](https://cljdoc.org/d/io.replikativ/datahike)

package/npm-package/package.template.json

@@ -0,0 +1,34 @@
+{
+  "description" : "Durable Datalog database for JavaScript and ClojureScript",
+  "engines" : {
+    "node" : ">=14.0.0"
+  },
+  "repository" : {
+    "type" : "git",
+    "url" : "https://github.com/replikativ/datahike.git"
+  },
+  "license" : "EPL-1.0",
+  "homepage" : "https://github.com/replikativ/datahike",
+  "name" : "datahike",
+  "scripts" : {
+    "test" : "node test.js",
+    "test:browser" : "karma start karma.conf.js --single-run"
+  },
+  "bugs" : {
+    "url" : "https://github.com/replikativ/datahike/issues"
+  },
+  "keywords" : [ "database", "datalog", "datomic", "clojurescript", "immutable", "functional" ],
+  "types" : "index.d.ts",
+  "author" : "Christian Weilbach",
+  "files" : [ "*.js", "*.js.map", "browser/main.js", "browser/cljs-runtime", "index.d.ts", "README.md", "LICENSE" ],
+  "version" : "{{VERSION}}",
+  "main" : "datahike.js.api.js",
+  "exports" : {
+    ".": {
+      "browser": "./browser/main.js",
+      "node": "./datahike.js.api.js",
+      "default": "./datahike.js.api.js"
+    }
+  },
+  "browser" : "./browser/main.js"
+}