@loradb/lora-node 0.2.0 → 0.4.0

package/README.md

@@ -1,7 +1,7 @@
 # lora-node
 
-Node.js / TypeScript bindings for the [Lora](../../README.md) in-memory
-graph engine. The package exposes a first-class typed API: query results are
+Node.js / TypeScript bindings for the [Lora](../../README.md) graph
+engine. The package exposes a first-class typed API: query results are
 modelled as discriminated unions, temporal values carry `kind` tags, and the
 `Database` class is strongly typed in both directions (params and rows).
 
@@ -29,13 +29,13 @@ to `package.json`.
 ## Usage
 
 `lora-node` is **async-only** — the sole initialization pattern is
-`createDatabase()`. There is no synchronous constructor and no
+`createDatabase(...)`. There is no synchronous constructor and no
 `Database.create()` static; `Database` is a type-only export.
 
 ```ts
 import { createDatabase, isNode, type LoraNode } from "lora-node";
 
-const db = await createDatabase();
+const db = await createDatabase(); // in-memory by default
 await db.execute("CREATE (:Person {name: $n, age: $a})", { n: "Alice", a: 30 });
 
 const res = await db.execute<{ n: LoraNode }>("MATCH (n:Person) RETURN n");
@@ -46,9 +46,32 @@ for (const row of res.rows) {
 }
 ```
 
-The API matches `lora-wasm` verbatim — same shared types, same
-`createDatabase()` entry point, same async method signatures — so
-switching backends is a single import change.
+The initialization rule is:
+
+```ts
+import { createDatabase } from "lora-node";
+
+const inMemory = await createDatabase();            // in-memory only
+const persistent = await createDatabase("./app");  // persistent: pass a directory string
+```
+
+If you want persistence, pass a **directory string** to `createDatabase(...)`.
+
+Node also has a WAL-backed convenience overload:
+
+```ts
+import { createDatabase } from "lora-node";
+
+const db = await createDatabase("./.lora-wal"); // persistent: directory string
+```
+
+The string is treated as the WAL directory path verbatim. Relative
+paths resolve from the current working directory. This is a Node-only
+initialization convenience; the query surface, shared types, and async
+method signatures still match `lora-wasm`.
+
+Call `db.dispose()` when you need to release the native handle eagerly,
+especially before reopening the same WAL directory in the same process.
 
 ## Typed value model
 
@@ -128,3 +151,9 @@ identical to `lora-wasm`.
   path would require extending the value serializer.
 - **Cancellation.** The napi `Task` abstraction does not support
   cancellation once dispatched; a runaway query runs to completion.
+- **WAL surface.** This first Node persistence slice only exposes
+  WAL-backed initialization via `createDatabase(walDir)`. Checkpoint,
+  truncate, status, and sync-mode controls are not exposed yet.
+- **WAL directory ownership.** A WAL directory can only be open by one
+  live handle at a time. Dispose the first handle before reopening the
+  same directory.

package/dist/index.d.ts

@@ -7,20 +7,33 @@
  * native surface into the strongly-typed `QueryResult<T>` / `LoraParams`
  * shapes defined in the shared TS contract (`crates/shared-ts/types.ts`).
  *
- * **Initialization is async-only.** The one canonical entry point is
- * `createDatabase()`; there is no synchronous constructor. See the docs at
+ * **Initialization is async-only.** The canonical entry point is
+ * `createDatabase(...)`, optionally with a WAL directory path. There is no
+ * synchronous constructor. See the docs at
  * https://loradb.com/docs/getting-started/node for the full rationale.
  */
 import type { LoraParams, LoraValue, QueryResult } from "./types.js";
 declare const NativeDatabase: typeof import("./native.js").Database;
 export * from "./types.js";
 /**
- * In-memory Lora graph database instance.
+ * Metadata returned by `saveSnapshot` / `loadSnapshot`. Mirrors the Rust
+ * `SnapshotMeta` struct and matches the shape used by every other binding
+ * (Python, WASM, Go, FFI) so snapshots can be described in the same way
+ * regardless of language.
+ */
+export interface SnapshotMeta {
+    formatVersion: number;
+    nodeCount: number;
+    relationshipCount: number;
+    walLsn: number | null;
+}
+/**
+ * Lora graph database instance.
  *
- * Obtained exclusively via `createDatabase()`. There is no public constructor
- * and no synchronous factory — the async entry point lets the binding
- * extend initialization later (lazy native loading, warmup, schema
- * preflight) without breaking callers.
+ * Obtained exclusively via `createDatabase()`. There is no public
+ * constructor and no synchronous factory. With no args the instance is
+ * purely in-memory; with a WAL directory path it replays committed WAL
+ * state from disk before serving queries.
  *
  * Instances are independent — each owns its own in-memory graph. Multiple
  * concurrent `execute()` calls against one instance run one at a time
@@ -41,6 +54,29 @@ declare class DatabaseImpl {
     nodeCount(): Promise<number>;
     /** Number of relationships currently in the graph. */
     relationshipCount(): Promise<number>;
