@harperfast/rocksdb-js 2.6.0 → 2.7.0

package/dist/index.d.cts

@@ -255,6 +255,18 @@ type StoreRemoveOptions = DBITransactional | unknown;
 type CompactOptions = {
   start?: Key;
   end?: Key;
+  /**
+   * Compact the bottommost level as well, rewriting every file in range.
+   *
+   * RocksDB skips the bottommost level by default when no compaction filter is installed, and
+   * that is where most of the data sits — so an ordinary `compact()` leaves it untouched. Since a
+   * changed `compression` algorithm only governs newly written files, rewriting that level is the
+   * only way to re-encode data that already exists.
+   *
+   * This rewrites the whole range regardless of whether RocksDB considers it worth doing, so it
+   * is as expensive as the data is large. Defaults to `false`.
+   */
+  bottommost?: boolean;
 };
 /**
  * A RocksDB block/blob compression algorithm. Which algorithms are actually
@@ -302,6 +314,27 @@ interface StoreOptions extends Omit<NativeDatabaseOptions, "compression" | "comp
    * @default 'lz4'
    */
   compression?: CompressionOption;
+  /**
+   * Apply `compression` to every column family in the database, not only the one being opened.
+   *
+   * RocksDB opens all of a database's column families in a single native call, and by default
+   * each of the ones you did not name keeps its persisted algorithm. That is right when codecs
+   * are chosen per table, but it leaves a caller that wants one codec for the whole database
+   * unable to say so: those families are already open at their old algorithm before it gets a
+   * chance to ask, and a column family's compression cannot be changed while it is open.
+   *
+   * Setting this applies the requested algorithm to all of them instead — including families
+   * that were persisted with a different one, which is the point when adopting a codec on a
+   * database that predates it.
+   *
+   * Only meaningful with an explicit `compression` (it throws otherwise), and only on the open
+   * that actually creates the database handle; later opens of the same path reuse that handle
+   * and cannot revisit the decision. As always, the algorithm governs newly written files —
+   * existing SST/blob files keep theirs until rewritten (see `compact({ bottommost: true })`).
+   *
+   * @default false
+   */
+  compressionForAllColumnFamilies?: boolean;
   decoder?: Encoder | null;
   encoder?: Encoder | null;
   encoding?: Encoding;
