@digitalpaws/starr 0.0.1

package/tests/config.test.ts

@@ -0,0 +1,612 @@
+// 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 } from "../src/datastore/migrations.js";
+import { loadEncryptionKey, resetEncryptionKey, encrypt, decrypt } from "../src/datastore/encrypt.js";
+import { validateConfig, type ValidationResult } from "../src/config/validate.js";
+import { ConfigService, SECRET_UNCHANGED_SENTINEL } from "../src/config/config-service.js";
+import { createLogger } from "../src/logging/logger.js";
+import type { ConfigSchema, ConfigField } from "../src/types/plugin.js";
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+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");
+
+function createTestConfigService(
+  db: Database.Database,
+  onReload?: (pluginId: string) => void,
+): ConfigService {
+  return new ConfigService(db, testLogger, onReload);
+}
+
+// ── 7a. Validation Tests ──────────────────────────────────────────────
+
+describe("validateConfig", () => {
+  it("returns valid: false with error for missing required field", () => {
+    const schema: ConfigSchema<{ x: string }> = {
+      x: { type: "string", label: "X", required: true },
+    };
+    const result = validateConfig(schema, {});
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].field).toBe("x");
+    expect(result.errors[0].message).toContain("required");
+    expect(result.values).toEqual({});
+  });
+
+  it("returns valid: true when required field is present", () => {
+    const schema: ConfigSchema<{ x: string }> = {
+      x: { type: "string", label: "X", required: true },
+    };
+    const result = validateConfig(schema, { x: "hello" });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.values.x).toBe("hello");
+  });
+
+  it("applies default value when field is missing", () => {
+    const schema: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port", default: 8080 },
+    };
+    const result = validateConfig(schema, {});
+    expect(result.valid).toBe(true);
+    expect(result.values.port).toBe(8080);
+  });
+
+  it("does NOT apply default when user provides a value", () => {
+    const schema: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port", default: 8080 },
+    };
+    const result = validateConfig(schema, { port: 9090 });
+    expect(result.valid).toBe(true);
+    expect(result.values.port).toBe(9090);
+  });
+
+  it("coerces string '42' to number 42", () => {
+    const schema: ConfigSchema<{ val: number }> = {
+      val: { type: "number", label: "Val" },
+    };
+    const result = validateConfig(schema, { val: "42" });
+    expect(result.valid).toBe(true);
+    expect(result.values.val).toBe(42);
+  });
+
+  it("rejects 'abc' for number field", () => {
+    const schema: ConfigSchema<{ val: number }> = {
+      val: { type: "number", label: "Val" },
+    };
+    const result = validateConfig(schema, { val: "abc" });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+  });
+
+  it("coerces 'true' and 'false' strings to booleans", () => {
+    const schema: ConfigSchema<{ a: boolean; b: boolean }> = {
+      a: { type: "boolean", label: "A" },
+      b: { type: "boolean", label: "B" },
+    };
+    const result = validateConfig(schema, { a: "true", b: "false" });
+    expect(result.valid).toBe(true);
+    expect(result.values.a).toBe(true);
+    expect(result.values.b).toBe(false);
+  });
+
+  it("rejects enum value not in options", () => {
+    const schema: ConfigSchema<{ color: string }> = {
+      color: { type: "enum", label: "Color", options: ["red", "green", "blue"] },
+    };
+    const result = validateConfig(schema, { color: "yellow" });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].message).toContain("not in allowed options");
+  });
+
+  it("accepts enum value in options", () => {
+    const schema: ConfigSchema<{ color: string }> = {
+      color: { type: "enum", label: "Color", options: ["red", "green", "blue"] },
+    };
+    const result = validateConfig(schema, { color: "green" });
+    expect(result.valid).toBe(true);
+    expect(result.values.color).toBe("green");
+  });
+
+  it("accepts any string for enum with empty options", () => {
+    const schema: ConfigSchema<{ val: string }> = {
+      val: { type: "enum", label: "Val", options: [] },
+    };
+    const result = validateConfig(schema, { val: "anything" });
+    expect(result.valid).toBe(true);
+    expect(result.values.val).toBe("anything");
+  });
+
+  it("validates URL type", () => {
+    const schema: ConfigSchema<{ url: string }> = {
+      url: { type: "url", label: "URL" },
+    };
+    const valid = validateConfig(schema, { url: "https://example.com" });
+    expect(valid.valid).toBe(true);
+    expect(valid.values.url).toBe("https://example.com");
+
+    const invalid = validateConfig(schema, { url: "not-a-url" });
+    expect(invalid.valid).toBe(false);
+    expect(invalid.errors).toHaveLength(1);
+  });
+
+  it("validates path type (non-empty string)", () => {
+    const schema: ConfigSchema<{ p: string }> = {
+      p: { type: "path", label: "Path" },
+    };
+    const valid = validateConfig(schema, { p: "/some/path" });
+    expect(valid.valid).toBe(true);
+    expect(valid.values.p).toBe("/some/path");
+
+    // Empty string is treated as "missing" per spec — optional field stores undefined
+    const empty = validateConfig(schema, { p: "" });
+    expect(empty.valid).toBe(true);
+    expect(empty.values.p).toBeUndefined();
+
+    const notString = validateConfig(schema, { p: 42 });
+    expect(notString.valid).toBe(false);
+  });
+
+  it("validates secret type same as string", () => {
+    const schema: ConfigSchema<{ token: string }> = {
+      token: { type: "secret", label: "Token" },
+    };
+    const result = validateConfig(schema, { token: "my-secret" });
+    expect(result.valid).toBe(true);
+    expect(result.values.token).toBe("my-secret");
+  });
+
+  it("collects multiple errors (not just first)", () => {
+    const schema: ConfigSchema<{ a: string; b: string; c: string }> = {
+      a: { type: "string", label: "A", required: true },
+      b: { type: "number", label: "B", required: true },
+      c: { type: "string", label: "C", required: true },
+    };
+    const result = validateConfig(schema, { b: "not-a-number" });
+    expect(result.valid).toBe(false);
+    // a missing, b invalid, c missing = 3 errors
+    expect(result.errors).toHaveLength(3);
+  });
+
+  it("ignores unknown fields in input", () => {
+    const schema: ConfigSchema<{ name: string }> = {
+      name: { type: "string", label: "Name" },
+    };
+    const result = validateConfig(schema, { name: "hello", extra: "ignored" });
+    expect(result.valid).toBe(true);
+    expect(result.values.name).toBe("hello");
+    expect((result.values as Record<string, unknown>).extra).toBeUndefined();
+  });
+
+  it("treats field.default: null as valid default", () => {
+    const schema: ConfigSchema<{ val: string | null }> = {
+      val: { type: "string", label: "Val", default: null },
+    };
+    const result = validateConfig(schema, {});
+    expect(result.valid).toBe(true);
+    expect(result.values.val).toBeNull();
+  });
+
+  it("empty schema returns valid: true with empty values", () => {
+    const result = validateConfig({}, {});
+    expect(result.valid).toBe(true);
+    expect(result.values).toEqual({});
+  });
+
+  it("optional field with no default stores undefined", () => {
+    const schema: ConfigSchema<{ name: string }> = {
+      name: { type: "string", label: "Name" },
+    };
+    const result = validateConfig(schema, {});
+    expect(result.valid).toBe(true);
+    expect(result.values.name).toBeUndefined();
+  });
+
+  it("required field with default does not trigger error when missing", () => {
+    const schema: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port", required: true, default: 8080 },
+    };
+    const result = validateConfig(schema, {});
+    expect(result.valid).toBe(true);
+    expect(result.values.port).toBe(8080);
+  });
+
+  it("number rejects empty string", () => {
+    const schema: ConfigSchema<{ n: number }> = {
+      n: { type: "number", label: "N", required: true },
+    };
+    const result = validateConfig(schema, { n: "" });
+    expect(result.valid).toBe(false);
+  });
+});
+
+// ── 7b. ConfigService Tests ────────────────────────────────────────────
+
+describe("ConfigService", () => {
+  let db: Database.Database;
+  let dataDir: string;
+
+  beforeEach(() => {
+    db = createTestDb();
+    runMigrations(db, CORE_MIGRATIONS, testLogger);
+    dataDir = mkdtempSync(path.join(tmpdir(), "starr-config-"));
+    resetEncryptionKey();
+    loadEncryptionKey(dataDir, testLogger);
+  });
+
+  afterEach(() => {
+    db.close();
+    try {
+      const keyPath = path.join(dataDir, "starr.key");
+      if (existsSync(keyPath)) unlinkSync(keyPath);
+      rmdirSync(dataDir);
+    } catch {
+      // ignore cleanup failures
+    }
+    resetEncryptionKey();
+  });
+
+  it("register on first call persists schema and returns defaults", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port", default: 8080 },
+    };
+    const values = cs.register("test-plugin", schema);
+    expect(values).toEqual({ port: 8080 });
+
+    // Verify it was persisted
+    const entry = cs.get("test-plugin");
+    expect(entry).toBeDefined();
+    expect(entry!.schema).toEqual(schema);
+    expect(entry!.values.port).toBe(8080);
+  });
+
+  it("register on second call returns persisted values", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ name: string }> = {
+      name: { type: "string", label: "Name", default: "default" },
+    };
+
+    // First call
+    cs.register("test-plugin", schema);
+
+    // Second call (simulating restart) - should return persisted value
+    // But since we never updated, it should still be the default
+    const values = cs.register("test-plugin", schema);
+    expect(values).toEqual({ name: "default" });
+  });
+
+  it("register returns persisted values after update", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ name: string }> = {
+      name: { type: "string", label: "Name" },
+    };
+
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { name: "updated" });
+
+    // Re-register (simulating restart) - should get persisted value
+    const values = cs.register("test-plugin", schema);
+    expect(values).toEqual({ name: "updated" });
+  });
+
+  it("register with required field missing marks needsConfiguration", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key", required: true },
+    };
+
+    cs.register("test-plugin", schema);
+
+    expect(cs.needsConfiguration("test-plugin")).toBe(true);
+    const entry = cs.get("test-plugin");
+    expect(entry!.needsConfiguration).toBe(true);
+  });
+
+  it("register with all required fields present does not need configuration", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key", required: true },
+    };
+
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { apiKey: "sk-123" });
+
+    expect(cs.needsConfiguration("test-plugin")).toBe(false);
+    const entry = cs.get("test-plugin");
+    expect(entry!.needsConfiguration).toBe(false);
+  });
+
+  it("update with valid input succeeds and persists", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ port: number; host: string }> = {
+      port: { type: "number", label: "Port", default: 8080 },
+      host: { type: "string", label: "Host", default: "localhost" },
+    };
+
+    cs.register("test-plugin", schema);
+    const result = cs.update("test-plugin", schema, { port: 9090, host: "example.com" });
+
+    expect(result.valid).toBe(true);
+    expect(result.values.port).toBe(9090);
+    expect(result.values.host).toBe("example.com");
+
+    // Verify persisted
+    const entry = cs.get("test-plugin");
+    expect(entry!.values.port).toBe(9090);
+    expect(entry!.values.host).toBe("example.com");
+  });
+
+  it("update with invalid input returns errors and does NOT persist", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port", required: true },
+    };
+
+    cs.register("test-plugin", schema);
+
+    // First set a valid value
+    cs.update("test-plugin", schema, { port: 8080 });
+
+    // Now try invalid
+    const result = cs.update("test-plugin", schema, { port: "not-a-number" });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(1);
+
+    // Verify the good value is still there
+    const entry = cs.get("test-plugin");
+    expect(entry!.values.port).toBe(8080);
+  });
+
+  it("update triggers the onReload callback on success", () => {
+    const reloaded: string[] = [];
+    const cs = createTestConfigService(db, (pluginId) => {
+      reloaded.push(pluginId);
+    });
+    const schema: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port" },
+    };
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { port: 9090 });
+    expect(reloaded).toContain("test-plugin");
+  });
+
+  it("update does NOT call onReload when validation fails", () => {
+    const reloaded: string[] = [];
+    const cs = createTestConfigService(db, (pluginId) => {
+      reloaded.push(pluginId);
+    });
+    const schema: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port", required: true },
+    };
+    cs.register("test-plugin", schema);
+
+    // Attempt invalid update
+    cs.update("test-plugin", schema, { port: "bad" });
+    expect(reloaded).toHaveLength(0);
+  });
+
+  it("get returns schema + values for a registered plugin", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ name: string }> = {
+      name: { type: "string", label: "Name", default: "test" },
+    };
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { name: "hello" });
+
+    const entry = cs.get("test-plugin");
+    expect(entry).toBeDefined();
+    expect(entry!.schema).toEqual(schema);
+    expect(entry!.values.name).toBe("hello");
+    expect(entry!.updatedAt).toBeDefined();
+  });
+
+  it("get returns undefined for unknown plugin", () => {
+    const cs = createTestConfigService(db);
+    const entry = cs.get("nonexistent");
+    expect(entry).toBeUndefined();
+  });
+
+  it("get masks secret values (returns sentinel, not plaintext)", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key" },
+    };
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { apiKey: "my-secret-key" });
+
+    const entry = cs.get("test-plugin");
+    expect(entry!.values.apiKey).toBe(SECRET_UNCHANGED_SENTINEL);
+  });
+
+  it("get returns needsConfiguration: true for plugins with missing required fields", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key", required: true },
+    };
+    cs.register("test-plugin", schema);
+
+    const entry = cs.get("test-plugin");
+    expect(entry!.needsConfiguration).toBe(true);
+  });
+
+  it("list returns all registered plugins", () => {
+    const cs = createTestConfigService(db);
+    const schemaA: ConfigSchema<{ name: string }> = {
+      name: { type: "string", label: "Name" },
+    };
+    const schemaB: ConfigSchema<{ port: number }> = {
+      port: { type: "number", label: "Port" },
+    };
+
+    cs.register("plugin-a", schemaA);
+    cs.register("plugin-b", schemaB);
+
+    const list = cs.list();
+    expect(list).toHaveLength(2);
+    expect(list.map((s) => s.pluginId)).toEqual(["plugin-a", "plugin-b"]);
+  });
+
+  it("secret encryption round-trip: update with secret value, get returns masked, update with sentinel preserves original", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key" },
+    };
+
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { apiKey: "my-secret-key" });
+
+    // get returns masked
+    const entry1 = cs.get("test-plugin");
+    expect(entry1!.values.apiKey).toBe(SECRET_UNCHANGED_SENTINEL);
+
+    // update with sentinel preserves original secret
+    cs.update("test-plugin", schema, { apiKey: SECRET_UNCHANGED_SENTINEL });
+
+    // register again (simulating restart) - should still have the original secret
+    const values = cs.register("test-plugin", schema);
+    expect(values).toEqual({ apiKey: "my-secret-key" });
+  });
+
+  it("secret in database is encrypted (not plaintext)", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key" },
+    };
+
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { apiKey: "my-secret-key" });
+
+    // Directly query the DB
+    const row = db.prepare("SELECT \"values\" FROM plugin_config WHERE plugin_id = ?").get("test-plugin") as { values: string } | undefined;
+    expect(row).toBeDefined();
+
+    const parsed = JSON.parse(row!.values);
+    // The secret field should NOT be the plaintext
+    expect(parsed.apiKey).not.toBe("my-secret-key");
+    // It should be a base64 string (encrypted blob)
+    expect(typeof parsed.apiKey).toBe("string");
+    expect(parsed.apiKey.length).toBeGreaterThan(0);
+
+    // Verify we can decrypt it
+    const decrypted = decrypt(parsed.apiKey);
+    expect(decrypted).toBe("my-secret-key");
+  });
+
+  it("schema changes between register calls are handled (new required field)", () => {
+    const cs = createTestConfigService(db);
+
+    // First registration with simple schema
+    const schema1: ConfigSchema<{ name: string }> = {
+      name: { type: "string", label: "Name", default: "test" },
+    };
+    cs.register("test-plugin", schema1);
+
+    // Update with a value
+    cs.update("test-plugin", schema1, { name: "original" });
+
+    // Now simulate a plugin upgrade with a new required field
+    const schema2: ConfigSchema<{ name: string; apiKey: string }> = {
+      name: { type: "string", label: "Name", default: "test" },
+      apiKey: { type: "secret", label: "API Key", required: true },
+    };
+
+    // Re-register with new schema
+    const values = cs.register("test-plugin", schema2);
+
+    // The old value "original" should be preserved for name
+    // But apiKey is required with no default → needs-configuration
+    expect(values).toBeDefined();
+    expect(cs.needsConfiguration("test-plugin")).toBe(true);
+
+    // The get should also reflect that
+    const entry = cs.get("test-plugin");
+    expect(entry!.needsConfiguration).toBe(true);
+  });
+
+  it("update with new secret value overwrites the old one", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key" },
+    };
+
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { apiKey: "old-secret" });
+    cs.update("test-plugin", schema, { apiKey: "new-secret" });
+
+    const values = cs.register("test-plugin", schema);
+    expect(values).toEqual({ apiKey: "new-secret" });
+  });
+
+  it("list returns needsConfiguration status", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key", required: true },
+    };
+    cs.register("plugin-a", schema);
+    cs.update("plugin-a", schema, { apiKey: "set" });
+
+    cs.register("plugin-b", schema); // missing required
+
+    const list = cs.list();
+    const a = list.find((s) => s.pluginId === "plugin-a");
+    const b = list.find((s) => s.pluginId === "plugin-b");
+    expect(a!.needsConfiguration).toBe(false);
+    expect(b!.needsConfiguration).toBe(true);
+  });
+
+  it("getDecryptedValues returns undefined for unknown plugin", () => {
+    const cs = createTestConfigService(db);
+    const result = cs.getDecryptedValues("nonexistent");
+    expect(result).toBeUndefined();
+  });
+
+  it("getDecryptedValues returns decrypted secret values", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ apiKey: string }> = {
+      apiKey: { type: "secret", label: "API Key" },
+    };
+
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, { apiKey: "my-secret-key" });
+
+    const decrypted = cs.getDecryptedValues("test-plugin");
+    expect(decrypted).toBeDefined();
+    expect(decrypted!.apiKey).toBe("my-secret-key");
+  });
+
+  it("getDecryptedValues returns non-secret fields as stored", () => {
+    const cs = createTestConfigService(db);
+    const schema: ConfigSchema<{ endpoint: string; apiKey: string }> = {
+      endpoint: { type: "url", label: "Endpoint" },
+      apiKey: { type: "secret", label: "API Key" },
+    };
+
+    cs.register("test-plugin", schema);
+    cs.update("test-plugin", schema, {
+      endpoint: "http://jackett:9117",
+      apiKey: "secret-123",
+    });
+
+    const decrypted = cs.getDecryptedValues("test-plugin");
+    expect(decrypted).toBeDefined();
+    expect(decrypted!.endpoint).toBe("http://jackett:9117");
+    expect(decrypted!.apiKey).toBe("secret-123");
+  });
+});