@checkstack/backend 0.0.2

package/src/plugin-lifecycle.test.ts

@@ -0,0 +1,276 @@
+import { describe, it, expect, mock, beforeEach, spyOn } from "bun:test";
+import {
+  createMockEventBus,
+  createMockPluginInstaller,
+  createMockQueueManager,
+  type MockEventBus,
+  type MockPluginInstaller,
+} from "@checkstack/test-utils-backend";
+import { coreServices, coreHooks } from "@checkstack/backend-api";
+
+// Note: ./db and ./logger are mocked via test-preload.ts (bunfig.toml preload)
+// This ensures mocks are in place BEFORE any module imports them
+
+import { PluginManager } from "./plugin-manager";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("Plugin Lifecycle", () => {
+  let pluginManager: PluginManager;
+  let mockEventBus: MockEventBus;
+  let mockInstaller: MockPluginInstaller;
+
+  beforeEach(() => {
+    pluginManager = new PluginManager();
+    mockEventBus = createMockEventBus();
+    mockInstaller = createMockPluginInstaller();
+
+    // Access internal registry to override factory (factories take precedence)
+    const registry = (pluginManager as never)["registry"] as {
+      registerFactory: <T>(ref: { id: string }, factory: () => T) => void;
+      register: <T>(ref: { id: string }, impl: T) => void;
+    };
+
+    // Override EventBus factory with our mock
+    registry.registerFactory(
+      coreServices.eventBus,
+      () => mockEventBus as never
+    );
+
+    // Register services
+    registry.register(coreServices.pluginInstaller, mockInstaller as never);
+    registry.register(
+      coreServices.queueManager,
+      createMockQueueManager() as never
+    );
+  });
+
+  describe("requestInstallation", () => {
+    it("should emit pluginInstallationRequested broadcast", async () => {
+      await pluginManager.requestInstallation("test-plugin", "/path/to/plugin");
+
+      expect(mockEventBus._emittedEvents).toContainEqual({
+        hook: coreHooks.pluginInstallationRequested.id,
+        payload: { pluginId: "test-plugin", pluginPath: "/path/to/plugin" },
+      });
+    });
+  });
+
+  describe("requestDeregistration", () => {
+    it("should emit pluginDeregistrationRequested broadcast", async () => {
+      await pluginManager.requestDeregistration("test-plugin", {
+        deleteSchema: false,
+      });
+
+      expect(mockEventBus._emittedEvents).toContainEqual({
+        hook: coreHooks.pluginDeregistrationRequested.id,
+        payload: { pluginId: "test-plugin", deleteSchema: false },
+      });
+    });
+
+    it("should include deleteSchema flag in broadcast", async () => {
+      await pluginManager.requestDeregistration("test-plugin", {
+        deleteSchema: true,
+      });
+
+      expect(mockEventBus._emittedEvents).toContainEqual({
+        hook: coreHooks.pluginDeregistrationRequested.id,
+        payload: { pluginId: "test-plugin", deleteSchema: true },
+      });
+    });
+  });
+
+  describe("setupLifecycleListeners", () => {
+    it("should register listeners for installation broadcasts", async () => {
+      await pluginManager.setupLifecycleListeners();
+
+      // Spy on loadSinglePlugin and make it a no-op to avoid actual import
+      const loadSpy = spyOn(
+        pluginManager,
+        "loadSinglePlugin"
+      ).mockImplementation(async () => {});
+      await mockEventBus._triggerBroadcast(
+        coreHooks.pluginInstallationRequested,
+        {
+          pluginId: "broadcast-plugin",
+          pluginPath: "/broadcast/path",
+        }
+      );
+
+      expect(loadSpy).toHaveBeenCalledWith(
+        "broadcast-plugin",
+        "/broadcast/path"
+      );
+    });
+
+    it("should register listeners for deregistration broadcasts", async () => {
+      await pluginManager.setupLifecycleListeners();
+
+      // Trigger a broadcast and verify the listener responds
+      const deregSpy = spyOn(pluginManager, "deregisterPlugin");
+      await mockEventBus._triggerBroadcast(
+        coreHooks.pluginDeregistrationRequested,
+        {
+          pluginId: "broadcast-plugin",
+          deleteSchema: true,
+        }
+      );
+
+      expect(deregSpy).toHaveBeenCalledWith("broadcast-plugin", {
+        deleteSchema: true,
+      });
+    });
+  });
+
+  describe("loadSinglePlugin", () => {
+    it("should emit pluginInstalling local hook", async () => {
+      // Try loading - will fail import but should still emit installing hook
+      try {
+        await pluginManager.loadSinglePlugin(
+          "nonexistent-plugin",
+          "/nonexistent/path"
+        );
+      } catch {
+        // Expected to fail since plugin doesn't exist
+      }
+
+      // Should have emitted pluginInstalling locally
+      expect(mockEventBus._localEmittedEvents).toContainEqual({
+        hook: coreHooks.pluginInstalling.id,
+        payload: { pluginId: "nonexistent-plugin" },
+      });
+    });
+
+    it("should call installer if import fails", async () => {
+      try {
+        await pluginManager.loadSinglePlugin(
+          "test-remote-plugin",
+          "/nonexistent/path"
+        );
+      } catch {
+        // Expected to fail at the final import, but installer should be called
+      }
+
+      // Installer should have been called when imports failed
+      expect(mockInstaller._installCalls).toContain("test-remote-plugin");
+    });
+  });
+
+  describe("deregisterPlugin", () => {
+    beforeEach(() => {
+      // Setup cleanup handlers for a plugin
+      const cleanupHandlers = (pluginManager as never)[
+        "cleanupHandlers"
+      ] as Map<string, (() => Promise<void>)[]>;
+      cleanupHandlers.set("test-plugin", [async () => {}]);
+    });
+
+    it("should emit pluginDeregistering local hook", async () => {
+      await pluginManager.deregisterPlugin("test-plugin", {
+        deleteSchema: false,
+      });
+
+      const deregisteringEvent = mockEventBus._localEmittedEvents.find(
+        (e) => e.hook === coreHooks.pluginDeregistering.id
+      );
+      expect(deregisteringEvent).toBeDefined();
+      expect(deregisteringEvent?.payload).toMatchObject({
+        pluginId: "test-plugin",
+      });
+    });
+
+    it("should emit pluginDeregistered after cleanup", async () => {
+      await pluginManager.deregisterPlugin("test-plugin", {
+        deleteSchema: false,
+      });
+
+      const deregisteredEvent = mockEventBus._emittedEvents.find(
+        (e) => e.hook === coreHooks.pluginDeregistered.id
+      );
+      expect(deregisteredEvent).toBeDefined();
+      expect(deregisteredEvent?.payload).toMatchObject({
+        pluginId: "test-plugin",
+      });
+    });
+
+    it("should run cleanup handlers in reverse order", async () => {
+      const callOrder: number[] = [];
+      const cleanupHandlers = (pluginManager as never)[
+        "cleanupHandlers"
+      ] as Map<string, (() => Promise<void>)[]>;
+
+      cleanupHandlers.set("test-plugin", [
+        async () => {
+          callOrder.push(1);
+        },
+        async () => {
+          callOrder.push(2);
+        },
+        async () => {
+          callOrder.push(3);
+        },
+      ]);
+
+      await pluginManager.deregisterPlugin("test-plugin", {
+        deleteSchema: false,
+      });
+
+      expect(callOrder).toEqual([3, 2, 1]);
+    });
+
+    it("should remove plugin router", async () => {
+      const pluginRpcRouters = (pluginManager as never)[
+        "pluginRpcRouters"
+      ] as Map<string, unknown>;
+      pluginRpcRouters.set("test-plugin", { mockRouter: true });
+
+      await pluginManager.deregisterPlugin("test-plugin", {
+        deleteSchema: false,
+      });
+
+      expect(pluginRpcRouters.has("test-plugin")).toBe(false);
+    });
+
+    it("should clear permissions for plugin", async () => {
+      const registeredPermissions = (pluginManager as never)[
+        "registeredPermissions"
+      ] as { pluginId: string; id: string }[];
+
+      // Clear existing permissions first
+      while (registeredPermissions.length > 0) {
+        registeredPermissions.pop();
+      }
+
+      // Add test permissions
+      registeredPermissions.push(
+        { pluginId: "test-plugin", id: "test-plugin.perm1" },
+        { pluginId: "test-plugin", id: "test-plugin.perm2" },
+        { pluginId: "other-plugin", id: "other-plugin.perm1" }
+      );
+
+      await pluginManager.deregisterPlugin("test-plugin", {
+        deleteSchema: false,
+      });
+
+      // Use getAllPermissions() which returns the current array
+      const remaining = pluginManager.getAllPermissions();
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0].id).toBe("other-plugin.perm1");
+    });
+  });
+
+  describe("registerCoreRouter", () => {
+    it("should add router to pluginRpcRouters", () => {
+      const mockRouter = { test: true };
+
+      pluginManager.registerCoreRouter("admin", mockRouter);
+
+      const pluginRpcRouters = (pluginManager as never)[
+        "pluginRpcRouters"
+      ] as Map<string, unknown>;
+      expect(pluginRpcRouters.get("admin")).toBe(mockRouter);
+    });
+  });
+});

