@digitalpaws/starr 0.0.1

package/tests/host.test.ts

@@ -0,0 +1,449 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { discoverPluginDirs } from "../src/plugins/discovery.js";
+import { createLogger } from "../src/logging/logger.js";
+import { createContext } from "../src/plugins/context.js";
+import { ConfigService } from "../src/config/config-service.js";
+import { loadPlugins, stopPlugins } from "../src/plugins/loader.js";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { Starr } from "../src/host.js";
+import type { RegisterFn } from "../src/types/plugin.js";
+
+function createTestDb(): Database.Database {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db, CORE_MIGRATIONS, createLogger("test", "silent"));
+  return db;
+}
+
+describe("discoverPluginDirs", () => {
+  let tmpDir: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(path.join(tmpdir(), "starr-discovery-"));
+  });
+
+  afterAll(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns empty array for non-existent directory", async () => {
+    const dirs = await discoverPluginDirs("/nonexistent/path");
+    expect(dirs).toEqual([]);
+  });
+
+  it("returns directories sorted lexically by name", async () => {
+    await mkdir(path.join(tmpDir, "zebra"), { recursive: true });
+    await writeFile(path.join(tmpDir, "zebra", "package.json"), "{}");
+    await mkdir(path.join(tmpDir, "alpha"), { recursive: true });
+    await writeFile(path.join(tmpDir, "alpha", "package.json"), "{}");
+    await mkdir(path.join(tmpDir, "beta"), { recursive: true });
+    await writeFile(path.join(tmpDir, "beta", "package.json"), "{}");
+
+    const dirs = await discoverPluginDirs(tmpDir);
+    const names = dirs.map((d) => path.basename(d));
+    expect(names).toEqual(["alpha", "beta", "zebra"]);
+  });
+
+  it("ignores hidden directories", async () => {
+    await mkdir(path.join(tmpDir, ".hidden"), { recursive: true });
+    await writeFile(path.join(tmpDir, ".hidden", "package.json"), "{}");
+
+    const dirs = await discoverPluginDirs(tmpDir);
+    const names = dirs.map((d) => path.basename(d));
+    expect(names).not.toContain(".hidden");
+  });
+
+  it("ignores node_modules directory", async () => {
+    await mkdir(path.join(tmpDir, "node_modules"), { recursive: true });
+    await writeFile(path.join(tmpDir, "node_modules", "package.json"), "{}");
+
+    const dirs = await discoverPluginDirs(tmpDir);
+    const names = dirs.map((d) => path.basename(d));
+    expect(names).not.toContain("node_modules");
+  });
+
+  it("ignores directories without package.json", async () => {
+    await mkdir(path.join(tmpDir, "not-a-plugin"), { recursive: true });
+
+    const dirs = await discoverPluginDirs(tmpDir);
+    const names = dirs.map((d) => path.basename(d));
+    expect(names).not.toContain("not-a-plugin");
+  });
+
+  it("ignores files (non-directories)", async () => {
+    await writeFile(path.join(tmpDir, "some-file.txt"), "hello");
+
+    const dirs = await discoverPluginDirs(tmpDir);
+    const names = dirs.map((d) => path.basename(d));
+    expect(names).not.toContain("some-file.txt");
+  });
+});
+
+describe("logger", () => {
+  it("creates logger with default tag core", () => {
+    const logger = createLogger("core", "info");
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe("function");
+    expect(typeof logger.debug).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.error).toBe("function");
+    expect(typeof logger.child).toBe("function");
+  });
+
+  it("child logger appends tag", () => {
+    const logger = createLogger("core", "debug");
+    const child = logger.child("test");
+    expect(child).toBeDefined();
+    // Just ensure no throw
+    child.debug("test message");
+  });
+
+  it("respects log level (debug not shown at info level)", () => {
+    // Just smoke test — debug logger at info level shouldn't output
+    const logger = createLogger("core", "info");
+    logger.debug("should not appear"); // won't crash
+  });
+});
+
+describe("Starr host", () => {
+  it("constructs with options and exposes service slots", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+
+    expect(starr.options.pluginsDir).toBe("/tmp");
+    expect(starr.apiVersion).toBe("1.0.0");
+    expect(starr.isRunning).toBe(false);
+    expect(starr.eventBus).toBeDefined();
+    expect(typeof starr.eventBus.on).toBe("function");
+    expect(typeof starr.eventBus.emit).toBe("function");
+  });
+
+  it("markRunning and markStopped change state", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+
+    expect(starr.isRunning).toBe(false);
+    starr.markRunning();
+    expect(starr.isRunning).toBe(true);
+    starr.markStopped();
+    expect(starr.isRunning).toBe(false);
+  });
+
+  it("setRuntimes and getRuntimes work", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const runtimes = [
+      { meta: { id: "a", version: "1.0.0", starrApiVersion: "^1.0.0" }, lifecycle: {}, startOrder: 0 },
+    ];
+    starr.setRuntimes(runtimes);
+    expect(starr.getRuntimes()).toEqual(runtimes);
+  });
+});
+
+describe("plugin context", () => {
+  let db: Database.Database;
+
+  beforeAll(() => {
+    db = createTestDb();
+  });
+
+  function createTestConfigService(): ConfigService {
+    return new ConfigService(db, createLogger("test", "silent"));
+  }
+
+  it("throws if ctx.config is called before ctx.define", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    expect(() => ctx.config({})).toThrow("ctx.define must be called before any other context method");
+  });
+
+  it("throws if ctx.events.on is called before ctx.define", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    expect(() => ctx.events.on("test", () => {})).toThrow("ctx.define must be called before any other context method");
+  });
+
+  it("throws on duplicate ctx.define", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    ctx.define({ id: "test", version: "1.0.0", starrApiVersion: "^1.0.0" });
+    expect(() => ctx.define({ id: "test2", version: "1.0.0", starrApiVersion: "^1.0.0" })).toThrow(
+      "ctx.define can only be called once",
+    );
+  });
+
+  it("throws on empty plugin id", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    expect(() => ctx.define({ id: "", version: "1.0.0", starrApiVersion: "^1.0.0" })).toThrow("plugin id is required");
+  });
+
+  it("throws on invalid version", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    expect(() => ctx.define({ id: "test", version: "not-semver", starrApiVersion: "^1.0.0" })).toThrow(
+      "invalid plugin version",
+    );
+  });
+
+  it("throws on API version mismatch", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    expect(() => ctx.define({ id: "test", version: "1.0.0", starrApiVersion: "^2.0.0" })).toThrow(
+      "API version mismatch",
+    );
+  });
+
+  it("successful define and config (returns from ConfigService)", () => {
+    const logger = createLogger("core", "info");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db, createTestConfigService());
+
+    ctx.define({ id: "test", version: "1.0.0", starrApiVersion: "^1.0.0" });
+    const cfg = ctx.config<{ foo?: string }>({
+      foo: { type: "string", label: "Foo", default: "bar" },
+    });
+    expect(cfg.foo).toBe("bar");
+  });
+});
+
+describe("plugin loader lifecycle", () => {
+  let tmpDir: string;
+  let db: Database.Database;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(path.join(tmpdir(), "starr-loader-"));
+    db = createTestDb();
+  });
+
+  afterAll(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+    db.close();
+  });
+
+  async function writePlugin(dirName: string, code: string, pkgOverrides: Record<string, unknown> = {}) {
+    const dir = path.join(tmpDir, dirName);
+    await mkdir(dir, { recursive: true });
+    await writeFile(
+      path.join(dir, "package.json"),
+      JSON.stringify({ type: "module", main: "./index.js", ...pkgOverrides }),
+    );
+    await writeFile(path.join(dir, "index.js"), code);
+    return dir;
+  }
+
+  it("registers all plugins before starting any", async () => {
+    const events: string[] = [];
+    const key = "__starr_reg_order";
+    (globalThis as Record<string, unknown>)[key] = events;
+
+    await writePlugin(
+      "plugin-a",
+      `
+      const k = "${key}";
+      export default function register(ctx) {
+        globalThis[k].push("register-a");
+        ctx.define({ id: "a", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() { globalThis[k].push("start-a"); },
+          stop() { globalThis[k].push("stop-a"); },
+        };
+      }
+    `,
+    );
+    await writePlugin(
+      "plugin-b",
+      `
+      const k = "${key}";
+      export default function register(ctx) {
+        globalThis[k].push("register-b");
+        ctx.define({ id: "b", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() { globalThis[k].push("start-b"); },
+          stop() { globalThis[k].push("stop-b"); },
+        };
+      }
+    `,
+    );
+
+    const logger = createLogger("core", "error");
+    const starr = new Starr({ pluginsDir: tmpDir, apiVersion: "1.0.0", logger });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+    starr.configService = new ConfigService(db, createLogger("test", "silent"));
+
+    await loadPlugins(starr);
+
+    // All registers should happen before any start
+    const regA = events.indexOf("register-a");
+    const regB = events.indexOf("register-b");
+    const startA = events.indexOf("start-a");
+    const startB = events.indexOf("start-b");
+
+    expect(regA).toBeLessThan(startA);
+    expect(regA).toBeLessThan(startB);
+    expect(regB).toBeLessThan(startA);
+    expect(regB).toBeLessThan(startB);
+
+    // Start order should be discovery order (lexical)
+    expect(startA).toBeLessThan(startB);
+  });
+
+  it("stops plugins in reverse start order", async () => {
+    const events: string[] = [];
+    const key = "__starr_stop_order";
+    (globalThis as Record<string, unknown>)[key] = events;
+
+    await writePlugin(
+      "plugin-c",
+      `
+      const k = "${key}";
+      export default function register(ctx) {
+        globalThis[k].push("register-c");
+        ctx.define({ id: "c", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() { globalThis[k].push("start-c"); },
+          stop() { globalThis[k].push("stop-c"); },
+        };
+      }
+    `,
+    );
+    await writePlugin(
+      "plugin-d",
+      `
+      const k = "${key}";
+      export default function register(ctx) {
+        globalThis[k].push("register-d");
+        ctx.define({ id: "d", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() { globalThis[k].push("start-d"); },
+          stop() { globalThis[k].push("stop-d"); },
+        };
+      }
+    `,
+    );
+
+    const logger = createLogger("core", "error");
+    const starr = new Starr({ pluginsDir: tmpDir, apiVersion: "1.0.0", logger });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+    starr.configService = new ConfigService(db, createLogger("test", "silent"));
+
+    await loadPlugins(starr);
+    await stopPlugins(starr);
+
+    const stopC = events.indexOf("stop-c");
+    const stopD = events.indexOf("stop-d");
+
+    // Reverse order: stop-d (started second) before stop-c (started first)
+    expect(stopD).toBeLessThan(stopC);
+  });
+
+  async function writePluginIn(baseDir: string, dirName: string, code: string) {
+    const dir = path.join(baseDir, dirName);
+    await mkdir(dir, { recursive: true });
+    await writeFile(path.join(dir, "package.json"), JSON.stringify({ type: "module", main: "./index.js" }));
+    await writeFile(path.join(dir, "index.js"), code);
+    return dir;
+  }
+
+  it("plugin that throws during register does not prevent other plugins", async () => {
+    const tmpDir2 = await mkdtemp(path.join(tmpdir(), "starr-isolate-"));
+    const events: string[] = [];
+    const key = "__starr_isolate";
+    (globalThis as Record<string, unknown>)[key] = events;
+    try {
+      await writePluginIn(tmpDir2, "bad-plugin", `
+        export default function register(ctx) {
+          throw new Error("boom");
+        }
+      `);
+
+      await writePluginIn(tmpDir2, "good-plugin", `
+        const k = "${key}";
+        export default function register(ctx) {
+          globalThis[k].push("good-registered");
+          ctx.define({ id: "good", version: "1.0.0", starrApiVersion: "^1.0.0" });
+          return {
+            start() { globalThis[k].push("good-started"); },
+          };
+        }
+      `);
+
+      const logger = createLogger("core", "error");
+      const starr = new Starr({ pluginsDir: tmpDir2, apiVersion: "1.0.0", logger });
+      starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+      starr.configService = new ConfigService(db, createLogger("test", "silent"));
+
+      await loadPlugins(starr);
+
+      expect(events).toContain("good-registered");
+      expect(events).toContain("good-started");
+
+      const runtimes = starr.getRuntimes();
+      const ids = runtimes.map((r) => r.meta.id);
+      expect(ids).toContain("good");
+      expect(ids).not.toContain("bad-plugin");
+    } finally {
+      await rm(tmpDir2, { recursive: true, force: true });
+    }
+  });
+
+  it("API version mismatch rejects plugin but continues loading others", async () => {
+    const tmpDir2 = await mkdtemp(path.join(tmpdir(), "starr-apiver-"));
+    const events: string[] = [];
+    const key = "__starr_apiver";
+    (globalThis as Record<string, unknown>)[key] = events;
+    try {
+      await writePluginIn(tmpDir2, "mismatch-plugin", `
+        export default function register(ctx) {
+          ctx.define({ id: "mismatch", version: "1.0.0", starrApiVersion: "^2.0.0" });
+        }
+      `);
+
+      await writePluginIn(tmpDir2, "ok-plugin", `
+        const k = "${key}";
+        export default function register(ctx) {
+          globalThis[k].push("ok-registered");
+          ctx.define({ id: "ok", version: "1.0.0", starrApiVersion: "^1.0.0" });
+          return { start() { globalThis[k].push("ok-started"); } };
+        }
+      `);
+
+      const logger = createLogger("core", "error");
+      const starr = new Starr({ pluginsDir: tmpDir2, apiVersion: "1.0.0", logger });
+      starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+      starr.configService = new ConfigService(db, createLogger("test", "silent"));
+
+      await loadPlugins(starr);
+
+      expect(events).toContain("ok-registered");
+      expect(events).toContain("ok-started");
+
+      const runtimes = starr.getRuntimes();
+      const ids = runtimes.map((r) => r.meta.id);
+      expect(ids).toContain("ok");
+      expect(ids).not.toContain("mismatch");
+    } finally {
+      await rm(tmpDir2, { recursive: true, force: true });
+    }
+  });
+});