+    /**
+     * Release the native database handle. Idempotent.
+     *
+     * Call this when a WAL-backed database needs to be reopened in the same
+     * process. New operations after disposal reject with `database is closed`.
+     */
+    dispose(): void;
+    /**
+     * Save the graph to a snapshot file. Writes atomically via a `.tmp` +
+     * rename dance — the target path is only replaced once the full payload
+     * has been written and fsync'd.
+     *
+     * Synchronous in the native layer (point-in-time consistency requires
+     * holding the store mutex for the duration of the save); the returned
+     * Promise resolves immediately once the save returns.
+     */
+    saveSnapshot(path: string): Promise<SnapshotMeta>;
+    /**
+     * Replace the current graph state with a snapshot loaded from `path`.
+     * Concurrent `execute()` calls block on the store mutex until the load
+     * completes.
+     */
+    loadSnapshot(path: string): Promise<SnapshotMeta>;
 }
 /**
  * Public type for a LoraDB instance.
@@ -56,24 +92,36 @@ declare class DatabaseImpl {
  */
 export type Database = DatabaseImpl;
 /**
- * Create and initialize a new in-memory LoraDB instance.
+ * Create and initialize a new LoraDB instance.
  *
  * **This is the only supported initialization pattern** for `lora-node`.
  * Synchronous construction is not available — the async factory guarantees
- * the native layer is ready before the first query dispatches and keeps
- * the Node and WASM surfaces symmetric.
+ * the native layer is ready before the first query dispatches.
  *
  * ```ts
  * import { createDatabase } from "lora-node";
  *
- * const db = await createDatabase();
+ * const db = await createDatabase(); // in-memory by default
  * const res = await db.execute(
  *   "CREATE (n:Person {name: $name}) RETURN n",
  *   { name: "Alice" },
  * );
  * ```
  *
+ * Optional Node-only persistence convenience:
+ *
+ * ```ts
+ * import { createDatabase } from "lora-node";
+ *
+ * const inMemory = await createDatabase();            // in-memory
+ * const persistent = await createDatabase("./app");  // persistent: pass a directory string
+ * ```
+ *
+ * If you want persistence, pass a directory string. The string is treated
+ * as a WAL directory path verbatim. Relative paths resolve from the
+ * current working directory.
+ *
  * Each call returns an independent graph — no shared state between instances.
  */
-export declare function createDatabase(): Promise<Database>;
+export declare function createDatabase(walDir?: string): Promise<Database>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,SAAS,EACT,WAAW,EACZ,MAAM,YAAY,CAAC;AAOpB,QAAA,MAAM,cAAc,EAAE,cAAc,aAAa,EAAE,QAA0B,CAAC;AAE9E,cAAc,YAAY,CAAC;AAE3B;;;;;;;;;;;GAWG;AACH,cAAM,YAAY;;gBAGJ,KAAK,EAAE,YAAY,CAAC,OAAO,cAAc,CAAC;IAItD;;;;OAIG;IACG,OAAO,CACX,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/D,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAS9D,sEAAsE;IAChE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,8CAA8C;IACxC,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAIlC,sDAAsD;IAChD,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;CAG3C;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,QAAQ,GAAG,YAAY,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,QAAQ,CAAC,CAExD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,SAAS,EACT,WAAW,EACZ,MAAM,YAAY,CAAC;AAOpB,QAAA,MAAM,cAAc,EAAE,cAAc,aAAa,EAAE,QAA0B,CAAC;AAE9E,cAAc,YAAY,CAAC;AAE3B;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,cAAM,YAAY;;gBAGJ,KAAK,EAAE,YAAY,CAAC,OAAO,cAAc,CAAC;IAItD;;;;OAIG;IACG,OAAO,CACX,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/D,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAS9D,sEAAsE;IAChE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B,8CAA8C;IACxC,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAQlC,sDAAsD;IAChD,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAQ1C;;;;;OAKG;IACH,OAAO,IAAI,IAAI;IAQf;;;;;;;;OAQG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAQvD;;;;OAIG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAOxD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,QAAQ,GAAG,YAAY,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,cAAc,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAQvE"}

