@ic-reactor/vite-plugin 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,72 +1,140 @@
 // src/index.ts
 import fs from "fs";
 import path from "path";
+import { execFileSync } from "child_process";
 import {
   generateDeclarations,
-  generateReactorFile
+  generateReactorFile,
+  generateClientFile
 } from "@ic-reactor/codegen";
-var ICP_LOCAL_IDS_PATH = ".icp/cache/mappings/local.ids.json";
-var IC_ROOT_KEY_HEX = "308182301d060d2b0601040182dc7c0503010201060c2b0601040182dc7c050302010361008b52b4994f94c7ce4be1c1542d7c81dc79fea17d49efe8fa42e8566373581d4b969c4a59e96a0ef51b711fe5027ec01601182519d0a788f4bfe388e593b97cd1d7e44904de79422430bca686ac8c21305b3397b5ba4d7037d17877312fb7ee34";
-function loadLocalCanisterIds(rootDir) {
-  const idsPath = path.resolve(rootDir, ICP_LOCAL_IDS_PATH);
+function getIcEnvironmentInfo(canisterNames) {
+  const environment = process.env.ICP_ENVIRONMENT || "local";
   try {
-    return JSON.parse(fs.readFileSync(idsPath, "utf-8"));
+    const networkStatus = JSON.parse(
+      execFileSync("icp", ["network", "status", "-e", environment, "--json"], {
+        encoding: "utf-8"
+      })
+    );
+    const rootKey = networkStatus.root_key;
+    const proxyTarget = `http://127.0.0.1:${networkStatus.port}`;
+    const canisterIds = {};
+    for (const name of canisterNames) {
+      try {
+        const canisterId = execFileSync(
+          "icp",
+          ["canister", "status", name, "-e", environment, "-i"],
+          {
+            encoding: "utf-8"
+          }
+        ).trim();
+        canisterIds[name] = canisterId;
+      } catch {
+      }
+    }
+    return { environment, rootKey, proxyTarget, canisterIds };
   } catch {
     return null;
   }
 }
-function buildIcEnvCookie(canisterIds) {
-  const envParts = [`ic_root_key=${IC_ROOT_KEY_HEX}`];
+function buildIcEnvCookie(canisterIds, rootKey) {
+  const envParts = [`ic_root_key=${rootKey}`];
   for (const [name, id] of Object.entries(canisterIds)) {
     envParts.push(`PUBLIC_CANISTER_ID:${name}=${id}`);
   }
   return encodeURIComponent(envParts.join("&"));
 }
-function addOrReplaceSetCookie(existing, cookie) {
-  const cookieEntries = typeof existing === "string" ? [existing] : Array.isArray(existing) ? existing.filter((value) => typeof value === "string") : [];
-  const nonIcEnvCookies = cookieEntries.filter(
-    (entry) => !entry.trim().startsWith("ic_env=")
-  );
-  return [...nonIcEnvCookies, cookie];
-}
-function setupIcEnvMiddleware(server) {
-  const rootDir = server.config.root || process.cwd();
-  const idsPath = path.resolve(rootDir, ICP_LOCAL_IDS_PATH);
-  let hasLoggedHint = false;
-  server.middlewares.use((req, res, next) => {
-    const canisterIds = loadLocalCanisterIds(rootDir);
-    if (!canisterIds) {
-      if (!hasLoggedHint) {
-        server.config.logger.info(
-          `[ic-reactor] icp-cli local IDs not found at ${idsPath}. Run \`icp deploy\` to enable automatic ic_env cookie injection.`
-        );
-        hasLoggedHint = true;
-      }
-      return next();
-    }
-    const cookie = `ic_env=${buildIcEnvCookie(canisterIds)}; Path=/; SameSite=Lax;`;
-    const current = res.getHeader("Set-Cookie");
-    res.setHeader("Set-Cookie", addOrReplaceSetCookie(current, cookie));
-    next();
-  });
-}
 function icReactorPlugin(options) {
-  const baseOutDir = options.outDir ?? "./src/canisters";
+  const baseOutDir = options.outDir ?? "./src/lib/canisters";
   return {
     name: "ic-reactor-plugin",
-    configureServer(server) {
-      if (options.autoInjectIcEnv ?? true) {
-        setupIcEnvMiddleware(server);
+    config(_config, { command }) {
+      if (command !== "serve" || !(options.injectEnvironment ?? true)) {
+        return {};
       }
+      const canisterNames = options.canisters.map((c) => c.name);
+      const icEnv = getIcEnvironmentInfo(canisterNames);
+      if (!icEnv) {
+        return {
+          server: {
+            proxy: {
+              "/api": {
+                target: "http://127.0.0.1:4943",
+                changeOrigin: true
+              }
+            }
+          }
+        };
+      }
+      const cookieValue = buildIcEnvCookie(icEnv.canisterIds, icEnv.rootKey);
+      return {
+        server: {
+          headers: {
+            "Set-Cookie": `ic_env=${cookieValue}; Path=/; SameSite=Lax;`
+          },
+          proxy: {
+            "/api": {
+              target: icEnv.proxyTarget,
+              changeOrigin: true
+            }
+          }
+        }
+      };
     },
     async buildStart() {
+      const defaultClientPath = path.resolve(
+        process.cwd(),
+        "src/lib/clients.ts"
+      );
+      if (!fs.existsSync(defaultClientPath)) {
+        console.log(
+          `[ic-reactor] Default client manager not found. Creating at ${defaultClientPath}`
+        );
+        const clientContent = generateClientFile();
+        fs.mkdirSync(path.dirname(defaultClientPath), { recursive: true });
+        fs.writeFileSync(defaultClientPath, clientContent);
+      }
       for (const canister of options.canisters) {
+        let didFile = canister.didFile;
         const outDir = canister.outDir ?? path.join(baseOutDir, canister.name);
+        if (!didFile) {
+          const environment = process.env.ICP_ENVIRONMENT || "local";
+          console.log(
+            `[ic-reactor] didFile not specified for "${canister.name}". Attempting to download from canister...`
+          );
+          try {
+            const candidContent = execFileSync(
+              "icp",
+              [
+                "canister",
+                "metadata",
+                canister.name,
+                "candid:service",
+                "-e",
+                environment
+              ],
+              { encoding: "utf-8" }
+            ).trim();
+            const declarationsDir = path.join(outDir, "declarations");
+            if (!fs.existsSync(declarationsDir)) {
+              fs.mkdirSync(declarationsDir, { recursive: true });
+            }
+            didFile = path.join(declarationsDir, `${canister.name}.did`);
+            fs.writeFileSync(didFile, candidContent);
+            console.log(
+              `[ic-reactor] Candid downloaded and saved to ${didFile}`
+            );
+          } catch (error) {
+            console.error(
+              `[ic-reactor] Failed to download candid for ${canister.name}: ${error}`
+            );
+            continue;
+          }
+        }
         console.log(
-          `[ic-reactor] Generating hooks for ${canister.name} from ${canister.didFile}`
+          `[ic-reactor] Generating hooks for ${canister.name} from ${didFile}`
         );
         const result = await generateDeclarations({
-          didFile: canister.didFile,
+          didFile,
           outDir,
           canisterName: canister.name
         });
@@ -76,28 +144,10 @@ function icReactorPlugin(options) {
           );
           continue;
         }
-        console.log(
-          `[ic-reactor] Declarations generated at ${result.declarationsDir}`
-        );
-        const useAdvanced = canister.advanced ?? options.advanced ?? false;
-        let didContent;
-        if (useAdvanced) {
-          try {
-            didContent = fs.readFileSync(canister.didFile, "utf-8");
-          } catch (e) {
-            console.warn(
-              `[ic-reactor] Could not read DID file at ${canister.didFile}, skipping advanced hook generation for ${canister.name}.`
-            );
-            continue;
-          }
-        }
         const reactorContent = generateReactorFile({
           canisterName: canister.name,
-          canisterConfig: canister,
-          globalClientManagerPath: options.clientManagerPath,
-          hasDeclarations: true,
-          advanced: useAdvanced,
-          didContent
+          didFile,
+          clientManagerPath: canister.clientManagerPath ?? options.clientManagerPath
         });
         const reactorPath = path.join(outDir, "index.ts");
         fs.mkdirSync(outDir, { recursive: true });
@@ -107,9 +157,10 @@ function icReactorPlugin(options) {
     },
     handleHotUpdate({ file, server }) {
       if (file.endsWith(".did")) {
-        const canister = options.canisters.find(
-          (c) => path.resolve(c.didFile) === file
-        );
+        const canister = options.canisters.find((c) => {
+          if (!c.didFile) return false;
+          return path.resolve(c.didFile) === file;
+        });
         if (canister) {
           console.log(
             `[ic-reactor] Detected change in ${file}, regenerating...`
@@ -120,8 +171,6 @@ function icReactorPlugin(options) {
     }
   };
 }
-var index_default = icReactorPlugin;
 export {
-  index_default as default,
   icReactorPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/vite-plugin",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Vite plugin for zero-config IC reactor generation from Candid files",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -37,20 +37,22 @@
     "url": "https://github.com/B3Pay/ic-reactor/issues"
   },
   "dependencies": {
-    "@ic-reactor/codegen": "0.2.0"
+    "@ic-reactor/codegen": "0.3.1"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0"
   },
   "devDependencies": {
     "@icp-sdk/bindgen": "^0.2.1",
-    "@types/node": "^25.2.2",
+    "@types/node": "^25.2.3",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vite": "^7.3.1"
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --tsconfig tsconfig.json",
-    "dev": "tsup src/index.ts --format esm,cjs --dts --watch --tsconfig tsconfig.json"
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch --tsconfig tsconfig.json",
+    "test": "vitest run"
   }
 }

package/src/index.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { icReactorPlugin, type IcReactorPluginOptions } from "./index"
+import fs from "fs"
+import path from "path"
+import { execFileSync } from "child_process"
+import {
+  generateDeclarations,
+  generateReactorFile,
+  generateClientFile,
+} from "@ic-reactor/codegen"
+
+// Mock internal dependencies
+vi.mock("@ic-reactor/codegen", () => ({
+  generateDeclarations: vi.fn(),
+  generateReactorFile: vi.fn(),
+  generateClientFile: vi.fn(),
+}))
+
+// Mock child_process
+vi.mock("child_process", () => ({
+  execFileSync: vi.fn(),
+}))
+
+// Mock fs
+vi.mock("fs", () => ({
+  default: {
+    existsSync: vi.fn(() => true),
+    readFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+  },
+}))
+
+describe("icReactorPlugin", () => {
+  const mockOptions: IcReactorPluginOptions = {
+    canisters: [
+      {
+        name: "test_canister",
+        didFile: "src/declarations/test.did",
+        outDir: "src/declarations/test_canister",
+      },
+    ],
+    outDir: "src/declarations",
+  }
+
+  const mockServer: any = {
+    config: {
+      root: "/mock/root",
+      logger: {
+        info: vi.fn(),
+      },
+    },
+    middlewares: {
+      use: vi.fn(),
+    },
+    restart: vi.fn(),
+  }
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    ;(generateDeclarations as any).mockResolvedValue({
+      success: true,
+      declarationsDir: "/mock/declarations",
+    })
+    ;(generateReactorFile as any).mockReturnValue("export const reactor = {}")
+    ;(generateClientFile as any).mockReturnValue("export const client = {}")
+  })
+
+  it("should return correct plugin structure", () => {
+    const plugin = icReactorPlugin(mockOptions)
+    expect(plugin.name).toBe("ic-reactor-plugin")
+    expect(plugin.buildStart).toBeDefined()
+    expect(plugin.handleHotUpdate).toBeDefined()
+    expect((plugin as any).config).toBeDefined()
+    // configureServer is no longer used for middleware
+    expect(plugin.configureServer).toBeUndefined()
+  })
+
+  describe("config", () => {
+    it("should set up API proxy and headers when icp-cli is available", () => {
+      ;(execFileSync as any).mockImplementation(
+        (command: string, args: string[], options: any) => {
+          if (
+            command === "icp" &&
+            args.includes("network") &&
+            args.includes("status")
+          ) {
+            return JSON.stringify({ root_key: "mock-root-key", port: 4943 })
+          }
+          if (
+            command === "icp" &&
+            args.includes("canister") &&
+            args.includes("status")
+          ) {
+            return "mock-canister-id"
+          }
+          return ""
+        }
+      )
+
+      const plugin = icReactorPlugin(mockOptions)
+      const config = (plugin as any).config({}, { command: "serve" })
+
+      expect(config.server.headers["Set-Cookie"]).toContain("ic_env=")
+      expect(config.server.headers["Set-Cookie"]).toContain(
+        "PUBLIC_CANISTER_ID%3Atest_canister%3Dmock-canister-id"
+      )
+      expect(config.server.headers["Set-Cookie"]).toContain(
+        "ic_root_key%3Dmock-root-key"
+      )
+      expect(config.server.proxy["/api"].target).toBe("http://127.0.0.1:4943")
+    })
+
+    it("should fallback to default proxy when icp-cli fails", () => {
+      ;(execFileSync as any).mockImplementation(() => {
+        throw new Error("Command not found")
+      })
+
+      const plugin = icReactorPlugin(mockOptions)
+      const config = (plugin as any).config({}, { command: "serve" })
+
+      expect(config.server.headers).toBeUndefined()
+      expect(config.server.proxy["/api"].target).toBe("http://127.0.0.1:4943")
+    })
+
+    it("should return empty config for build command", () => {
+      const plugin = icReactorPlugin(mockOptions)
+      const config = (plugin as any).config({}, { command: "build" })
+
+      expect(config).toEqual({})
+    })
+  })
+
+  describe("buildStart", () => {
+    it("should generate declarations and reactor file", async () => {
+      const plugin = icReactorPlugin(mockOptions)
+      await (plugin.buildStart as any)()
+
+      expect(generateDeclarations).toHaveBeenCalledWith({
+        didFile: "src/declarations/test.did",
+        outDir: "src/declarations/test_canister",
+        canisterName: "test_canister",
+      })
+
+      expect(generateReactorFile).toHaveBeenCalledWith({
+        canisterName: "test_canister",
+        didFile: "src/declarations/test.did",
+        clientManagerPath: undefined,
+      })
+
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        path.join("src/declarations/test_canister", "index.ts"),
+        "export const reactor = {}"
+      )
+    })
+
+    it("should download candid if not specified", async () => {
+      const optionsWithMissingDid: IcReactorPluginOptions = {
+        canisters: [
+          {
+            name: "missing_did",
+            outDir: "src/declarations/missing_did",
+          },
+        ],
+        outDir: "src/declarations",
+      }
+
+      ;(execFileSync as any).mockImplementation(
+        (command: string, args: string[]) => {
+          if (command === "icp" && args.includes("metadata")) {
+            return "service : { greet: (text) -> (text) query }"
+          }
+          return ""
+        }
+      )
+
+      const plugin = icReactorPlugin(optionsWithMissingDid)
+      await (plugin.buildStart as any)()
+
+      expect(execFileSync).toHaveBeenCalledWith(
+        "icp",
+        expect.arrayContaining([
+          "canister",
+          "metadata",
+          "missing_did",
+          "candid:service",
+        ]),
+        expect.any(Object)
+      )
+
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        path.join(
+          "src/declarations/missing_did/declarations",
+          "missing_did.did"
+        ),
+        "service : { greet: (text) -> (text) query }"
+      )
+
+      expect(generateDeclarations).toHaveBeenCalledWith({
+        didFile: path.join(
+          "src/declarations/missing_did/declarations",
+          "missing_did.did"
+        ),
+        outDir: "src/declarations/missing_did",
+        canisterName: "missing_did",
+      })
+
+      expect(generateReactorFile).toHaveBeenCalledWith({
+        canisterName: "missing_did",
+        didFile: path.join(
+          "src/declarations/missing_did/declarations",
+          "missing_did.did"
+        ),
+        clientManagerPath: undefined,
+      })
+    })
+
+    it("should handle generation errors", async () => {
+      const consoleErrorSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {})
+
+      ;(generateDeclarations as any).mockResolvedValue({
+        success: false,
+        error: "Failed to generate",
+      })
+
+      const plugin = icReactorPlugin(mockOptions)
+      await (plugin.buildStart as any)()
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Failed to generate declarations")
+      )
+      expect(generateReactorFile).not.toHaveBeenCalled()
+
+      consoleErrorSpy.mockRestore()
+    })
+  })
+
+  describe("handleHotUpdate", () => {
+    it("should restart server when .did file changes", () => {
+      const plugin = icReactorPlugin(mockOptions)
+      const ctx = {
+        file: "/absolute/path/to/src/declarations/test.did",
+        server: mockServer,
+      }
+
+      // Mock path.resolve to match the test case
+      const originalResolve = path.resolve
+      vi.spyOn(path, "resolve").mockImplementation((...args) => {
+        if (args.some((a) => a.includes("test.did"))) {
+          return "/absolute/path/to/src/declarations/test.did"
+        }
+        return originalResolve(...args)
+      })
+      ;(plugin.handleHotUpdate as any)(ctx)
+
+      expect(mockServer.restart).toHaveBeenCalled()
+    })
+
+    it("should ignore other files", () => {
+      const plugin = icReactorPlugin(mockOptions)
+      const ctx = {
+        file: "/some/other/file.ts",
+        server: mockServer,
+      }
+
+      ;(plugin.handleHotUpdate as any)(ctx)
+
+      expect(mockServer.restart).not.toHaveBeenCalled()
+    })
+  })
+})