feat: implement SqliteMap class with CRUD operations and add tests

Author: xcfio

.github/workflows/test.yaml

@@ -30,6 +30,10 @@ jobs:
             - name: Install dependencies
               run: pnpm install --no-frozen-lockfile
 
+            # Install tsx
+            - name: Install dependencies
+              run: pnpm install --save-dev tsx
+
             # Run test
             - name: Run test
               run: node --run test

.npmignore

@@ -1,5 +1,5 @@
-*.test.ts
-*.test.js
+*.test*.ts
+*.test*.js
 .github/
 src/
 .gitignore

package.json

@@ -10,7 +10,7 @@
     "scripts": {
         "lint": "prettier --config=.prettierrc --check src",
         "fmt": "prettier --config=.prettierrc --write src",
-        "test": "tsc --noEmit",
+        "test": "(tsc --noEmit) && (tsx src/index.test.ts)",
         "dev": "tsc --watch",
         "build": "tsc"
     },

src/index.test.ts

@@ -0,0 +1,171 @@
+import { test, describe } from "node:test"
+import assert from "node:assert/strict"
+import { SqliteMap } from "./index"
+
+describe("SqliteMap", () => {
+    test("set and get", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("foo", { bar: "baz" })
+        assert.deepEqual(map.get("foo"), { bar: "baz" })
+    })
+
+    test("get returns undefined for missing key", () => {
+        const map = new SqliteMap(":memory:")
+        assert.equal(map.get("missing"), undefined)
+    })
+
+    test("has", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("foo", 1)
+        assert.equal(map.has("foo"), true)
+        assert.equal(map.has("bar"), false)
+    })
+
+    test("delete", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("foo", 1)
+        assert.equal(map.delete("foo"), true)
+        assert.equal(map.delete("foo"), false)
+        assert.equal(map.has("foo"), false)
+    })
+
+    test("clear", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("a", 1)
+        map.set("b", 2)
+        map.clear()
+        assert.equal(map.size, 0)
+    })
+
+    test("size", () => {
+        const map = new SqliteMap(":memory:")
+        assert.equal(map.size, 0)
+        map.set("a", 1)
+        map.set("b", 2)
+        assert.equal(map.size, 2)
+        map.delete("a")
+        assert.equal(map.size, 1)
+    })
+
+    test("set returns this (chaining)", () => {
+        const map = new SqliteMap(":memory:")
+        const result = map.set("a", 1).set("b", 2)
+        assert.equal(result, map)
+        assert.equal(map.size, 2)
+    })
+
+    test("getOrInsert - existing key", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("foo", 42)
+        assert.equal(map.getOrInsert("foo", 99), 42)
+    })
+
+    test("getOrInsert - missing key", () => {
+        const map = new SqliteMap(":memory:")
+        assert.equal(map.getOrInsert("foo", 99), 99)
+        assert.equal(map.get("foo"), 99)
+    })
+
+    test("getOrInsertComputed - existing key", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("foo", 42)
+        assert.equal(
+            map.getOrInsertComputed("foo", () => 99),
+            42
+        )
+    })
+
+    test("getOrInsertComputed - missing key", () => {
+        const map = new SqliteMap(":memory:")
+        assert.equal(
+            map.getOrInsertComputed("foo", (k) => k.length),
+            3
+        )
+        assert.equal(map.get("foo"), 3)
+    })
+
+    test("keys", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("a", 1)
+        map.set("b", 2)
+        assert.deepEqual([...map.keys()], ["a", "b"])
+    })
+
+    test("values", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("a", 1)
+        map.set("b", 2)
+        assert.deepEqual([...map.values()], [1, 2])
+    })
+
+    test("entries", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("a", 1)
+        map.set("b", 2)
+        assert.deepEqual(
+            [...map.entries()],
+            [
+                ["a", 1],
+                ["b", 2]
+            ]
+        )
+    })
+
+    test("forEach", () => {
+        const map = new SqliteMap<string, number>(":memory:")
+        map.set("a", 1)
+        map.set("b", 2)
+        const result: [string, number][] = []
+        map.forEach((value, key) => result.push([key, value]))
+        assert.deepEqual(result, [
+            ["a", 1],
+            ["b", 2]
+        ])
+    })
+
+    test("[Symbol.iterator]", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("a", 1)
+        map.set("b", 2)
+        assert.deepEqual(
+            [...map],
+            [
+                ["a", 1],
+                ["b", 2]
+            ]
+        )
+    })
+
+    test("[Symbol.toStringTag]", () => {
+        const map = new SqliteMap(":memory:")
+        assert.equal(Object.prototype.toString.call(map), "[object SqliteMap]")
+    })
+
+    test("toJSON", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("a", 1)
+        map.set("b", 2)
+        assert.deepEqual(map.toJSON(), { a: 1, b: 2 })
+    })
+
+    test("JSON.stringify", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("a", 1)
+        assert.equal(JSON.stringify(map), '{"a":1}')
+    })
+
+    test("overwrites existing key", () => {
+        const map = new SqliteMap(":memory:")
+        map.set("foo", 1)
+        map.set("foo", 2)
+        assert.equal(map.get("foo"), 2)
+        assert.equal(map.size, 1)
+    })
+
+    test("supports complex values", () => {
+        const map = new SqliteMap(":memory:")
+        const val = { nested: { arr: [1, 2, 3], flag: true } }
+        map.set("x", val)
+        assert.deepEqual(map.get("x"), val)
+    })
+})