package/dist/index.js

@@ -8,8 +8,9 @@
  * native surface into the strongly-typed `QueryResult<T>` / `LoraParams`
  * shapes defined in the shared TS contract (`crates/shared-ts/types.ts`).
  *
- * **Initialization is async-only.** The one canonical entry point is
- * `createDatabase()`; there is no synchronous constructor. See the docs at
+ * **Initialization is async-only.** The canonical entry point is
+ * `createDatabase(...)`, optionally with a WAL directory path. There is no
+ * synchronous constructor. See the docs at
  * https://loradb.com/docs/getting-started/node for the full rationale.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -38,12 +39,12 @@ const native_js_1 = __importDefault(require("./native.js"));
 const NativeDatabase = native_js_1.default.Database;
 __exportStar(require("./types.js"), exports);
 /**
- * In-memory Lora graph database instance.
+ * Lora graph database instance.
  *
- * Obtained exclusively via `createDatabase()`. There is no public constructor
- * and no synchronous factory — the async entry point lets the binding
- * extend initialization later (lazy native loading, warmup, schema
- * preflight) without breaking callers.
+ * Obtained exclusively via `createDatabase()`. There is no public
+ * constructor and no synchronous factory. With no args the instance is
+ * purely in-memory; with a WAL directory path it replays committed WAL
+ * state from disk before serving queries.
  *
  * Instances are independent — each owns its own in-memory graph. Multiple
  * concurrent `execute()` calls against one instance run one at a time
@@ -70,38 +71,114 @@ class DatabaseImpl {
     }
     /** Drop every node and relationship. Constant-time under the hood. */
     async clear() {
-        this.#inner.clear();
+        try {
+            this.#inner.clear();
+        }
+        catch (err) {
+            throw (0, types_js_1.wrapError)(err);
+        }
     }
     /** Number of nodes currently in the graph. */
     async nodeCount() {
-        return this.#inner.nodeCount();
+        try {
+            return this.#inner.nodeCount();
+        }
+        catch (err) {
+            throw (0, types_js_1.wrapError)(err);
+        }
     }
     /** Number of relationships currently in the graph. */
     async relationshipCount() {
-        return this.#inner.relationshipCount();
+        try {
+            return this.#inner.relationshipCount();
+        }
+        catch (err) {
+            throw (0, types_js_1.wrapError)(err);
+        }
+    }
+    /**
+     * Release the native database handle. Idempotent.
+     *
+     * Call this when a WAL-backed database needs to be reopened in the same
+     * process. New operations after disposal reject with `database is closed`.
+     */
+    dispose() {
+        try {
+            this.#inner.dispose();
+        }
+        catch (err) {
+            throw (0, types_js_1.wrapError)(err);
+        }
+    }
+    /**
+     * Save the graph to a snapshot file. Writes atomically via a `.tmp` +
+     * rename dance — the target path is only replaced once the full payload
+     * has been written and fsync'd.
+     *
+     * Synchronous in the native layer (point-in-time consistency requires
+     * holding the store mutex for the duration of the save); the returned
+     * Promise resolves immediately once the save returns.
+     */
+    async saveSnapshot(path) {
+        try {
+            return this.#inner.saveSnapshot(path);
+        }
+        catch (err) {
+            throw (0, types_js_1.wrapError)(err);
+        }
+    }
+    /**
+     * Replace the current graph state with a snapshot loaded from `path`.
+     * Concurrent `execute()` calls block on the store mutex until the load
+     * completes.
+     */
+    async loadSnapshot(path) {
+        try {
+            return this.#inner.loadSnapshot(path);
+        }
+        catch (err) {
+            throw (0, types_js_1.wrapError)(err);
+        }
     }
 }
 /**
- * Create and initialize a new in-memory LoraDB instance.
+ * Create and initialize a new LoraDB instance.
  *
  * **This is the only supported initialization pattern** for `lora-node`.
  * Synchronous construction is not available — the async factory guarantees
- * the native layer is ready before the first query dispatches and keeps
- * the Node and WASM surfaces symmetric.
+ * the native layer is ready before the first query dispatches.
  *
  * ```ts
  * import { createDatabase } from "lora-node";
  *
- * const db = await createDatabase();
+ * const db = await createDatabase(); // in-memory by default
  * const res = await db.execute(
  *   "CREATE (n:Person {name: $name}) RETURN n",
  *   { name: "Alice" },
  * );
  * ```
  *
+ * Optional Node-only persistence convenience:
+ *
+ * ```ts
+ * import { createDatabase } from "lora-node";
+ *
+ * const inMemory = await createDatabase();            // in-memory
+ * const persistent = await createDatabase("./app");  // persistent: pass a directory string
+ * ```
+ *
+ * If you want persistence, pass a directory string. The string is treated
+ * as a WAL directory path verbatim. Relative paths resolve from the
+ * current working directory.
+ *
  * Each call returns an independent graph — no shared state between instances.
  */
