@checkstack/backend 0.8.2 → 0.9.1

package/src/plugin-lifecycle.test.ts

@@ -1,276 +0,0 @@
-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 access rules for plugin", async () => {
-      const registeredAccessRules = (pluginManager as never)[
-        "registeredAccessRules"
-      ] as { pluginId: string; id: string }[];
-
-      // Clear existing access rules first
-      while (registeredAccessRules.length > 0) {
-        registeredAccessRules.pop();
-      }
-
-      // Add test access rules
-      registeredAccessRules.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 getAllAccessRules() which returns the current array
-      const remaining = pluginManager.getAllAccessRules();
-      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/plugin-admin-router.ts

@@ -1,89 +0,0 @@
-import { implement } from "@orpc/server";
-import {
-  autoAuthMiddleware,
-  type RpcContext,
-} from "@checkstack/backend-api";
-import { pluginAdminContract } from "@checkstack/backend-api";
-import type { PluginManager } from "../plugin-manager";
-import type { PluginInstaller } from "@checkstack/backend-api";
-import { db } from "../db";
-import { plugins } from "../schema";
-import { eq } from "drizzle-orm";
-import { rootLogger } from "../logger";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Router Factory
-// ─────────────────────────────────────────────────────────────────────────────
-
-export function createPluginAdminRouter({
-  pluginManager,
-  installer,
-}: {
-  pluginManager: PluginManager;
-  installer: PluginInstaller;
-}) {
-  const impl = implement(pluginAdminContract)
-    .$context<RpcContext>()
-    .use(autoAuthMiddleware);
-
-  return impl.router({
-    install: impl.install.handler(async ({ input }) => {
-      const { packageName } = input;
-      rootLogger.info(`📦 Installing plugin: ${packageName}`);
-
-      // 1. npm install to filesystem
-      const result = await installer.install(packageName);
-
-      // 2. Insert/update in DB with isUninstallable=true (remote plugin)
-      await db
-        .insert(plugins)
-        .values({
-          name: result.name,
-          path: result.path,
-          enabled: true,
-          isUninstallable: true, // Remote plugins can be uninstalled
-          type: "backend",
-        })
-        .onConflictDoUpdate({
-          target: [plugins.name],
-          set: { path: result.path, enabled: true },
-        });
-
-      // 3. Broadcast to all instances to load the plugin
-      await pluginManager.requestInstallation(result.name, result.path);
-
-      return {
-        success: true,
-        pluginId: result.name,
-        path: result.path,
-      };
-    }),
-
-    deregister: impl.deregister.handler(async ({ input }) => {
-      const { pluginId, deleteSchema } = input;
-      rootLogger.info(`🗑️ Deregistering plugin: ${pluginId}`);
-
-      // Check if plugin exists and is uninstallable
-      const existing = await db
-        .select()
-        .from(plugins)
-        .where(eq(plugins.name, pluginId))
-        .limit(1);
-
-      if (existing.length === 0) {
-        throw new Error(`Plugin ${pluginId} not found`);
-      }
-
-      if (!existing[0].isUninstallable) {
-        throw new Error(
-          `Plugin ${pluginId} is a core plugin and cannot be deregistered`
-        );
-      }
-
-      // Broadcast to all instances to deregister
-      await pluginManager.requestDeregistration(pluginId, { deleteSchema });
-
-      return { success: true };
-    }),
-  });
-}