src/index.ts

@@ -5,13 +5,104 @@ export class SqliteMap<K extends string, V> {
     private db: DatabaseSync
 
     constructor(path: string, options?: DatabaseSyncOptions) {
-        this.db = new DatabaseSync(path, options)
+        this.db = new DatabaseSync(path, { ...options })
         this.db.exec("CREATE TABLE IF NOT EXISTS map (key TEXT PRIMARY KEY, value TEXT)")
     }
 
     set(key: K, data: V): this {
-        const stmt = this.db.prepare(`INSERT OR REPLACE INTO cache (key, value) VALUES (?, ?)`)
-        stmt.run(String(key), JSON.stringify(data), Date.now())
+        this.db
+            .prepare(`INSERT OR REPLACE INTO map (key, value) VALUES (?, ?)`)
+            .run(this.serializeKey(key), this.serialize(data))
         return this
     }
+
+    get(key: K): V | undefined {
+        const row = this.db.prepare(`SELECT value FROM map WHERE key = ?`).get(this.serializeKey(key))
+        return typeof row?.value === "string" ? this.deserialize(row.value) : undefined
+    }
+
+    has(key: K): boolean {
+        const row = this.db.prepare(`SELECT 1 FROM map WHERE key = ?`).get(this.serializeKey(key))
+        return Boolean(row)
+    }
+
+    delete(key: K): boolean {
+        const result = this.db.prepare(`DELETE FROM map WHERE key = ?`).run(this.serializeKey(key))
+        return result.changes > 0
+    }
+
+    clear(): void {
+        this.db.exec("DELETE FROM map")
+    }
+
+    getOrInsert(key: K, defaultValue: V): V {
+        const existing = this.get(key)
+        if (existing !== undefined) return existing
+        this.set(key, defaultValue)
+        return defaultValue
+    }
+
+    getOrInsertComputed(key: K, callbackFn: (key: K) => V): V {
+        const existing = this.get(key)
+        if (existing !== undefined) return existing
+        const value = callbackFn(key)
+        this.set(key, value)
+        return value
+    }
+
+    keys(): IterableIterator<K> {
+        const rows = this.db.prepare(`SELECT key FROM map`).all() as { key: string }[]
+        return rows.map((row) => row.key as K)[Symbol.iterator]()
+    }
+
+    values(): IterableIterator<V> {
+        const rows = this.db.prepare(`SELECT value FROM map`).all() as { value: string }[]
+        return rows.map((row) => this.deserialize(row.value))[Symbol.iterator]()
+    }
+
+    entries(): IterableIterator<[K, V]> {
+        const rows = this.db.prepare(`SELECT key, value FROM map`).all() as { key: string; value: string }[]
+        return rows.map((row) => [row.key as K, this.deserialize(row.value)] as [K, V])[Symbol.iterator]()
+    }
+
+    forEach(cb: (value: V, key: K, map: this) => void): void {
+        const rows = this.db.prepare(`SELECT key, value FROM map`).all() as { key: string; value: string }[]
+        for (const row of rows) {
+            cb(this.deserialize(row.value), row.key as K, this)
+        }
+    }
+
+    toJSON(): Record<string, V> {
+        const obj: Record<string, V> = {}
+        const rows = this.db.prepare(`SELECT key, value FROM map`).all() as { key: string; value: string }[]
+        for (const row of rows) {
+            obj[row.key] = this.deserialize(row.value)
+        }
+        return obj
+    }
+
+    [Symbol.iterator](): IterableIterator<[K, V]> {
+        return this.entries()
+    }
+
+    get size(): number {
+        const row = this.db.prepare(`SELECT COUNT(*) AS count FROM map`).get()
+        return typeof row?.count === "number" ? row.count : 0
+    }
+
+    get [Symbol.toStringTag](): string {
+        return "SqliteMap"
+    }
+
+    private serialize(value: V): string {
+        return JSON.stringify(value)
+    }
+
+    private deserialize(raw: string): V {
+        return JSON.parse(raw) as V
+    }
+
+    private serializeKey(key: K): string {
+        return String(key)
+    }
 }

tsconfig.json

@@ -106,6 +106,5 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true,                                 /* Skip type checking all .d.ts files. */
     "ignoreDeprecations": "6.0"
-  },
-  "exclude": ["tsup.config.ts", "out"]
+  }
 }