package/src/plugin-manager/api-router.ts

@@ -0,0 +1,163 @@
+import type { Hono, Context } from "hono";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { RPCHandler } from "@orpc/server/fetch";
+import {
+  coreServices,
+  AuthService,
+  RpcContext,
+  Logger,
+  Fetch,
+  HealthCheckRegistry,
+  type EmitHookFn,
+  type Hook,
+} from "@checkstack/backend-api";
+import type {
+  QueuePluginRegistry,
+  QueueManager,
+} from "@checkstack/queue-api";
+import type { ServiceRegistry } from "../services/service-registry";
+import type { EventBus } from "@checkstack/backend-api";
+import type { PluginMetadata } from "@checkstack/common";
+
+/**
+ * Creates the API route handler for Hono.
+ * Extracted from PluginManager for better organization.
+ */
+export function createApiRouteHandler({
+  registry,
+  pluginRpcRouters,
+  pluginHttpHandlers,
+  pluginMetadataRegistry,
+}: {
+  registry: ServiceRegistry;
+  pluginRpcRouters: Map<string, unknown>;
+  pluginHttpHandlers: Map<string, (req: Request) => Promise<Response>>;
+  pluginMetadataRegistry: Map<string, PluginMetadata>;
+}) {
+  // Helper to get service from registry
+  async function getService<T>(ref: {
+    id: string;
+    T: T;
+  }): Promise<T | undefined> {
+    try {
+      return await registry.get(ref, { pluginId: "core" });
+    } catch {
+      return undefined;
+    }
+  }
+
+  return async function handleApiRequest(c: Context) {
+    // Extract pluginId from Hono path parameter (/api/:pluginId/*)
+    const pluginId = c.req.param("pluginId") || "";
+    const pathname = new URL(c.req.raw.url).pathname;
+
+    // Build RPC handler lazily at request time
+    // This ensures all plugins registered during init are included
+    const rootRpcRouter: Record<string, unknown> = {};
+    for (const [pluginId, router] of pluginRpcRouters.entries()) {
+      rootRpcRouter[pluginId] = router;
+    }
+
+    const rpcHandler = new RPCHandler(
+      rootRpcRouter as ConstructorParameters<typeof RPCHandler>[0]
+    );
+
+    // Resolve core services for RPC context
+    const auth = await getService(coreServices.auth);
+    const logger = await getService(coreServices.logger);
+    const db = await getService(coreServices.database);
+    const fetch = await getService(coreServices.fetch);
+    const healthCheckRegistry = await getService(
+      coreServices.healthCheckRegistry
+    );
+    const queuePluginRegistry = await getService(
+      coreServices.queuePluginRegistry
+    );
+    const queueManager = await getService(coreServices.queueManager);
+    const eventBus = await getService(coreServices.eventBus);
+
+    if (
+      !auth ||
+      !logger ||
+      !db ||
+      !fetch ||
+      !healthCheckRegistry ||
+      !queuePluginRegistry ||
+      !queueManager ||
+      !eventBus
+    ) {
+      return c.json({ error: "Core services not initialized" }, 500);
+    }
+
+    const user = await (auth as AuthService).authenticate(c.req.raw);
+
+    // Create emitHook function using eventBus
+    const emitHook: EmitHookFn = async <T>(hook: Hook<T>, payload: T) => {
+      await (eventBus as EventBus).emit(hook, payload);
+    };
+
+    // Lookup plugin metadata from registry
+    const pluginMetadata: PluginMetadata | undefined =
+      pluginMetadataRegistry.get(pluginId);
+
+    if (!pluginMetadata) {
+      return c.json({ error: "Plugin metadata not found in registry" }, 500);
+    }
+
+    const context: RpcContext = {
+      pluginMetadata,
+      auth: auth as AuthService,
+      logger: logger as Logger,
+      db: db as NodePgDatabase<Record<string, unknown>>,
+      fetch: fetch as Fetch,
+      healthCheckRegistry: healthCheckRegistry as HealthCheckRegistry,
+      queuePluginRegistry: queuePluginRegistry as QueuePluginRegistry,
+      queueManager: queueManager as QueueManager,
+      user,
+      emitHook,
+    };
+
+    // 1. Try oRPC first
+    try {
+      const { matched, response } = await rpcHandler.handle(c.req.raw, {
+        prefix: "/api",
+        context,
+      });
+
+      if (matched) {
+        return c.newResponse(response.body, response);
+      }
+
+      logger.debug(`RPC mismatch for: ${c.req.method} ${pathname}`);
+    } catch (error) {
+      logger.error(`RPC Handler error: ${String(error)}`);
+    }
+
+    // 2. Try native handlers
+    // Sort by path length (descending) to ensure more specific paths are tried first
+    const sortedHandlers = [...pluginHttpHandlers.entries()].toSorted(function (
+      a,
+      b
+    ) {
+      return b[0].length - a[0].length;
+    });
+
+    for (const [path, handler] of sortedHandlers) {
+      if (pathname.startsWith(path)) {
+        return handler(c.req.raw);
+      }
+    }
+
+    return c.json({ error: "Not Found" }, 404);
+  };
+}
+
+/**
+ * Registers the /api/:pluginId/* route with Hono.
+ */
+export function registerApiRoute(
+  rootRouter: Hono,
+  handler: ReturnType<typeof createApiRouteHandler>
+) {
+  rootRouter.all("/api/:pluginId/*", handler);
+}