package/src/services/plugin-installer.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect, mock, beforeEach } from "bun:test";
-
-// 1. Mock child_process and fs BEFORE importing the target module
-const mockExec = mock((_cmd: string, cb: any) => {
-  cb(null, { stdout: "mocked" }, { stderr: "" });
-});
-
-const mockExistsSync = mock(() => true);
-const mockMkdirSync = mock();
-const mockReadFileSync = mock(() => JSON.stringify({ name: "mock-plugin" }));
-
-mock.module("node:util", () => ({
-  promisify: (fn: any) => {
-    return async (...args: any[]) => {
-      // Return a promise that resolves with what our mock would return
-      // We can just call mockExec and return its "result"
-      return new Promise((resolve) => {
-        fn(...args, (err: any, stdout: any, stderr: any) =>
-          resolve({ stdout, stderr })
-        );
-      });
-    };
-  },
-}));
-
-mock.module("node:child_process", () => ({
-  exec: mockExec,
-}));
-
-mock.module("node:fs", () => {
-  const exports = {
-    existsSync: mockExistsSync,
-    mkdirSync: mockMkdirSync,
-    readFileSync: mockReadFileSync,
-  };
-  return {
-    ...exports,
-    default: exports,
-  };
-});
-
-// 2. Now import the module under test
-import { PluginLocalInstaller } from "./plugin-installer";
-import fs from "node:fs";
-import path from "node:path";
-
-describe("PluginLocalInstaller", () => {
-  const runtimeDir = "/tmp/runtime_plugins";
-  let installer: PluginLocalInstaller;
-  let customExec: any;
-
-  beforeEach(() => {
-    customExec = mock(() => Promise.resolve({ stdout: "mocked", stderr: "" }));
-    installer = new PluginLocalInstaller(runtimeDir, customExec);
-    mockExistsSync.mockClear();
-    mockExistsSync.mockReturnValue(true);
-  });
-
-  it("should install a package using bun", async () => {
-    const result = await installer.install("my-plugin");
-
-    expect(customExec).toHaveBeenCalled();
-    const command = customExec.mock.calls[0][0];
-    expect(command).toContain("bun install my-plugin");
-    expect(command).toContain(`--cwd ${path.resolve(runtimeDir)}`);
-    expect(command).toContain("--no-save");
-
-    expect(result.name).toBe("mock-plugin");
-  });
-
-  it("should handle scoped packages correctly", async () => {
-    const result = await installer.install("@scope/plugin");
-
-    expect(customExec).toHaveBeenCalled();
-    const command = customExec.mock.calls[0][0];
-    expect(command).toContain("bun install @scope/plugin");
-
-    expect(result.name).toBe("mock-plugin");
-  });
-
-  it("should throw error if package.json is missing after install", async () => {
-    // The constructor was already called in beforeEach.
-    // The next call to existsSync will be inside the install method for the pkgJsonPath.
-    mockExistsSync.mockReturnValueOnce(false);
-
-    await expect(installer.install("failing-plugin")).rejects.toThrow(
-      "not found"
-    );
-  });
-});

package/src/services/plugin-installer.ts

@@ -1,70 +0,0 @@
-import { PluginInstaller } from "@checkstack/backend-api";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import path from "node:path";
-import fs from "node:fs";
-
-export class PluginLocalInstaller implements PluginInstaller {
-  private runtimeDir: string;
-  private execAsync: (
-    command: string
-  ) => Promise<{ stdout: string; stderr: string }>;
-
-  constructor(
-    runtimeDir: string,
-    customExec?: (
-      command: string
-    ) => Promise<{ stdout: string; stderr: string }>
-  ) {
-    this.runtimeDir = path.resolve(runtimeDir);
-    this.execAsync = customExec || promisify(exec);
-    if (!fs.existsSync(this.runtimeDir)) {
-      fs.mkdirSync(this.runtimeDir, { recursive: true });
-    }
-  }
-
-  async install(packageName: string): Promise<{ name: string; path: string }> {
-    try {
-      console.log(
-        `🔌 Installing plugin: ${packageName} into ${this.runtimeDir}`
-      );
-
-      // Use bun install with --no-save to avoid creating/modifying lockfiles
-      // in the runtime directory. This keeps plugins isolated from the main app.
-      await this.execAsync(
-        `bun install ${packageName} --cwd ${this.runtimeDir} --no-save`
-      );
-
-      // Extract the actual package name (packageName could be a URL or @org/name@version)
-      // For now, we assume it's a simple package name for the path lookup,
-      // or we can parse it better.
-      // A safer way is to check the recently changed folders in node_modules?
-      // Or just assume the input packageName (stripped of @version) matches the folder.
-      let folderName = packageName;
-      if (packageName.includes("@") && !packageName.startsWith("@")) {
-        folderName = packageName.split("@")[0];
-      } else if (packageName.startsWith("@") && packageName.includes("@", 1)) {
-        folderName = "@" + packageName.split("@")[1];
-      }
-
-      const pkgPath = path.join(this.runtimeDir, "node_modules", folderName);
-      const pkgJsonPath = path.join(pkgPath, "package.json");
-
-      if (!fs.existsSync(pkgJsonPath)) {
-        throw new Error(
-          `Package folder ${folderName} not found at ${pkgPath} after installation`
-        );
-      }
-
-      const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
-
-      return {
-        name: pkgJson.name,
-        path: pkgPath,
-      };
-    } catch (error) {
-      console.error(`❌ Failed to install plugin ${packageName}:`, error);
-      throw error;
-    }
-  }
-}