node-sqlite-kv 0.2.1 → 0.3.0

package/dist/index.d.mts

@@ -4,18 +4,18 @@ interface KVSyncOptions {
     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): K;
+    set<K = T>(key: string, value: K | undefined): K | null;
     get<K = T>(key: string): K | null;
-    delete<K = T>(key: string): K | null;
-    all<K = T>(): {
+    delete(key: string): KVSync;
+    all<K = T>(filter?: (key: string, value: K) => boolean): {
         key: string;
         value: K;
     }[];
-    clear(): void;
+    clear(): KVSync;
     setJournalMode(mode: JournalMode): this;
     transaction<R>(callback: (kv: KVSync<T>) => R): {
         oldValues: {
@@ -29,4 +29,4 @@ declare class KVSync<T = any> {
     };
 }
 
-export { type JournalMode, KVSync, type KVSyncOptions, type SQLitePath, KVSync as default };
+export { type JournalMode, KVSync, type KVSyncOptions, type SQLitePath, journalModes };

package/dist/index.d.ts

@@ -4,18 +4,18 @@ interface KVSyncOptions {
     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): K;
+    set<K = T>(key: string, value: K | undefined): K | null;
     get<K = T>(key: string): K | null;
-    delete<K = T>(key: string): K | null;
-    all<K = T>(): {
+    delete(key: string): KVSync;
+    all<K = T>(filter?: (key: string, value: K) => boolean): {
         key: string;
         value: K;
     }[];
-    clear(): void;
+    clear(): KVSync;
     setJournalMode(mode: JournalMode): this;
     transaction<R>(callback: (kv: KVSync<T>) => R): {
         oldValues: {
@@ -29,6 +29,4 @@ declare class KVSync<T = any> {
     };
 }
 
-// @ts-ignore
-export = KVSync;
-export { type JournalMode, KVSync, type KVSyncOptions, type SQLitePath };
+export { type JournalMode, KVSync, type KVSyncOptions, type SQLitePath, journalModes };

package/dist/index.js

@@ -1,7 +1,9 @@
 "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) => {
@@ -16,104 +18,139 @@ var __copyProps = (to, from, except, desc) => {
   }
   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,
-  default: () => KVSync
+  journalModes: () => journalModes
 });
 module.exports = __toCommonJS(index_exports);
-
-// src/structures/KVSync.ts
 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;
   /**
-   * Create a new key-value store
+   * Instantiate a new key-value store
    * @param path Where the database is stored, or `:memory:` for in-memory storage
    */
   constructor(options) {
-    this.#db = new import_node_sqlite.DatabaseSync(options?.path ?? ":memory:");
+    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
+            ) STRICT;
         `);
   }
   /**
-   * Sets a key in the database
+   * 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;
   }
   /**
-   * Gets a value from the database
+   * 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;
   }
   /**
-   * Deletes a key from the database
+   * Delete a key from the database
    * @param key Key name
-   * @returns Deleted key or null
+   * @returns KVSync instance
    */
   delete(key) {
-    const existing = this.get(key);
-    if (existing !== null) {
-      this.#db.prepare("DELETE FROM kv WHERE key = ?").run(key);
+    if (!key || typeof key !== "string") {
+      throw new Error(
+        "[KVSync]: Key must be provided and be a non-empty string."
+      );
     }
-    return existing;
+    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() {
-    return this.#db.prepare("SELECT key, value FROM kv").all().map((record) => ({
-      key: record.key,
-      value: (0, import_node_v8.deserialize)(record.value)
-    }));
+  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");
+    this.#db.exec("DELETE FROM kv;");
+    return this;
   }
   /**
-   * Updates the journal mode
+   * Update the journal mode
    * @param mode New journal mode
    */
   setJournalMode(mode) {
-    const journalModes = [
-      "DELETE",
-      "MEMORY",
-      "OFF",
-      "PERSIST",
-      "TRUNCATE",
-      "WAL"
-    ];
     if (!journalModes.includes(mode)) {
       throw new Error(
-        `Invalid KVSync journal mode specified. Received: "${mode}", expected one of: ${journalModes.join(", ")}`
+        `[KVSync]: Invalid journal mode specified. Received: "${mode}", expected one of: ${journalModes.join(", ")}`
       );
     }
-    this.#db.exec(`PRAGMA journal_mode = ${mode}`);
+    this.#db.exec(`PRAGMA journal_mode = ${mode};`);
     return this;
   }
   /**
@@ -122,6 +159,16 @@ var KVSync = class {
    * @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();
@@ -142,7 +189,7 @@ var KVSync = class {
       }
       newMap.set(key, null);
       this.delete(key);
-      return oldMap.get(key);
+      return tx;
     };
     try {
       callback(tx);
@@ -165,5 +212,6 @@ var KVSync = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  KVSync
+  KVSync,
+  journalModes
 });

package/dist/index.mjs

@@ -1,94 +1,123 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/structures/KVSync.ts
+// src/index.ts
 import { DatabaseSync } from "node:sqlite";
 import { serialize, deserialize } 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;
   /**
-   * Create a new key-value store
+   * Instantiate a new key-value store
    * @param path Where the database is stored, or `:memory:` for in-memory storage
    */
   constructor(options) {
-    this.#db = new DatabaseSync(options?.path ?? ":memory:");
+    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
+            ) STRICT;
         `);
   }
   /**
-   * Sets a key in the database
+   * 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;
   }
   /**
-   * Gets a value from the database
+   * 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;
   }
   /**
-   * Deletes a key from the database
+   * Delete a key from the database
    * @param key Key name
-   * @returns Deleted key or null
+   * @returns KVSync instance
    */
   delete(key) {
-    const existing = this.get(key);
-    if (existing !== null) {
-      this.#db.prepare("DELETE FROM kv WHERE key = ?").run(key);
+    if (!key || typeof key !== "string") {
+      throw new Error(
+        "[KVSync]: Key must be provided and be a non-empty string."
+      );
     }
-    return existing;
+    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() {
-    return this.#db.prepare("SELECT key, value FROM kv").all().map((record) => ({
-      key: record.key,
-      value: deserialize(record.value)
-    }));
+  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");
+    this.#db.exec("DELETE FROM kv;");
+    return this;
   }
   /**
-   * Updates the journal mode
+   * Update the journal mode
    * @param mode New journal mode
    */
   setJournalMode(mode) {
-    const journalModes = [
-      "DELETE",
-      "MEMORY",
-      "OFF",
-      "PERSIST",
-      "TRUNCATE",
-      "WAL"
-    ];
     if (!journalModes.includes(mode)) {
       throw new Error(
-        `Invalid KVSync journal mode specified. Received: "${mode}", expected one of: ${journalModes.join(", ")}`
+        `[KVSync]: Invalid journal mode specified. Received: "${mode}", expected one of: ${journalModes.join(", ")}`
       );
     }
-    this.#db.exec(`PRAGMA journal_mode = ${mode}`);
+    this.#db.exec(`PRAGMA journal_mode = ${mode};`);
     return this;
   }
   /**
@@ -97,6 +126,16 @@ var KVSync = class {
    * @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();
@@ -117,7 +156,7 @@ var KVSync = class {
       }
       newMap.set(key, null);
       this.delete(key);
-      return oldMap.get(key);
+      return tx;
     };
     try {
       callback(tx);
@@ -140,5 +179,5 @@ var KVSync = class {
 };
 export {
   KVSync,
-  KVSync as default
+  journalModes
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-sqlite-kv",
   "description": "Key-value store with node:sqlite",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "repository": {
     "url": "https://github.com/e60m5ss/node-sqlite-kv"
   },