package/tests/library-cache.test.ts

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import Database from "better-sqlite3";
+import { EventBusImpl } from "../src/events/event-bus.js";
+import { createLogger } from "../src/logging/logger.js";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { LibraryCache } from "../src/library/library-cache.js";
+
+function setup() {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  const logger = createLogger("test", "silent");
+  runMigrations(db, CORE_MIGRATIONS, logger);
+
+  const impl = new EventBusImpl(logger);
+  const coreBus = impl.coreBus();
+
+  // Insert a tracked request with status 'imported'
+  db.prepare(`INSERT INTO tracked_requests (request_id, content_type_id, content_identity, item, owner_user_id, status, library_path)
+    VALUES (?,?,?,?,?,?,?)`).run(
+    "req-imported-1",
+    "starr-video/movie@1",
+    "starr-video/movie@1::tmdb=123",
+    JSON.stringify({
+      title: "Dune",
+      contentTypeId: "starr-video/movie@1",
+      externalIds: { tmdb: "123" },
+      images: [{ role: "poster", url: "https://example.com/poster.jpg" }],
+    }),
+    "admin",
+    "imported",
+    "/media/Dune/Dune.mkv",
+  );
+
+  // Insert a library_paths row for it
+  db.prepare(`INSERT INTO library_paths (request_id, library_path, library_root, imported_at)
+    VALUES (?,?,?,?)`).run(
+    "req-imported-1",
+    "/media/Dune/Dune.mkv",
+    "/media",
+    "2026-01-15T10:00:00.000Z",
+  );
+
+  // Insert a tracked request with other status (should NOT be in cache)
+  db.prepare(`INSERT INTO tracked_requests (request_id, content_type_id, content_identity, item, owner_user_id, status)
+    VALUES (?,?,?,?,?,?)`).run(
+    "req-downloading-1",
+    "starr-video/movie@1",
+    "starr-video/movie@1::tmdb=456",
+    JSON.stringify({ title: "Still Downloading", contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "456" } }),
+    "admin",
+    "downloading",
+  );
+
+  const cache = new LibraryCache(db, coreBus, logger);
+
+  return { db, coreBus, cache };
+}
+
+describe("LibraryCache", () => {
+  it("refreshFromDb populates the cache from imported requests", () => {
+    const { cache } = setup();
+
+    cache.refreshFromDb();
+
+    const items = cache.getItems();
+    expect(items.length).toBe(1);
+    expect(items[0].title).toBe("Dune");
+    expect(items[0].libraryPath).toBe("/media/Dune/Dune.mkv");
+    expect(items[0].contentTypeId).toBe("starr-video/movie@1");
+  });
+
+  it("getItems filters by content type", () => {
+    const { cache } = setup();
+
+    cache.refreshFromDb();
+
+    const movieItems = cache.getItems("starr-video/movie@1");
+    expect(movieItems.length).toBe(1);
+
+    const unknownItems = cache.getItems("nonexistent/type@1");
+    expect(unknownItems.length).toBe(0);
+  });
+
+  it("count returns the number of cached items", () => {
+    const { cache } = setup();
+
+    cache.refreshFromDb();
+
+    expect(cache.count()).toBe(1);
+  });
+
+  it("caches images as parsed objects", () => {
+    const { cache } = setup();
+
+    cache.refreshFromDb();
+
+    const items = cache.getItems();
+    expect(items[0].images).toHaveLength(1);
+    expect(items[0].images[0].role).toBe("poster");
+    expect(items[0].images[0].url).toBe("https://example.com/poster.jpg");
+  });
+
+  it("is initially empty before refreshFromDb", () => {
+    const { cache } = setup();
+
+    // No refreshFromDb called
+    expect(cache.count()).toBe(0);
+    expect(cache.getItems()).toHaveLength(0);
+  });
+
+  it("handles library.file_added event by inserting into cache", () => {
+    const { db, coreBus, cache } = setup();
+
+    cache.refreshFromDb();
+    expect(cache.count()).toBe(1);
+
+    // Add another imported request behind the scenes
+    db.prepare(`INSERT INTO tracked_requests (request_id, content_type_id, content_identity, item, owner_user_id, status, library_path)
+      VALUES (?,?,?,?,?,?,?)`).run(
+      "req-imported-2",
+      "starr-video/movie@1",
+      "starr-video/movie@1::tmdb=789",
+      JSON.stringify({
+        title: "Another Movie",
+        contentTypeId: "starr-video/movie@1",
+        externalIds: { tmdb: "789" },
+      }),
+      "admin",
+      "imported",
+      "/media/Another/Another.mkv",
+    );
+    db.prepare(`INSERT INTO library_paths (request_id, library_path, library_root, imported_at)
+      VALUES (?,?,?,?)`).run(
+      "req-imported-2",
+      "/media/Another/Another.mkv",
+      "/media",
+      "2026-02-20T12:00:00.000Z",
+    );
+
+    // Emit the event that triggers cache update
+    coreBus.emit("library.file_added", {
+      requestId: "req-imported-2",
+      libraryPath: "/media/Another/Another.mkv",
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=789",
+    });
+
+    expect(cache.count()).toBe(2);
+    const titles = cache.getItems().map((i) => i.title);
+    expect(titles).toContain("Another Movie");
+    expect(titles).toContain("Dune");
+  });
+
+  it("handles request.deleted event by removing from cache", () => {
+    const { coreBus, cache } = setup();
+
+    cache.refreshFromDb();
+    expect(cache.count()).toBe(1);
+
+    coreBus.emit("request.deleted", {
+      requestId: "req-imported-1",
+      previousStatus: "imported",
+    });
+
+    expect(cache.count()).toBe(0);
+  });
+});