@digitalpaws/starr 0.0.1

package/tests/datastore.test.ts

@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import { mkdtempSync, writeFileSync, existsSync, unlinkSync, rmdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+
+import { runMigrations, CORE_MIGRATIONS, type Migration } from "../src/datastore/migrations.js";
+import { createPluginStorage } from "../src/datastore/storage.js";
+import { loadEncryptionKey, encrypt, decrypt, resetEncryptionKey } from "../src/datastore/encrypt.js";
+import { createContext } from "../src/plugins/context.js";
+import { ConfigService } from "../src/config/config-service.js";
+import { createLogger } from "../src/logging/logger.js";
+import { Starr } from "../src/host.js";
+
+// ── Helper: fresh in-memory database with migrations applied ───────────
+
+function createTestDb(): Database.Database {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
+
+const testLogger = createLogger("test", "silent");
+
+// ── 7a. Migrations tests ───────────────────────────────────────────────
+
+describe("migrations", () => {
+  it("creates _migrations and plugin_storage tables", () => {
+    const db = createTestDb();
+    runMigrations(db, CORE_MIGRATIONS, testLogger);
+
+    const tables = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+      .all() as Array<{ name: string }>;
+    const tableNames = tables.map((t) => t.name);
+    expect(tableNames).toContain("_migrations");
+    expect(tableNames).toContain("plugin_storage");
+  });
+
+  it("is idempotent — second run does not error", () => {
+    const db = createTestDb();
+    runMigrations(db, CORE_MIGRATIONS, testLogger);
+    expect(() => runMigrations(db, CORE_MIGRATIONS, testLogger)).not.toThrow();
+
+    // Verify correct number of rows in _migrations (should match CORE_MIGRATIONS count)
+    const rows = db.prepare("SELECT COUNT(*) as cnt FROM _migrations").get() as { cnt: number };
+    expect(rows.cnt).toBe(CORE_MIGRATIONS.length);
+  });
+
+  it("applies custom migration and its side effects are visible", () => {
+    const db = createTestDb();
+    const customMigrations: Migration[] = [
+      {
+        id: 99,
+        name: "test_data",
+        up: "CREATE TABLE test_data (id INTEGER PRIMARY KEY, val TEXT); INSERT INTO test_data VALUES (1, 'hello');",
+      },
+    ];
+
+    runMigrations(db, [...CORE_MIGRATIONS, ...customMigrations], testLogger);
+
+    const row = db.prepare("SELECT val FROM test_data WHERE id = 1").get() as { val: string } | undefined;
+    expect(row?.val).toBe("hello");
+  });
+
+  it("runs migrations in id order", () => {
+    const db = createTestDb();
+    const order: number[] = [];
+
+    const orderedMigrations: Migration[] = [
+      {
+        id: 1,
+        name: "first",
+        up: `CREATE TABLE IF NOT EXISTS _order_test (step INTEGER); INSERT INTO _order_test VALUES (1);`,
+      },
+      {
+        id: 2,
+        name: "second",
+        up: `INSERT INTO _order_test VALUES (2);`,
+      },
+      {
+        id: 3,
+        name: "third",
+        up: `INSERT INTO _order_test VALUES (3);`,
+      },
+    ];
+
+    runMigrations(db, orderedMigrations, testLogger);
+
+    const steps = db.prepare("SELECT step FROM _order_test ORDER BY step").all() as Array<{ step: number }>;
+    expect(steps.map((s) => s.step)).toEqual([1, 2, 3]);
+  });
+});
+
+// ── 7b. Plugin storage tests ──────────────────────────────────────────
+
+describe("plugin storage", () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = createTestDb();
+    runMigrations(db, CORE_MIGRATIONS, testLogger);
+  });
+
+  it("get returns undefined for non-existent key", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    const result = await storage.get("nonexistent");
+    expect(result).toBeUndefined();
+  });
+
+  it("set then get round-trips a value", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    await storage.set("key1", { name: "hello", count: 42 });
+    const result = await storage.get<{ name: string; count: number }>("key1");
+    expect(result).toEqual({ name: "hello", count: 42 });
+  });
+
+  it("set overwrites an existing key", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    await storage.set("key1", "first");
+    await storage.set("key1", "second");
+    const result = await storage.get<string>("key1");
+    expect(result).toBe("second");
+  });
+
+  it("delete removes a key; subsequent get returns undefined", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    await storage.set("key1", "value");
+    await storage.delete("key1");
+    const result = await storage.get("key1");
+    expect(result).toBeUndefined();
+  });
+
+  it("delete on non-existent key does not throw", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    await expect(storage.delete("nonexistent")).resolves.toBeUndefined();
+  });
+
+  it("list() returns all keys in the namespace", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    await storage.set("a", 1);
+    await storage.set("b", 2);
+    await storage.set("c", 3);
+
+    const results = await storage.list<number>();
+    expect(results).toHaveLength(3);
+    expect(results.map((r) => r.key)).toEqual(["a", "b", "c"]);
+    expect(results.map((r) => r.value)).toEqual([1, 2, 3]);
+  });
+
+  it("list(prefix) returns only keys with that prefix", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    await storage.set("a/1", "a-one");
+    await storage.set("a/2", "a-two");
+    await storage.set("b/1", "b-one");
+
+    const results = await storage.list<string>("a/");
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.key)).toEqual(["a/1", "a/2"]);
+  });
+
+  it("isolation: plugin A cannot read plugin B's keys", async () => {
+    const storageA = createPluginStorage(db, "plugin-a");
+    const storageB = createPluginStorage(db, "plugin-b");
+
+    await storageA.set("secret", "only-a");
+    await storageB.set("secret", "only-b");
+
+    const aVal = await storageA.get<string>("secret");
+    const bVal = await storageB.get<string>("secret");
+
+    expect(aVal).toBe("only-a");
+    expect(bVal).toBe("only-b");
+  });
+
+  it("isolation: list for plugin A does not include plugin B keys", async () => {
+    const storageA = createPluginStorage(db, "plugin-a");
+    const storageB = createPluginStorage(db, "plugin-b");
+
+    await storageA.set("key-a", 1);
+    await storageB.set("key-b", 2);
+
+    const listA = await storageA.list<number>();
+    const listB = await storageB.list<number>();
+
+    expect(listA.map((r) => r.key)).toEqual(["key-a"]);
+    expect(listB.map((r) => r.key)).toEqual(["key-b"]);
+  });
+
+  it("list returns results sorted lexically", async () => {
+    const storage = createPluginStorage(db, "plugin-a");
+    await storage.set("z", 1);
+    await storage.set("a", 2);
+    await storage.set("m", 3);
+
+    const results = await storage.list<number>();
+    expect(results.map((r) => r.key)).toEqual(["a", "m", "z"]);
+  });
+});
+
+// ── 7c. Encryption tests ──────────────────────────────────────────────
+
+describe("encryption", () => {
+  let dataDir: string;
+
+  beforeEach(() => {
+    dataDir = mkdtempSync(path.join(tmpdir(), "starr-encrypt-"));
+    resetEncryptionKey();
+  });
+
+  afterEach(() => {
+    // Clean up temp directory
+    try {
+      const keyPath = path.join(dataDir, "starr.key");
+      if (existsSync(keyPath)) unlinkSync(keyPath);
+      rmdirSync(dataDir);
+    } catch {
+      // Ignore cleanup failures
+    }
+    resetEncryptionKey();
+  });
+
+  it("encrypt/decrypt round-trips a plaintext string", () => {
+    // Load key in auto-generate mode
+    loadEncryptionKey(dataDir, testLogger);
+
+    const original = "hello world";
+    const encrypted = encrypt(original);
+    const decrypted = decrypt(encrypted);
+    expect(decrypted).toBe(original);
+  });
+
+  it("decrypt with tampered blob throws", () => {
+    loadEncryptionKey(dataDir, testLogger);
+    const encrypted = encrypt("test data");
+
+    // Mutate the blob
+    const buf = Buffer.from(encrypted, "base64");
+    buf[0] ^= 0xff; // flip bits in IV
+    const tampered = buf.toString("base64");
+
+    expect(() => decrypt(tampered)).toThrow();
+  });
+
+  it("encrypt produces different outputs for same plaintext (random IV)", () => {
+    loadEncryptionKey(dataDir, testLogger);
+    const a = encrypt("same");
+    const b = encrypt("same");
+    expect(a).not.toBe(b);
+  });
+
+  it("loadEncryptionKey loads from env var", () => {
+    const key = randomBytes(32).toString("base64");
+    process.env.STARR_ENCRYPTION_KEY = key;
+    try {
+      const loaded = loadEncryptionKey(dataDir, testLogger);
+      expect(loaded.toString("base64")).toBe(key);
+    } finally {
+      delete process.env.STARR_ENCRYPTION_KEY;
+    }
+  });
+
+  it("loadEncryptionKey loads from file", () => {
+    const key = randomBytes(32).toString("base64");
+    const keyPath = path.join(dataDir, "starr.key");
+    writeFileSync(keyPath, key + "\n", { mode: 0o600 });
+
+    const loaded = loadEncryptionKey(dataDir, testLogger);
+    expect(loaded.toString("base64")).toBe(key);
+  });
+
+  it("loadEncryptionKey auto-generates when no env var or file exists", () => {
+    // Ensure env var is not set
+    delete process.env.STARR_ENCRYPTION_KEY;
+
+    const loaded = loadEncryptionKey(dataDir, testLogger);
+    expect(loaded.length).toBe(32);
+
+    // Verify key file was written
+    const keyPath = path.join(dataDir, "starr.key");
+    expect(existsSync(keyPath)).toBe(true);
+    const fileContent = readFileSync(keyPath, "utf8").trim();
+    expect(fileContent).toBe(loaded.toString("base64"));
+  });
+
+  it("loadEncryptionKey is idempotent", () => {
+    delete process.env.STARR_ENCRYPTION_KEY;
+    const first = loadEncryptionKey(dataDir, testLogger);
+    const second = loadEncryptionKey(dataDir, testLogger);
+    expect(first).toBe(second); // Same buffer reference
+    resetEncryptionKey();
+  });
+});
+
+// ── 7d. Context integration test ──────────────────────────────────────
+
+describe("context integration", () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = createTestDb();
+    runMigrations(db, CORE_MIGRATIONS, testLogger);
+  });
+
+  function createTestConfigService(): ConfigService {
+    return new ConfigService(db, testLogger);
+  }
+
+  it("ctx.storage.set and ctx.storage.get persist data", async () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    ctx.define({ id: "test-plugin", version: "1.0.0", starrApiVersion: "^1.0.0" });
+    await ctx.storage.set("mykey", { foo: "bar" });
+    const result = await ctx.storage.get<{ foo: string }>("mykey");
+    expect(result).toEqual({ foo: "bar" });
+  });
+
+  it("ctx.storage.list works with real storage", async () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    ctx.define({ id: "test-plugin", version: "1.0.0", starrApiVersion: "^1.0.0" });
+    await ctx.storage.set("a", 1);
+    await ctx.storage.set("b", 2);
+    const results = await ctx.storage.list<number>();
+    expect(results).toHaveLength(2);
+  });
+
+  it("calling ctx.storage.* before ctx.define throws", () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    // Attempt to access storage before define — getter throws synchronously
+    expect(() => ctx.storage).toThrow("ctx.storage called before ctx.define");
+  });
+});