node-sqlite-kv 0.3.0 → 0.4.0

package/README.md

@@ -78,6 +78,9 @@ const { oldValues, newValues } = kv.transaction((tx) => {
 
 // delete all entries
 kv.clear();
+
+// close the database
+kv.close();
 ```
 
 ## Contributing

package/dist/index.cjs

@@ -0,0 +1,221 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_sqlite = require("node:sqlite");
+let node_v8 = require("node:v8");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+
+//#region src/classes/KVError.ts
+/**
+* Class representing a KVError
+*/
+var KVError = class extends Error {
+	static name = "KVError";
+	scope;
+	constructor(scope, ...args) {
+		super(args.join(" "));
+		this.scope = scope;
+		Error.captureStackTrace?.(this, this.constructor);
+	}
+	get name() {
+		return `${this.constructor.name} (${this.scope})`;
+	}
+};
+
+//#endregion
+//#region src/utils/index.ts
+/**
+* A list of journal modes SQLite supports
+*/
+const journalModes = {
+	Delete: "DELETE",
+	Memory: "MEMORY",
+	Off: "OFF",
+	Persist: "PERSIST",
+	Truncate: "TRUNCATE",
+	WAL: "WAL"
+};
+
+//#endregion
+//#region src/classes/KVSync.ts
+/**
+* Class representing a synchronous key-value store
+*/
+var KVSync = class {
+	#db;
+	/**
+	* Instantiate a new key-value store
+	* @param options KVSync options
+	*/
+	constructor(options) {
+		const dbPath = options?.path ?? ":memory:";
+		if (dbPath !== ":memory:") node_fs.default.mkdirSync(node_path.default.dirname(dbPath), { recursive: true });
+		this.#db = new node_sqlite.DatabaseSync(dbPath);
+		this.setJournalMode(options?.journalMode ?? (dbPath !== ":memory:" ? journalModes.WAL : journalModes.Delete));
+		this.#db.exec("CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY NOT NULL, value BLOB NOT NULL) STRICT;");
+	}
+	/**
+	* Set a key in the database
+	* @param key Key name
+	* @param value Key value
+	* @returns Provided value
+	*/
+	set(key, value) {
+		if (!this.#db.isOpen) throw new KVError("set", "Database is not open");
+		if (!key || typeof key !== "string") throw new KVError("set", "Key must be provided and be a non-empty string");
+		if (value === void 0) throw new KVError("set", "Provided value is undefined, did you mean to use delete()?");
+		this.#db.prepare("INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)").run(key, (0, node_v8.serialize)(value));
+		return value;
+	}
+	/**
+	* Get a value from the database
+	* @param key Key name
+	* @returns Value or null
+	*/
+	get(key) {
+		if (!this.#db.isOpen) throw new KVError("get", "Database is not open");
+		if (!key || typeof key !== "string") throw new KVError("get", "Key must be provided and be a non-empty string.");
+		const row = this.#db.prepare("SELECT value FROM kv WHERE key = ?;").get(key);
+		return row ? (0, node_v8.deserialize)(row.value) : null;
+	}
+	/**
+	* Delete a key from the database
+	* @param key Key name
+	* @returns KVSync instance
+	*/
+	delete(key) {
+		if (!this.#db.isOpen) throw new KVError("delete", "Database is not open");
+		if (!key || typeof key !== "string") throw new KVError("delete", "Key must be provided and be a non-empty string.");
+		this.#db.prepare("DELETE FROM kv WHERE key = ?;").run(key);
+		return this;
+	}
+	/**
+	* Get all data in the database
+	* @returns Array of objects containing keys and values
+	*/
+	all(filter) {
+		if (!this.#db.isOpen) throw new KVError("all", "Database is not open");
+		const rows = this.#db.prepare("SELECT key, value FROM kv").iterate();
+		const result = [];
+		for (const row of rows) {
+			const key = row.key;
+			const value = (0, node_v8.deserialize)(row.value);
+			if (!filter || filter(key, value)) result.push({
+				key,
+				value
+			});
+		}
+		return result;
+	}
+	/**
+	* Remove all entries from the database
+	*/
+	clear() {
+		if (!this.#db.isOpen) throw new KVError("clear", "Database is not open");
+		this.#db.exec("DELETE FROM kv;");
+		return this;
+	}
+	/**
+	* Update the journal mode
+	* @param mode New journal mode
+	*/
+	setJournalMode(mode) {
+		if (!this.#db.isOpen) throw new KVError("setJournalMode", "Database is not open");
+		if (!Object.values(journalModes).includes(mode)) throw new KVError("setJournalMode", `Invalid journal mode specified - received: "${mode}", expected one of: ${Object.values(journalModes).join(", ")}`);
+		this.#db.exec(`PRAGMA journal_mode = ${mode};`);
+		return this;
+	}
+	/**
+	* Perform a transaction
+	* @param callback Callback with KVSync instance
+	* @returns Object containing oldValues and newValues each containing arrays of keys and values
+	*/
+	transaction(callback) {
+		if (!this.#db.isOpen) throw new KVError("transaction", "Database is not open");
+		if (!callback) throw new KVError("transaction", "A callback must be provided when using transaction().");
+		if (typeof callback !== "function") throw new KVError("transaction", `Transaction callback must be of type function. Received: ${typeof callback}`);
+		const oldMap = /* @__PURE__ */ new Map();
+		const newMap = /* @__PURE__ */ new Map();
+		const tx = Object.create(this);
+		tx.set = (key, value) => {
+			if (!oldMap.has(key)) {
+				const oldValue = this.get(key);
+				oldMap.set(key, oldValue === null ? void 0 : oldValue);
+			}
+			newMap.set(key, value);
+			return value ?? null;
+		};
+		tx.delete = (key) => {
+			if (!oldMap.has(key)) {
+				const oldValue = this.get(key);
+				oldMap.set(key, oldValue === null ? void 0 : oldValue);
+			}
+			newMap.set(key, null);
+			return tx;
+		};
+		try {
+			this.#db.exec("BEGIN TRANSACTION;");
+			callback(tx);
+			for (const [key, value] of newMap.entries()) if (value === null) this.delete(key);
+			else this.set(key, value);
+			this.#db.exec("COMMIT;");
+		} catch (error) {
+			this.#db.exec("ROLLBACK;");
+			throw error;
+		}
+		return {
+			oldValues: Array.from(oldMap.entries()).map(([key, value]) => ({
+				key,
+				value
+			})),
+			newValues: Array.from(newMap.entries()).map(([key, value]) => ({
+				key,
+				value
+			}))
+		};
+	}
+	/**
+	* Open the database
+	*/
+	open() {
+		if (this.#db.isOpen) throw new KVError("open", "Database is open");
+	}
+	/**
+	* Close the database
+	*/
+	close() {
+		if (!this.#db.isOpen) throw new KVError("close", "Database is not open");
+		this.#db.close();
+	}
+};
+
+//#endregion
+exports.KVSync = KVSync;
+exports.journalModes = journalModes;

package/dist/index.d.cts

@@ -0,0 +1,46 @@
+//#region src/utils/index.d.ts
+declare const journalModes: {
+  readonly Delete: "DELETE";
+  readonly Memory: "MEMORY";
+  readonly Off: "OFF";
+  readonly Persist: "PERSIST";
+  readonly Truncate: "TRUNCATE";
+  readonly WAL: "WAL";
+};
+//#endregion
+//#region src/types.d.ts
+type JournalMode = (typeof journalModes)[keyof typeof journalModes];
+interface KVSyncOptions {
+  path?: SQLitePath;
+  journalMode?: JournalMode;
+}
+type SQLitePath = ":memory:" | (string & {});
+//#endregion
+//#region src/classes/KVSync.d.ts
+declare class KVSync<T = any> {
+  #private;
+  constructor(options?: KVSyncOptions);
+  set<K = T>(key: string, value: K | undefined): K;
+  get<K = T>(key: string): K | null;
+  delete(key: string): KVSync;
+  all<K = T>(filter?: (key: string, value: K) => boolean): {
+    key: string;
+    value: K;
+  }[];
+  clear(): KVSync;
+  setJournalMode(mode: JournalMode): this;
+  transaction<R>(callback: (kv: KVSync<T>) => R): {
+    oldValues: {
+      key: string;
+      value: T | null | undefined;
+    }[];
+    newValues: {
+      key: string;
+      value: T | null;
+    }[];
+  };
+  open(): void;
+  close(): void;
+}
+//#endregion
+export { JournalMode, KVSync, KVSyncOptions, SQLitePath, journalModes };

package/dist/index.d.mts

@@ -1,32 +1,46 @@
-type JournalMode = "DELETE" | "MEMORY" | "OFF" | "PERSIST" | "TRUNCATE" | "WAL";
+//#region src/utils/index.d.ts
+declare const journalModes: {
+  readonly Delete: "DELETE";
+  readonly Memory: "MEMORY";
+  readonly Off: "OFF";
+  readonly Persist: "PERSIST";
+  readonly Truncate: "TRUNCATE";
+  readonly WAL: "WAL";
+};
+//#endregion
+//#region src/types.d.ts
+type JournalMode = (typeof journalModes)[keyof typeof journalModes];
 interface KVSyncOptions {
-    path?: SQLitePath;
-    journalMode?: JournalMode;
+  path?: SQLitePath;
+  journalMode?: JournalMode;
 }
 type SQLitePath = ":memory:" | (string & {});
-declare const journalModes: JournalMode[];
+//#endregion
+//#region src/classes/KVSync.d.ts
 declare class KVSync<T = any> {
-    #private;
-    constructor(options?: KVSyncOptions);
-    set<K = T>(key: string, value: K | undefined): K | null;
-    get<K = T>(key: string): K | null;
-    delete(key: string): KVSync;
-    all<K = T>(filter?: (key: string, value: K) => boolean): {
-        key: string;
-        value: K;
+  #private;
+  constructor(options?: KVSyncOptions);
+  set<K = T>(key: string, value: K | undefined): K;
+  get<K = T>(key: string): K | null;
+  delete(key: string): KVSync;
+  all<K = T>(filter?: (key: string, value: K) => boolean): {
+    key: string;
+    value: K;
+  }[];
+  clear(): KVSync;
+  setJournalMode(mode: JournalMode): this;
+  transaction<R>(callback: (kv: KVSync<T>) => R): {
+    oldValues: {
+      key: string;
+      value: T | null | undefined;
     }[];
-    clear(): KVSync;
-    setJournalMode(mode: JournalMode): this;
-    transaction<R>(callback: (kv: KVSync<T>) => R): {
-        oldValues: {
-            key: string;
-            value: T | null | undefined;
-        }[];
-        newValues: {
-            key: string;
-            value: T | null;
-        }[];
-    };
+    newValues: {
+      key: string;
+      value: T | null;
+    }[];
+  };
+  open(): void;
+  close(): void;
 }
-
-export { type JournalMode, KVSync, type KVSyncOptions, type SQLitePath, journalModes };
+//#endregion
+export { JournalMode, KVSync, KVSyncOptions, SQLitePath, journalModes };

package/dist/index.mjs

@@ -1,183 +1,191 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/index.ts
 import { DatabaseSync } from "node:sqlite";
-import { serialize, deserialize } from "node:v8";
+import { deserialize, serialize } from "node:v8";
 import fs from "node:fs";
 import path from "node:path";
-var journalModes = [
-  "DELETE",
-  "MEMORY",
-  "OFF",
-  "PERSIST",
-  "TRUNCATE",
-  "WAL"
-];
-var KVSync = class {
-  static {
-    __name(this, "KVSync");
-  }
-  #db;
-  /**
-   * Instantiate a new key-value store
-   * @param path Where the database is stored, or `:memory:` for in-memory storage
-   */
-  constructor(options) {
-    const dbPath = options?.path ?? ":memory:";
-    if (dbPath !== ":memory:") {
-      fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-    }
-    this.#db = new DatabaseSync(dbPath);
-    this.setJournalMode(options?.journalMode ?? "DELETE");
-    this.#db.exec(`
-            CREATE TABLE IF NOT EXISTS kv (
-                key TEXT PRIMARY KEY NOT NULL,
-                value BLOB NOT NULL
-            ) STRICT;
-        `);
-  }
-  /**
-   * Set a key in the database
-   * @param key Key name
-   * @param value Key value
-   * @returns Provided value
-   */
-  set(key, value) {
-    if (!key || typeof key !== "string") {
-      throw new Error(
-        "[KVSync]: Key must be provided and be a non-empty string."
-      );
-    }
-    if (value === void 0) {
-      this.delete(key);
-      return null;
-    }
-    this.#db.prepare("INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)").run(key, serialize(value));
-    return value;
-  }
-  /**
-   * Get a value from the database
-   * @param key Key name
-   * @returns Value or null
-   */
-  get(key) {
-    if (!key || typeof key !== "string") {
-      throw new Error(
-        "[KVSync]: Key must be provided and be a non-empty string."
-      );
-    }
-    const row = this.#db.prepare("SELECT value FROM kv WHERE key = ?").get(key);
-    return row ? deserialize(row.value) : null;
-  }
-  /**
-   * Delete a key from the database
-   * @param key Key name
-   * @returns KVSync instance
-   */
-  delete(key) {
-    if (!key || typeof key !== "string") {
-      throw new Error(
-        "[KVSync]: Key must be provided and be a non-empty string."
-      );
-    }
-    this.#db.prepare("DELETE FROM kv WHERE key = ?").run(key);
-    return this;
-  }
-  /**
-   * Get all data in the database
-   * @returns Array of objects containing keys and values
-   */
-  all(filter) {
-    const rows = this.#db.prepare("SELECT key, value FROM kv").iterate();
-    const result = [];
-    for (const row of rows) {
-      const key = row.key;
-      const value = deserialize(row.value);
-      if (!filter || filter(key, value)) {
-        result.push({ key, value });
-      }
-    }
-    return result;
-  }
-  /**
-   * Remove all entries from the database
-   */
-  clear() {
-    this.#db.exec("DELETE FROM kv;");
-    return this;
-  }
-  /**
-   * Update the journal mode
-   * @param mode New journal mode
-   */
-  setJournalMode(mode) {
-    if (!journalModes.includes(mode)) {
-      throw new Error(
-        `[KVSync]: Invalid journal mode specified. Received: "${mode}", expected one of: ${journalModes.join(", ")}`
-      );
-    }
-    this.#db.exec(`PRAGMA journal_mode = ${mode};`);
-    return this;
-  }
-  /**
-   * Perform a transaction
-   * @param callback Callback with KVSync instance
-   * @returns Object containing oldValues and newValues each containing arrays of keys and values
-   */
-  transaction(callback) {
-    if (!callback) {
-      throw new Error(
-        "[KVSync]: A callback must be provided when using transaction()."
-      );
-    }
-    if (typeof callback !== "function") {
-      throw new Error(
-        `[KVSync]: Transaction callback must be of type function. Received: ${typeof callback}`
-      );
-    }
-    this.#db.exec("BEGIN TRANSACTION;");
-    const oldMap = /* @__PURE__ */ new Map();
-    const newMap = /* @__PURE__ */ new Map();
-    const tx = Object.create(this);
-    tx.set = (key, value) => {
-      if (!oldMap.has(key)) {
-        const oldValue = this.get(key);
-        oldMap.set(key, oldValue === null ? void 0 : oldValue);
-      }
-      const result = this.set(key, value);
-      newMap.set(key, result);
-      return result;
-    };
-    tx.delete = (key) => {
-      if (!oldMap.has(key)) {
-        const oldValue = this.get(key);
-        oldMap.set(key, oldValue === null ? void 0 : oldValue);
-      }
-      newMap.set(key, null);
-      this.delete(key);
-      return tx;
-    };
-    try {
-      callback(tx);
-      this.#db.exec("COMMIT;");
-    } catch (error) {
-      this.#db.exec("ROLLBACK;");
-      throw error;
-    }
-    return {
-      oldValues: Array.from(oldMap.entries()).map(([key, value]) => ({
-        key,
-        value
-      })),
-      newValues: Array.from(newMap.entries()).map(([key, value]) => ({
-        key,
-        value
-      }))
-    };
-  }
+
+//#region src/classes/KVError.ts
+/**
+* Class representing a KVError
+*/
+var KVError = class extends Error {
+	static name = "KVError";
+	scope;
+	constructor(scope, ...args) {
+		super(args.join(" "));
+		this.scope = scope;
+		Error.captureStackTrace?.(this, this.constructor);
+	}
+	get name() {
+		return `${this.constructor.name} (${this.scope})`;
+	}
+};
+
+//#endregion
+//#region src/utils/index.ts
+/**
+* A list of journal modes SQLite supports
+*/
+const journalModes = {
+	Delete: "DELETE",
+	Memory: "MEMORY",
+	Off: "OFF",
+	Persist: "PERSIST",
+	Truncate: "TRUNCATE",
+	WAL: "WAL"
 };
-export {
-  KVSync,
-  journalModes
+
+//#endregion
+//#region src/classes/KVSync.ts
+/**
+* Class representing a synchronous key-value store
+*/
+var KVSync = class {
+	#db;
+	/**
+	* Instantiate a new key-value store
+	* @param options KVSync options
+	*/
+	constructor(options) {
+		const dbPath = options?.path ?? ":memory:";
+		if (dbPath !== ":memory:") fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+		this.#db = new DatabaseSync(dbPath);
+		this.setJournalMode(options?.journalMode ?? (dbPath !== ":memory:" ? journalModes.WAL : journalModes.Delete));
+		this.#db.exec("CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY NOT NULL, value BLOB NOT NULL) STRICT;");
+	}
+	/**
+	* Set a key in the database
+	* @param key Key name
+	* @param value Key value
+	* @returns Provided value
+	*/
+	set(key, value) {
+		if (!this.#db.isOpen) throw new KVError("set", "Database is not open");
+		if (!key || typeof key !== "string") throw new KVError("set", "Key must be provided and be a non-empty string");
+		if (value === void 0) throw new KVError("set", "Provided value is undefined, did you mean to use delete()?");
+		this.#db.prepare("INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)").run(key, serialize(value));
+		return value;
+	}
+	/**
+	* Get a value from the database
+	* @param key Key name
+	* @returns Value or null
+	*/
+	get(key) {
+		if (!this.#db.isOpen) throw new KVError("get", "Database is not open");
+		if (!key || typeof key !== "string") throw new KVError("get", "Key must be provided and be a non-empty string.");
+		const row = this.#db.prepare("SELECT value FROM kv WHERE key = ?;").get(key);
+		return row ? deserialize(row.value) : null;
+	}
+	/**
+	* Delete a key from the database
+	* @param key Key name
+	* @returns KVSync instance
+	*/
+	delete(key) {
+		if (!this.#db.isOpen) throw new KVError("delete", "Database is not open");
+		if (!key || typeof key !== "string") throw new KVError("delete", "Key must be provided and be a non-empty string.");
+		this.#db.prepare("DELETE FROM kv WHERE key = ?;").run(key);
+		return this;
+	}
+	/**
+	* Get all data in the database
+	* @returns Array of objects containing keys and values
+	*/
+	all(filter) {
+		if (!this.#db.isOpen) throw new KVError("all", "Database is not open");
+		const rows = this.#db.prepare("SELECT key, value FROM kv").iterate();
+		const result = [];
+		for (const row of rows) {
+			const key = row.key;
+			const value = deserialize(row.value);
+			if (!filter || filter(key, value)) result.push({
+				key,
+				value
+			});
+		}
+		return result;
+	}
+	/**
+	* Remove all entries from the database
+	*/
+	clear() {
+		if (!this.#db.isOpen) throw new KVError("clear", "Database is not open");
+		this.#db.exec("DELETE FROM kv;");
+		return this;
+	}
+	/**
+	* Update the journal mode
+	* @param mode New journal mode
+	*/
+	setJournalMode(mode) {
+		if (!this.#db.isOpen) throw new KVError("setJournalMode", "Database is not open");
+		if (!Object.values(journalModes).includes(mode)) throw new KVError("setJournalMode", `Invalid journal mode specified - received: "${mode}", expected one of: ${Object.values(journalModes).join(", ")}`);
+		this.#db.exec(`PRAGMA journal_mode = ${mode};`);
+		return this;
+	}
+	/**
+	* Perform a transaction
+	* @param callback Callback with KVSync instance
+	* @returns Object containing oldValues and newValues each containing arrays of keys and values
+	*/
+	transaction(callback) {
+		if (!this.#db.isOpen) throw new KVError("transaction", "Database is not open");
+		if (!callback) throw new KVError("transaction", "A callback must be provided when using transaction().");
+		if (typeof callback !== "function") throw new KVError("transaction", `Transaction callback must be of type function. Received: ${typeof callback}`);
+		const oldMap = /* @__PURE__ */ new Map();
+		const newMap = /* @__PURE__ */ new Map();
+		const tx = Object.create(this);
+		tx.set = (key, value) => {
+			if (!oldMap.has(key)) {
+				const oldValue = this.get(key);
+				oldMap.set(key, oldValue === null ? void 0 : oldValue);
+			}
+			newMap.set(key, value);
+			return value ?? null;
+		};
+		tx.delete = (key) => {
+			if (!oldMap.has(key)) {
+				const oldValue = this.get(key);
+				oldMap.set(key, oldValue === null ? void 0 : oldValue);
+			}
+			newMap.set(key, null);
+			return tx;
+		};
+		try {
+			this.#db.exec("BEGIN TRANSACTION;");
+			callback(tx);
+			for (const [key, value] of newMap.entries()) if (value === null) this.delete(key);
+			else this.set(key, value);
+			this.#db.exec("COMMIT;");
+		} catch (error) {
+			this.#db.exec("ROLLBACK;");
+			throw error;
+		}
+		return {
+			oldValues: Array.from(oldMap.entries()).map(([key, value]) => ({
+				key,
+				value
+			})),
+			newValues: Array.from(newMap.entries()).map(([key, value]) => ({
+				key,
+				value
+			}))
+		};
+	}
+	/**
+	* Open the database
+	*/
+	open() {
+		if (this.#db.isOpen) throw new KVError("open", "Database is open");
+	}
+	/**
+	* Close the database
+	*/
+	close() {
+		if (!this.#db.isOpen) throw new KVError("close", "Database is not open");
+		this.#db.close();
+	}
 };
+
+//#endregion
+export { KVSync, journalModes };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-sqlite-kv",
   "description": "Key-value store with node:sqlite",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "repository": {
     "url": "https://github.com/e60m5ss/node-sqlite-kv"
   },
@@ -9,16 +9,23 @@
     "name": "e60m5ss",
     "url": "https://github.com/e60m5ss"
   },
-  "main": "./dist/index.js",
+  "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.mts",
+  "type": "module",
+  "exports": {
+    "default": "./dist/index.cjs",
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.cjs",
+    "types": "./dist/index.d.cts"
+  },
   "engineStrict": true,
   "engines": {
     "node": ">=22.5.0"
   },
   "prettier": {
     "jsxSingleQuote": false,
-    "printWidth": 85,
+    "printWidth": 80,
     "semi": true,
     "singleQuote": false,
     "tabWidth": 4,
@@ -26,15 +33,15 @@
     "useTabs": false
   },
   "devDependencies": {
-    "@types/node": "^25.1.0",
+    "@types/node": "^25.2.0",
     "prettier": "^3.8.1",
-    "tsup": "^8.5.1",
+    "tsdown": "^0.20.1",
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "format": "prettier ./src --write --ignore-path=.prettierignore",
     "lint": "tsc --noEmit; prettier ./src --check --ignore-path=.prettierignore",
-    "prepublish": "tsup"
+    "prepublish": "tsdown"
   }
 }

package/dist/index.d.ts

@@ -1,32 +0,0 @@
-type JournalMode = "DELETE" | "MEMORY" | "OFF" | "PERSIST" | "TRUNCATE" | "WAL";
-interface KVSyncOptions {
-    path?: SQLitePath;
-    journalMode?: JournalMode;
-}
-type SQLitePath = ":memory:" | (string & {});
-declare const journalModes: JournalMode[];
-declare class KVSync<T = any> {
-    #private;
-    constructor(options?: KVSyncOptions);
-    set<K = T>(key: string, value: K | undefined): K | null;
-    get<K = T>(key: string): K | null;
-    delete(key: string): KVSync;
-    all<K = T>(filter?: (key: string, value: K) => boolean): {
-        key: string;
-        value: K;
-    }[];
-    clear(): KVSync;
-    setJournalMode(mode: JournalMode): this;
-    transaction<R>(callback: (kv: KVSync<T>) => R): {
-        oldValues: {
-            key: string;
-            value: T | null | undefined;
-        }[];
-        newValues: {
-            key: string;
-            value: T | null;
-        }[];
-    };
-}
-
-export { type JournalMode, KVSync, type KVSyncOptions, type SQLitePath, journalModes };

package/dist/index.js

@@ -1,217 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  KVSync: () => KVSync,
-  journalModes: () => journalModes
-});
-module.exports = __toCommonJS(index_exports);
-var import_node_sqlite = require("node:sqlite");
-var import_node_v8 = require("node:v8");
-var import_node_fs = __toESM(require("node:fs"));
-var import_node_path = __toESM(require("node:path"));
-var journalModes = [
-  "DELETE",
-  "MEMORY",
-  "OFF",
-  "PERSIST",
-  "TRUNCATE",
-  "WAL"
-];
-var KVSync = class {
-  static {
-    __name(this, "KVSync");
-  }
-  #db;
-  /**
-   * Instantiate a new key-value store
-   * @param path Where the database is stored, or `:memory:` for in-memory storage
-   */
-  constructor(options) {
-    const dbPath = options?.path ?? ":memory:";
-    if (dbPath !== ":memory:") {
-      import_node_fs.default.mkdirSync(import_node_path.default.dirname(dbPath), { recursive: true });
-    }
-    this.#db = new import_node_sqlite.DatabaseSync(dbPath);
-    this.setJournalMode(options?.journalMode ?? "DELETE");
-    this.#db.exec(`
-            CREATE TABLE IF NOT EXISTS kv (
-                key TEXT PRIMARY KEY NOT NULL,
-                value BLOB NOT NULL
-            ) STRICT;
-        `);
-  }
-  /**
-   * Set a key in the database
-   * @param key Key name
-   * @param value Key value
-   * @returns Provided value
-   */
-  set(key, value) {
-    if (!key || typeof key !== "string") {
-      throw new Error(
-        "[KVSync]: Key must be provided and be a non-empty string."
-      );
-    }
-    if (value === void 0) {
-      this.delete(key);
-      return null;
-    }
-    this.#db.prepare("INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)").run(key, (0, import_node_v8.serialize)(value));
-    return value;
-  }
-  /**
-   * Get a value from the database
-   * @param key Key name
-   * @returns Value or null
-   */
-  get(key) {
-    if (!key || typeof key !== "string") {
-      throw new Error(
-        "[KVSync]: Key must be provided and be a non-empty string."
-      );
-    }
-    const row = this.#db.prepare("SELECT value FROM kv WHERE key = ?").get(key);
-    return row ? (0, import_node_v8.deserialize)(row.value) : null;
-  }
-  /**
-   * Delete a key from the database
-   * @param key Key name
-   * @returns KVSync instance
-   */
-  delete(key) {
-    if (!key || typeof key !== "string") {
-      throw new Error(
-        "[KVSync]: Key must be provided and be a non-empty string."
-      );
-    }
-    this.#db.prepare("DELETE FROM kv WHERE key = ?").run(key);
-    return this;
-  }
-  /**
-   * Get all data in the database
-   * @returns Array of objects containing keys and values
-   */
-  all(filter) {
-    const rows = this.#db.prepare("SELECT key, value FROM kv").iterate();
-    const result = [];
-    for (const row of rows) {
-      const key = row.key;
-      const value = (0, import_node_v8.deserialize)(row.value);
-      if (!filter || filter(key, value)) {
-        result.push({ key, value });
-      }
-    }
-    return result;
-  }
-  /**
-   * Remove all entries from the database
-   */
-  clear() {
-    this.#db.exec("DELETE FROM kv;");
-    return this;
-  }
-  /**
-   * Update the journal mode
-   * @param mode New journal mode
-   */
-  setJournalMode(mode) {
-    if (!journalModes.includes(mode)) {
-      throw new Error(
-        `[KVSync]: Invalid journal mode specified. Received: "${mode}", expected one of: ${journalModes.join(", ")}`
-      );
-    }
-    this.#db.exec(`PRAGMA journal_mode = ${mode};`);
-    return this;
-  }
-  /**
-   * Perform a transaction
-   * @param callback Callback with KVSync instance
-   * @returns Object containing oldValues and newValues each containing arrays of keys and values
-   */
-  transaction(callback) {
-    if (!callback) {
-      throw new Error(
-        "[KVSync]: A callback must be provided when using transaction()."
-      );
-    }
-    if (typeof callback !== "function") {
-      throw new Error(
-        `[KVSync]: Transaction callback must be of type function. Received: ${typeof callback}`
-      );
-    }
-    this.#db.exec("BEGIN TRANSACTION;");
-    const oldMap = /* @__PURE__ */ new Map();
-    const newMap = /* @__PURE__ */ new Map();
-    const tx = Object.create(this);
-    tx.set = (key, value) => {
-      if (!oldMap.has(key)) {
-        const oldValue = this.get(key);
-        oldMap.set(key, oldValue === null ? void 0 : oldValue);
-      }
-      const result = this.set(key, value);
-      newMap.set(key, result);
-      return result;
-    };
-    tx.delete = (key) => {
-      if (!oldMap.has(key)) {
-        const oldValue = this.get(key);
-        oldMap.set(key, oldValue === null ? void 0 : oldValue);
-      }
-      newMap.set(key, null);
-      this.delete(key);
-      return tx;
-    };
-    try {
-      callback(tx);
-      this.#db.exec("COMMIT;");
-    } catch (error) {
-      this.#db.exec("ROLLBACK;");
-      throw error;
-    }
-    return {
-      oldValues: Array.from(oldMap.entries()).map(([key, value]) => ({
-        key,
-        value
-      })),
-      newValues: Array.from(newMap.entries()).map(([key, value]) => ({
-        key,
-        value
-      }))
-    };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  KVSync,
-  journalModes
-});