-async function createDatabase() {
-    return new DatabaseImpl(new NativeDatabase());
+async function createDatabase(walDir) {
+    try {
+        return new DatabaseImpl(walDir === undefined ? new NativeDatabase() : new NativeDatabase(walDir));
+    }
+    catch (err) {
+        throw (0, types_js_1.wrapError)(err);
+    }
 }
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;;;;;;;;;;;;;;;;;AAsGH,wCAEC;AAjGD,yCAAuC;AAEvC,6DAA6D;AAC7D,wDAAwD;AACxD,4DAAiC;AAEjC,MAAM,cAAc,GAA0C,mBAAM,CAAC,QAAQ,CAAC;AAE9E,6CAA2B;AAE3B;;;;;;;;;;;GAWG;AACH,MAAM,YAAY;IACP,MAAM,CAAsC;IAErD,YAAY,KAA0C;QACpD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAEX,KAAa,EAAE,MAAmB;QAClC,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,IAAI,IAAI,CAAC,CAAC;YAC7D,OAAO,GAAqB,CAAC;QAC/B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,IAAA,oBAAS,EAAC,GAAG,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IAED,sEAAsE;IACtE,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,8CAA8C;IAC9C,KAAK,CAAC,SAAS;QACb,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;IACjC,CAAC;IAED,sDAAsD;IACtD,KAAK,CAAC,iBAAiB;QACrB,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;IACzC,CAAC;CACF;AAgBD;;;;;;;;;;;;;;;;;;;GAmBG;AACI,KAAK,UAAU,cAAc;IAClC,OAAO,IAAI,YAAY,CAAC,IAAI,cAAc,EAAE,CAAC,CAAC;AAChD,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loradb/lora-node",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Node.js / TypeScript bindings for the Lora in-memory graph database",
   "license": "BUSL-1.1",
   "author": "LoraDB, Inc.",
@@ -89,10 +89,10 @@
     "vitest": "^2.1.1"
   },
   "optionalDependencies": {
-    "@loradb/lora-node-linux-x64-gnu": "0.2.0",
-    "@loradb/lora-node-linux-arm64-gnu": "0.2.0",
-    "@loradb/lora-node-darwin-x64": "0.2.0",
-    "@loradb/lora-node-darwin-arm64": "0.2.0",
-    "@loradb/lora-node-win32-x64-msvc": "0.2.0"
+    "@loradb/lora-node-linux-x64-gnu": "0.4.0",
+    "@loradb/lora-node-linux-arm64-gnu": "0.4.0",
+    "@loradb/lora-node-darwin-x64": "0.4.0",
+    "@loradb/lora-node-darwin-arm64": "0.4.0",
+    "@loradb/lora-node-win32-x64-msvc": "0.4.0"
   }
 }

package/ts/native.d.ts

@@ -11,8 +11,15 @@ export interface NativeQueryResult {
   rows: Array<Record<string, unknown>>;
 }
 
+export interface NativeSnapshotMeta {
+  formatVersion: number;
+  nodeCount: number;
+  relationshipCount: number;
+  walLsn: number | null;
+}
+
 export declare class Database {
-  constructor();
+  constructor(walDir?: string | null);
   /** Non-blocking: runs on the libuv threadpool, returns a Promise. */
   execute(
     query: string,
@@ -21,4 +28,9 @@ export declare class Database {
   clear(): void;
   nodeCount(): number;
   relationshipCount(): number;
+  dispose(): void;
+  /** Atomic save. Synchronous under the store mutex. */
+  saveSnapshot(path: string): NativeSnapshotMeta;
+  /** Replace the current graph with the snapshot at `path`. */
+  loadSnapshot(path: string): NativeSnapshotMeta;
 }