@@ -375,6 +408,11 @@ declare class Store {
    * store's column family. Normalized and applied when the database opens.
    */
   compression?: CompressionOption;
+  /**
+   * Whether `compression` applies to every column family in the database rather than just this
+   * store's. See `RocksDatabaseOptions.compressionForAllColumnFamilies`.
+   */
+  compressionForAllColumnFamilies: boolean;
   /**
    * Whether to disable the write ahead log.
    */
@@ -750,6 +788,15 @@ declare class Transaction extends DBI {
    * @param options - The options for the transaction.
    */
   constructor(store: Store, options?: NativeTransactionOptions);
+  /**
+   * Release the staged writes' verification-table write intents without
+   * closing the transaction, barring any later commit or write. For a
+   * transaction kept open only for its outstanding read iterators after the
+   * writes were replayed onto another transaction: otherwise other writers'
+   * coordinated-retry commits park on those intents until it is aborted.
+   * Reads keep working, including read-your-own-writes.
+   */
+  abandonWrites(): void;
   /**
    * Abort the transaction.
    */
@@ -1605,6 +1652,7 @@ type NativeTransactionOptions = {
 type NativeTransaction = {
   id: number;
   new (context: NativeDatabase, options?: NativeTransactionOptions): NativeTransaction;
+  abandonWrites(): void;
   abort(): void;
   commit(resolve: (retrySignal?: number) => void, reject: (err: Error) => void): void;
   commitSync(): void;
@@ -1755,6 +1803,11 @@ type NativeDatabaseOptions = {
    * is algorithm-specific; omit to use the algorithm's default.
    */
   compressionLevel?: number;
+  /**
+   * Apply `compression` to every column family the underlying `DB::Open` opens, rather than
+   * only the one named by `name`. Requires an explicit `compression`.
+   */
+  compressionForAllColumnFamilies?: boolean;
   dbWriteBufferSize?: number;
   disableWAL?: boolean;
   enableStats?: boolean;
@@ -1812,8 +1865,8 @@ type NativeDatabase = {
   clear(resolve: ResolveCallback<void>, reject: RejectCallback): void;
   clearSync(): void;
   close(): void;
-  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key): void;
-  compactSync(start?: Key, end?: Key): void;
+  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key, bottommost?: boolean): void;
+  compactSync(start?: Key, end?: Key, bottommost?: boolean): void;
   columns: string[];
   createCheckpoint(resolve: ResolveCallback<void>, reject: RejectCallback, targetPath: string): void;
   destroy(): void;

package/dist/index.d.mts

@@ -255,6 +255,18 @@ type StoreRemoveOptions = DBITransactional | unknown;
 type CompactOptions = {
   start?: Key;
   end?: Key;
+  /**
+   * Compact the bottommost level as well, rewriting every file in range.
+   *
+   * RocksDB skips the bottommost level by default when no compaction filter is installed, and
+   * that is where most of the data sits — so an ordinary `compact()` leaves it untouched. Since a
+   * changed `compression` algorithm only governs newly written files, rewriting that level is the
+   * only way to re-encode data that already exists.
+   *
+   * This rewrites the whole range regardless of whether RocksDB considers it worth doing, so it
+   * is as expensive as the data is large. Defaults to `false`.
+   */
+  bottommost?: boolean;
 };
 /**
  * A RocksDB block/blob compression algorithm. Which algorithms are actually
@@ -302,6 +314,27 @@ interface StoreOptions extends Omit<NativeDatabaseOptions, "compression" | "comp
    * @default 'lz4'
    */
   compression?: CompressionOption;
+  /**
+   * Apply `compression` to every column family in the database, not only the one being opened.
+   *
+   * RocksDB opens all of a database's column families in a single native call, and by default
+   * each of the ones you did not name keeps its persisted algorithm. That is right when codecs
+   * are chosen per table, but it leaves a caller that wants one codec for the whole database
+   * unable to say so: those families are already open at their old algorithm before it gets a
+   * chance to ask, and a column family's compression cannot be changed while it is open.
+   *
+   * Setting this applies the requested algorithm to all of them instead — including families
+   * that were persisted with a different one, which is the point when adopting a codec on a
+   * database that predates it.
+   *
+   * Only meaningful with an explicit `compression` (it throws otherwise), and only on the open
+   * that actually creates the database handle; later opens of the same path reuse that handle
+   * and cannot revisit the decision. As always, the algorithm governs newly written files —
+   * existing SST/blob files keep theirs until rewritten (see `compact({ bottommost: true })`).
+   *
+   * @default false
+   */
+  compressionForAllColumnFamilies?: boolean;
   decoder?: Encoder | null;
   encoder?: Encoder | null;
   encoding?: Encoding;
@@ -375,6 +408,11 @@ declare class Store {
    * store's column family. Normalized and applied when the database opens.
    */
   compression?: CompressionOption;
+  /**
+   * Whether `compression` applies to every column family in the database rather than just this
+   * store's. See `RocksDatabaseOptions.compressionForAllColumnFamilies`.
+   */
+  compressionForAllColumnFamilies: boolean;
   /**
    * Whether to disable the write ahead log.
    */
@@ -750,6 +788,15 @@ declare class Transaction extends DBI {
    * @param options - The options for the transaction.
    */
   constructor(store: Store, options?: NativeTransactionOptions);
+  /**
+   * Release the staged writes' verification-table write intents without
+   * closing the transaction, barring any later commit or write. For a
+   * transaction kept open only for its outstanding read iterators after the
+   * writes were replayed onto another transaction: otherwise other writers'
+   * coordinated-retry commits park on those intents until it is aborted.
+   * Reads keep working, including read-your-own-writes.
+   */
+  abandonWrites(): void;
   /**
    * Abort the transaction.
    */
@@ -1605,6 +1652,7 @@ type NativeTransactionOptions = {
 type NativeTransaction = {
   id: number;
   new (context: NativeDatabase, options?: NativeTransactionOptions): NativeTransaction;
+  abandonWrites(): void;
   abort(): void;
   commit(resolve: (retrySignal?: number) => void, reject: (err: Error) => void): void;
   commitSync(): void;
@@ -1755,6 +1803,11 @@ type NativeDatabaseOptions = {
    * is algorithm-specific; omit to use the algorithm's default.
    */
   compressionLevel?: number;
+  /**
+   * Apply `compression` to every column family the underlying `DB::Open` opens, rather than
+   * only the one named by `name`. Requires an explicit `compression`.
+   */
+  compressionForAllColumnFamilies?: boolean;
   dbWriteBufferSize?: number;
   disableWAL?: boolean;
   enableStats?: boolean;
@@ -1812,8 +1865,8 @@ type NativeDatabase = {
   clear(resolve: ResolveCallback<void>, reject: RejectCallback): void;
   clearSync(): void;
   close(): void;
-  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key): void;
-  compactSync(start?: Key, end?: Key): void;
+  compact(resolve: ResolveCallback<void>, reject: RejectCallback, start?: Key, end?: Key, bottommost?: boolean): void;
+  compactSync(start?: Key, end?: Key, bottommost?: boolean): void;
   columns: string[];
   createCheckpoint(resolve: ResolveCallback<void>, reject: RejectCallback, targetPath: string): void;
   destroy(): void;

package/dist/index.mjs

@@ -1213,9 +1213,10 @@ const MAX_KEY_SIZE = 1024 * 1024;
 const SAVE_BUFFER_SIZE = 8192;
 /**
 * Normalizes the public `compression` option into the primitive fields the
-* native layer expects. When `option` is omitted, returns an empty object and
-* lets the native layer apply the default (LZ4 when the build supports it, else
-* RocksDB's own default). Throws a `TypeError` for a malformed option and an
+* native layer expects. When `option` is omitted, or is an object without an
+* `algorithm`, returns an empty object and lets the native layer apply the
+* default (LZ4 when the build supports it, else RocksDB's own default).
+* Throws a `TypeError` for a malformed option and an
 * `Error` for an algorithm that isn't supported by this build.
 */
 function normalizeCompression(option) {
@@ -1223,7 +1224,11 @@ function normalizeCompression(option) {
 	let algorithm;
 	let level;
 	if (typeof option === "string") algorithm = option;
-	else if (typeof option === "object" && option.algorithm !== void 0) {
+	else if (typeof option === "object" && !Array.isArray(option)) {
+		if (option.algorithm === void 0 || option.algorithm === null) {
+			if (option.level !== void 0 && option.level !== null) throw new TypeError("Compression level cannot be specified without an algorithm");
+			return {};
+		}
 		algorithm = option.algorithm;
 		if (option.level !== void 0 && option.level !== null) {
 			const raw = option.level;
@@ -1275,6 +1280,11 @@ var Store = class {
 	*/
 	compression;
 	/**
+	* Whether `compression` applies to every column family in the database rather than just this
+	* store's. See `RocksDatabaseOptions.compressionForAllColumnFamilies`.
+	*/
+	compressionForAllColumnFamilies = false;
+	/**
 	* Whether to disable the write ahead log.
 	*/
 	disableWAL;
@@ -1433,6 +1443,7 @@ var Store = class {
 		const { keyEncoding, readKey, writeKey } = initKeyEncoder(options?.keyEncoding, options?.keyEncoder);
 		this.db = new NativeDatabase();
 		this.compression = options?.compression;
+		this.compressionForAllColumnFamilies = options?.compressionForAllColumnFamilies === true;
 		this.dbWriteBufferSize = options?.dbWriteBufferSize;
 		this.decoder = options?.decoder ?? null;
 		this.disableWAL = options?.disableWAL ?? false;
@@ -1502,7 +1513,7 @@ var Store = class {
 			const end = this.encodeKey(options.end);
 			endBuffer = Buffer.from(end.subarray(end.start, end.end));
 		}
-		return new Promise((resolve, reject) => this.db.compact(resolve, reject, startBuffer, endBuffer));
+		return new Promise((resolve, reject) => this.db.compact(resolve, reject, startBuffer, endBuffer, options?.bottommost === true));
 	}
 	async backup(target, options) {
 		if (typeof target !== "string" && typeof target?.getWriter === "function") return backupToStream(this.db, target, options);
@@ -1530,7 +1541,7 @@ var Store = class {
 			const end = this.encodeKey(options.end);
 			endBuffer = Buffer.from(end.subarray(end.start, end.end));
 		}
-		this.db.compactSync(startBuffer, endBuffer);
+		this.db.compactSync(startBuffer, endBuffer, options?.bottommost === true);
 	}
 	/**
 	* Decodes a key from the database.
@@ -1747,6 +1758,7 @@ var Store = class {
 		this.db.open(this.path, {
 			compression,
 			compressionLevel,
+			compressionForAllColumnFamilies: this.compressionForAllColumnFamilies,
 			dbWriteBufferSize: this.dbWriteBufferSize,
 			disableWAL: this.disableWAL,
 			enableStats: this.enableStats,
@@ -1929,7 +1941,7 @@ var Transaction = class extends DBI {
 		if (store.readOnly) {
 			super(store);
 			this.#txn = { id: 0 };
-			this.abort = this.commitSync = this.setTimestamp = () => {};
+			this.abandonWrites = this.abort = this.commitSync = this.setTimestamp = () => {};
 			this.commit = async () => {};
 			this.getTimestamp = () => 0;
 		} else {
@@ -1939,6 +1951,17 @@ var Transaction = class extends DBI {
 		}
 	}
 	/**
+	* Release the staged writes' verification-table write intents without
+	* closing the transaction, barring any later commit or write. For a
+	* transaction kept open only for its outstanding read iterators after the
+	* writes were replayed onto another transaction: otherwise other writers'
+	* coordinated-retry commits park on those intents until it is aborted.
+	* Reads keep working, including read-your-own-writes.
+	*/
+	abandonWrites() {
+		this.#txn.abandonWrites();
+	}
+	/**
 	* Abort the transaction.
 	*/
 	abort() {
@@ -3012,7 +3035,7 @@ function loadLastPosition(transactionLog, readUncommitted) {
 //#region src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.6.0"
+	"rocksdb-js": "2.7.0"
 };
 
 //#endregion