@harperfast/rocksdb-js 2.2.0 → 2.3.0

package/dist/index.d.cts

@@ -1189,6 +1189,7 @@ type NativeDatabase = {
   compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key): void;
   compactSync(start?: Key, end?: Key): void;
   columns: string[];
+  createCheckpoint(resolve: ResolveCallback<void>, reject: RejectCallback, targetPath: string): void;
   destroy(): void;
   drop(resolve: ResolveCallback<void>, reject: RejectCallback): void;
   dropSync(): void;
@@ -1823,6 +1824,31 @@ declare class RocksDatabase extends DBI<DBITransactional> {
   */
   backup(backupDir: string, options?: BackupOptions): Promise<number>;
   /**
+  * Creates a hardlinked, point-in-time, fully independent copy of the entire
+  * database (all column families) at `targetPath` and resolves once written.
+  *
+  * Unlike a backup, a checkpoint is a normal, writable sibling database: open
+  * it with {@link RocksDatabase.open} and it diverges independently from the
+  * source. SST and blob files are hardlinked when `targetPath` is on the same
+  * filesystem as the database and copied otherwise (other files such as the
+  * MANIFEST are always copied), so the operation is near-instant on the same
+  * filesystem. The memtable is flushed so the checkpoint includes the latest
+  * writes even when the WAL is disabled.
+  *
+  * Parent directories are created as needed. `targetPath` itself must not
+  * already exist (RocksDB creates the checkpoint directory) and rejects with
+  * `Create checkpoint failed: target path exists` if it does. The caller is
+  * responsible for eventual cleanup of the directory.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * await db.createCheckpoint('/path/to/checkpoint');
+  * const branch = RocksDatabase.open('/path/to/checkpoint');
+  * ```
+  */
+  createCheckpoint(targetPath: string): Promise<void>;
+  /**
   * Compacts the entire key range of the database synchronously.
   * This triggers manual compaction which removes tombstones and reclaims space.
   *

package/dist/index.d.mts

@@ -1189,6 +1189,7 @@ type NativeDatabase = {
   compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key): void;
   compactSync(start?: Key, end?: Key): void;
   columns: string[];
+  createCheckpoint(resolve: ResolveCallback<void>, reject: RejectCallback, targetPath: string): void;
   destroy(): void;
   drop(resolve: ResolveCallback<void>, reject: RejectCallback): void;
   dropSync(): void;
@@ -1823,6 +1824,31 @@ declare class RocksDatabase extends DBI<DBITransactional> {
   */
   backup(backupDir: string, options?: BackupOptions): Promise<number>;
   /**
+  * Creates a hardlinked, point-in-time, fully independent copy of the entire
+  * database (all column families) at `targetPath` and resolves once written.
+  *
+  * Unlike a backup, a checkpoint is a normal, writable sibling database: open
+  * it with {@link RocksDatabase.open} and it diverges independently from the
+  * source. SST and blob files are hardlinked when `targetPath` is on the same
+  * filesystem as the database and copied otherwise (other files such as the
+  * MANIFEST are always copied), so the operation is near-instant on the same
+  * filesystem. The memtable is flushed so the checkpoint includes the latest
+  * writes even when the WAL is disabled.
+  *
+  * Parent directories are created as needed. `targetPath` itself must not
+  * already exist (RocksDB creates the checkpoint directory) and rejects with
+  * `Create checkpoint failed: target path exists` if it does. The caller is
+  * responsible for eventual cleanup of the directory.
+  *
+  * @example
+  * ```typescript
+  * const db = RocksDatabase.open('/path/to/database');
+  * await db.createCheckpoint('/path/to/checkpoint');
+  * const branch = RocksDatabase.open('/path/to/checkpoint');
+  * ```
+  */
+  createCheckpoint(targetPath: string): Promise<void>;
+  /**
   * Compacts the entire key range of the database synchronously.
   * This triggers manual compaction which removes tombstones and reclaims space.
   *

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { execSync } from "node:child_process";
-import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { mkdir } from "node:fs/promises";
@@ -1502,6 +1502,40 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.backup(backupDir, options);
 	}
 	/**
+	* Creates a hardlinked, point-in-time, fully independent copy of the entire
+	* database (all column families) at `targetPath` and resolves once written.
+	*
+	* Unlike a backup, a checkpoint is a normal, writable sibling database: open
+	* it with {@link RocksDatabase.open} and it diverges independently from the
+	* source. SST and blob files are hardlinked when `targetPath` is on the same
+	* filesystem as the database and copied otherwise (other files such as the
+	* MANIFEST are always copied), so the operation is near-instant on the same
+	* filesystem. The memtable is flushed so the checkpoint includes the latest
+	* writes even when the WAL is disabled.
+	*
+	* Parent directories are created as needed. `targetPath` itself must not
+	* already exist (RocksDB creates the checkpoint directory) and rejects with
+	* `Create checkpoint failed: target path exists` if it does. The caller is
+	* responsible for eventual cleanup of the directory.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/database');
+	* await db.createCheckpoint('/path/to/checkpoint');
+	* const branch = RocksDatabase.open('/path/to/checkpoint');
+	* ```
+	*/
+	createCheckpoint(targetPath) {
+		return new Promise((resolve, reject) => {
+			if (existsSync(targetPath)) {
+				reject(/* @__PURE__ */ new Error("Create checkpoint failed: target path exists"));
+				return;
+			}
+			mkdirSync(dirname(targetPath), { recursive: true });
+			this.store.db.createCheckpoint(resolve, reject, targetPath);
+		});
+	}
+	/**
 	* Compacts the entire key range of the database synchronously.
 	* This triggers manual compaction which removes tombstones and reclaims space.
 	*
@@ -2350,7 +2384,7 @@ function loadLastPosition(transactionLog, readUncommitted) {
 //#region src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.2.0"
+	"rocksdb-js": "2.3.0"
 };
 
 //#endregion