node-sqlite-kv 0.1.0 → 0.2.1

package/README.md

@@ -19,9 +19,15 @@ bun add node-sqlite-kv
 ```js
 import { KVSync } from "node-sqlite-kv";
 
-// use :memory: for in-memory storage
-// path is optional, defaults to :memory:
-const kv = new KVSync("./data.sqlite");
+const kv = new KVSync({
+    // use :memory: for in-memory storage
+    // path is optional, defaults to :memory:
+    path: "./data.sqlite",
+
+    // optional journal mode
+    // default: DELETE
+    journalMode: "WAL",
+});
 
 // set values
 kv.set("number", 123);
@@ -58,6 +64,18 @@ kv.all();
 //      // ...
 // ];
 
+// transactions
+kv.set("user:1", { name: "Andrew", age: 19 });
+kv.set("user:2", { name: "Josh", age: 22 });
+kv.set("user:3", { name: "Gabe", age: 20 });
+
+// ...store what changed in transactions
+const { oldValues, newValues } = kv.transaction((tx) => {
+    tx.set("user:1", { name: "Andrew", age: 20 });
+    tx.set("user:4", { name: "Kris", age: 21 });
+    tx.delete("user:2");
+});
+
 // delete all entries
 kv.clear();
 ```

package/dist/index.d.mts

@@ -1,14 +1,32 @@
-declare class KVSync {
+type JournalMode = "DELETE" | "MEMORY" | "OFF" | "PERSIST" | "TRUNCATE" | "WAL";
+interface KVSyncOptions {
+    path?: SQLitePath;
+    journalMode?: JournalMode;
+}
+type SQLitePath = ":memory:" | (string & {});
+
+declare class KVSync<T = any> {
     #private;
-    constructor(path?: ":memory:" | (string & {}));
-    set<T = any>(key: string, value: T): T;
-    get<T = any>(key: string): T | null;
-    delete<T = any>(key: string): T | null;
-    all<T = any>(): {
+    constructor(options?: KVSyncOptions);
+    set<K = T>(key: string, value: K): K;
+    get<K = T>(key: string): K | null;
+    delete<K = T>(key: string): K | null;
+    all<K = T>(): {
         key: string;
-        value: T;
+        value: K;
     }[];
     clear(): void;
+    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 { KVSync, KVSync as default };
+export { type JournalMode, KVSync, type KVSyncOptions, type SQLitePath, KVSync as default };

package/dist/index.d.ts

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

package/dist/index.js

@@ -38,8 +38,9 @@ var KVSync = class {
    * Create a new key-value store
    * @param path Where the database is stored, or `:memory:` for in-memory storage
    */
-  constructor(path = ":memory:") {
-    this.#db = new import_node_sqlite.DatabaseSync(path);
+  constructor(options) {
+    this.#db = new import_node_sqlite.DatabaseSync(options?.path ?? ":memory:");
+    this.setJournalMode(options?.journalMode ?? "DELETE");
     this.#db.exec(`
             CREATE TABLE IF NOT EXISTS kv (
                 key TEXT PRIMARY KEY NOT NULL,
@@ -94,6 +95,73 @@ var KVSync = class {
   clear() {
     this.#db.exec("DELETE FROM kv");
   }
+  /**
+   * Updates 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(", ")}`
+      );
+    }
+    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) {
+    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 oldMap.get(key);
+    };
+    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 = {

package/dist/index.mjs

@@ -13,8 +13,9 @@ var KVSync = class {
    * Create a new key-value store
    * @param path Where the database is stored, or `:memory:` for in-memory storage
    */
-  constructor(path = ":memory:") {
-    this.#db = new DatabaseSync(path);
+  constructor(options) {
+    this.#db = new DatabaseSync(options?.path ?? ":memory:");
+    this.setJournalMode(options?.journalMode ?? "DELETE");
     this.#db.exec(`
             CREATE TABLE IF NOT EXISTS kv (
                 key TEXT PRIMARY KEY NOT NULL,
@@ -69,6 +70,73 @@ var KVSync = class {
   clear() {
     this.#db.exec("DELETE FROM kv");
   }
+  /**
+   * Updates 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(", ")}`
+      );
+    }
+    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) {
+    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 oldMap.get(key);
+    };
+    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
+      }))
+    };
+  }
 };
 export {
   KVSync,

package/package.json

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