every-plugin 0.8.9 → 2.2.2

package/src/build/rspack/dev-server-middleware.ts

@@ -0,0 +1,233 @@
+import type { PluginInfo } from "./utils";
+
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+  "Access-Control-Allow-Headers": "X-Requested-With, content-type, Authorization",
+};
+
+const applyCorsHeaders = (res: any) => {
+  Object.entries(corsHeaders).forEach(([key, value]) => {
+    res.setHeader(key, value);
+  });
+};
+
+const normalizePrefix = (prefix?: string): string => {
+  if (!prefix) return "";
+  const cleaned = prefix.replace(/^\/+|\/+$/g, "");
+  return cleaned ? `/${cleaned}` : "";
+};
+
+export function setupPluginMiddleware(
+  devServer: any,
+  pluginInfo: PluginInfo,
+  devConfig: any,
+  port: number,
+) {
+  const rpcPrefix = normalizePrefix(devConfig?.prefix);
+  const handlers: { rpc: any; api: any } = { rpc: null, api: null };
+  let cleanup: (() => Promise<void>) | null = null;
+
+  const performCleanup = async () => {
+    if (cleanup) {
+      await cleanup();
+      cleanup = null;
+    }
+  };
+
+  (async () => {
+    await performCleanup();
+
+    try {
+      const { createPluginRuntime } = await import("every-plugin");
+      const { RPCHandler } = await import("@orpc/server/fetch");
+      const { OpenAPIHandler } = await import("@orpc/openapi/fetch");
+      const { OpenAPIReferencePlugin } = await import("@orpc/openapi/plugins");
+      const { ZodToJsonSchemaConverter } = await import("@orpc/zod/zod4");
+      const { onError } = await import("every-plugin/orpc");
+      const { formatORPCError } = await import("every-plugin/errors");
+
+      const pluginId = devConfig?.pluginId || pluginInfo.normalizedName;
+
+      const runtime = createPluginRuntime({
+        registry: {
+          [pluginId]: {
+            remote: `http://localhost:${port}/remoteEntry.js`,
+          },
+        },
+      });
+
+      const defaultConfig = { variables: {}, secrets: {} };
+
+      // @ts-expect-error we don't know the plugin id
+      const loaded = await runtime.usePlugin(pluginId, (devConfig?.config ?? defaultConfig) as any);
+
+      cleanup = async () => {
+        if (loaded && typeof (loaded as any).dispose === "function") {
+          await (loaded as any).dispose();
+        }
+        if (runtime && typeof (runtime as any).cleanup === "function") {
+          await (runtime as any).cleanup();
+        }
+        handlers.rpc = null;
+        handlers.api = null;
+        if (devServer.app.locals.handlers) {
+          devServer.app.locals.handlers = null;
+        }
+      };
+
+      handlers.rpc = new RPCHandler(loaded.router, {
+        interceptors: [
+          onError((error: any) => {
+            formatORPCError(error);
+          }),
+        ],
+      });
+
+      handlers.api = new OpenAPIHandler(loaded.router, {
+        plugins: [
+          new OpenAPIReferencePlugin({
+            schemaConverters: [new ZodToJsonSchemaConverter()],
+          }),
+        ],
+        interceptors: [
+          onError((error: any) => {
+            formatORPCError(error);
+          }),
+        ],
+      });
+
+      console.log(`╭─────────────────────────────────────────────`);
+      console.log(`│  ✅ Plugin dev server ready: `);
+      console.log(`├─────────────────────────────────────────────`);
+      console.log(`│  📡 RPC:    http://localhost:${port}/api/rpc${rpcPrefix}`);
+      console.log(`│  📖 Docs:   http://localhost:${port}/api`);
+      console.log(`│  💚 Health: http://localhost:${port}/`);
+      console.log(`╰─────────────────────────────────────────────`);
+
+      devServer.app.locals.handlers = handlers;
+
+      if (devServer.server) {
+        devServer.server.once("close", async () => {
+          await performCleanup();
+        });
+      }
+    } catch (error) {
+      console.error("❌ Failed to load plugin:", error);
+      await performCleanup();
+    }
+  })();
+
+  process.once("SIGINT", async () => {
+    const timeout = setTimeout(() => process.exit(0), 3000);
+    await performCleanup();
+    clearTimeout(timeout);
+  });
+  process.once("SIGTERM", async () => {
+    const timeout = setTimeout(() => process.exit(0), 3000);
+    await performCleanup();
+    clearTimeout(timeout);
+  });
+
+  devServer.app.options("*", (_req: any, res: any) => {
+    applyCorsHeaders(res);
+    res.status(200).end();
+  });
+
+  devServer.app.get("/", (_req: any, res: any) => {
+    applyCorsHeaders(res);
+    res.json({
+      ok: true,
+      plugin: pluginInfo.normalizedName,
+      version: pluginInfo.version,
+      status: devServer.app.locals.handlers?.rpc ? "ready" : "loading",
+      endpoints: {
+        health: "/",
+        docs: "/api",
+        rpc: `/api/rpc${rpcPrefix}`,
+      },
+    });
+  });
+
+  devServer.app.get("/health", (_req: any, res: any) => {
+    applyCorsHeaders(res);
+    res.status(200).send("OK");
+  });
+
+  const handleApiRequest = async (req: any, res: any) => {
+    applyCorsHeaders(res);
+    const apiHandler = devServer.app.locals.handlers?.api;
+    if (!apiHandler) {
+      return res.status(503).json({ error: "Plugin still loading..." });
+    }
+
+    try {
+      const url = `http://${req.headers.host}${req.url}`;
+      const webRequest = new Request(url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.method !== "GET" && req.method !== "HEAD" ? req : undefined,
+        duplex: req.method !== "GET" && req.method !== "HEAD" ? "half" : undefined,
+      } as RequestInit);
+
+      const result = await apiHandler.handle(webRequest, {
+        prefix: "/api",
+        context: {},
+      });
+
+      if (result.response) {
+        res.status(result.response.status);
+        result.response.headers.forEach((value: string, key: string) => {
+          res.setHeader(key, value);
+        });
+        const text = await result.response.text();
+        res.send(text);
+      } else {
+        res.status(404).send("Not Found");
+      }
+    } catch (error) {
+      console.error("OpenAPI error:", error);
+      res.status(500).json({ error: (error as Error).message });
+    }
+  };
+
+  devServer.app.all(`/api/rpc${rpcPrefix}/*`, async (req: any, res: any) => {
+    applyCorsHeaders(res);
+    const rpcHandler = devServer.app.locals.handlers?.rpc;
+    if (!rpcHandler) {
+      return res.status(503).json({ error: "Plugin still loading..." });
+    }
+
+    try {
+      const url = `http://${req.headers.host}${req.url}`;
+      const webRequest = new Request(url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.method !== "GET" && req.method !== "HEAD" ? req : undefined,
+        duplex: req.method !== "GET" && req.method !== "HEAD" ? "half" : undefined,
+      } as RequestInit);
+
+      const result = await rpcHandler.handle(webRequest, {
+        prefix: `/api/rpc${rpcPrefix}`,
+        context: {},
+      });
+
+      if (result.response) {
+        res.status(result.response.status);
+        result.response.headers.forEach((value: string, key: string) => {
+          res.setHeader(key, value);
+        });
+        const text = await result.response.text();
+        res.send(text);
+      } else {
+        res.status(404).send("Not Found");
+      }
+    } catch (error) {
+      console.error("RPC error:", error);
+      res.status(500).json({ error: (error as Error).message });
+    }
+  });
+
+  devServer.app.all("/api", handleApiRequest);
+  devServer.app.all("/api/*", handleApiRequest);
+}

package/src/build/rspack/fix-mf-data-uri-plugin.ts

@@ -0,0 +1,49 @@
+import type { Compiler, RspackPluginInstance } from "@rspack/core";
+
+const MF_DATA_URI_MARKER = "data:text/javascript,";
+
+export class FixMfDataUriPlugin implements RspackPluginInstance {
+  name = "FixMfDataUriPlugin";
+
+  apply(compiler: Compiler) {
+    compiler.hooks.compilation.tap(this.name, (_compilation, { normalModuleFactory }) => {
+      normalModuleFactory.hooks.beforeResolve.tap(this.name, (resolveData) => {
+        if (!resolveData?.request) return;
+        if (!resolveData.request.includes(MF_DATA_URI_MARKER)) return;
+        this.reencodeDataUri(resolveData);
+      });
+    });
+  }
+
+  private reencodeDataUri(resolveData: { request: string }) {
+    const { request } = resolveData;
+    const idx = request.indexOf(MF_DATA_URI_MARKER);
+    if (idx === -1) return;
+
+    const contentStart = idx + MF_DATA_URI_MARKER.length;
+    const prefix = request.substring(0, contentStart);
+    const rawContent = request.substring(contentStart);
+
+    if (isAlreadyEncoded(rawContent)) return;
+
+    const decoded = safeDecode(rawContent);
+    resolveData.request = prefix + encodeURIComponent(decoded);
+  }
+}
+
+function isAlreadyEncoded(content: string): boolean {
+  try {
+    const decoded = decodeURIComponent(content);
+    return decoded !== content;
+  } catch {
+    return false;
+  }
+}
+
+function safeDecode(content: string): string {
+  try {
+    return decodeURIComponent(content);
+  } catch {
+    return content.replace(/%(?![0-9A-Fa-f]{2})/g, "%25");
+  }
+}

package/src/build/rspack/index.ts

@@ -0,0 +1,14 @@
+export {
+  getMajorMinorVersion,
+  getPluginSharedDependencies,
+  getPluginSharedDependenciesVersionRange,
+  type SharedDependencies,
+  type SharedDependencyConfig,
+} from "../shared-deps";
+export { FixMfDataUriPlugin } from "./fix-mf-data-uri-plugin";
+export {
+  EmitPluginManifest,
+  EveryPluginDevServer,
+  type EveryPluginOptions,
+  type PluginManifestEmitterOptions,
+} from "./plugin";

package/src/build/rspack/module-federation.ts

@@ -0,0 +1,6 @@
+import { getPluginSharedDependencies } from "../shared-deps";
+import type { PluginInfo } from "./utils";
+
+export function buildSharedDependencies(_pluginInfo: PluginInfo) {
+  return getPluginSharedDependencies();
+}

package/src/build/rspack/plugin.ts

@@ -0,0 +1,252 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { ModuleFederationPlugin } from "@module-federation/enhanced/rspack";
+import type { Compiler, RspackPluginInstance } from "@rspack/core";
+import { setupPluginMiddleware } from "./dev-server-middleware";
+import { buildSharedDependencies } from "./module-federation";
+import { getPluginInfo, loadDevConfig } from "./utils";
+
+export interface EveryPluginOptions {
+  devConfigPath?: string;
+  port?: number;
+  pluginId?: string;
+  dts?: boolean;
+}
+
+export interface PluginManifestEmitterOptions {
+  manifestFileName?: string;
+  contractFileName?: string;
+}
+
+export class EmitPluginManifest implements RspackPluginInstance {
+  name = "EmitPluginManifest";
+
+  constructor(private options: PluginManifestEmitterOptions = {}) {}
+
+  apply(compiler: Compiler) {
+    compiler.hooks.thisCompilation.tap(this.name, (compilation) => {
+      const webpack = (compiler as Compiler & { webpack?: any }).webpack;
+      const rawSource = webpack?.sources?.RawSource;
+      const stage = webpack?.Compilation?.PROCESS_ASSETS_STAGE_ADDITIONS ?? 1000;
+
+      compilation.hooks.processAssets.tapPromise({ name: this.name, stage }, async () => {
+        const context = compiler.options.context || process.cwd();
+        const pluginInfo = getPluginInfo(context);
+        const contractFileName = this.options.contractFileName ?? "contract.d.ts";
+        const manifestFileName = this.options.manifestFileName ?? "plugin.manifest.json";
+
+        const sourceContractPath = path.join(context, "types", contractFileName);
+
+        let contractTypes: string;
+
+        const tryReadFile = async (filePath: string): Promise<string | null> => {
+          if (!fs.existsSync(filePath)) {
+            return null;
+          }
+          const stats = fs.statSync(filePath);
+          if (!stats.isFile()) {
+            return null;
+          }
+          try {
+            return await fs.promises.readFile(filePath, "utf8");
+          } catch {
+            return null;
+          }
+        };
+
+        contractTypes = (await tryReadFile(sourceContractPath)) ?? "";
+
+        if (!contractTypes) {
+          const packageDir = context.split("/").pop();
+          const nestedPath = path.join(context, "types", packageDir ?? "", "src", contractFileName);
+
+          contractTypes = (await tryReadFile(nestedPath)) ?? "";
+
+          if (!contractTypes) {
+            console.warn(
+              `[EmitPluginManifest] Contract file not found at ${sourceContractPath} or ${nestedPath}. ` +
+                `Skipping manifest generation.`,
+            );
+            return;
+          }
+        }
+
+        const contractSha256 = crypto.createHash("sha256").update(contractTypes).digest("hex");
+        const manifest = {
+          schemaVersion: 1,
+          kind: "every-plugin/manifest",
+          plugin: {
+            name: pluginInfo.name,
+            version: pluginInfo.version,
+          },
+          runtime: {
+            remoteEntry: "./remoteEntry.js",
+          },
+          contract: {
+            kind: "orpc",
+            types: {
+              path: `./types/${contractFileName}`,
+              exportName: "contract",
+              typeName: "ContractType",
+              sha256: contractSha256,
+            },
+          },
+        };
+
+        if (rawSource) {
+          compilation.emitAsset(
+            manifestFileName,
+            new rawSource(`${JSON.stringify(manifest, null, 2)}\n`),
+          );
+          compilation.emitAsset(`types/${contractFileName}`, new rawSource(`${contractTypes}`));
+        }
+      });
+    });
+  }
+}
+
+export class EveryPluginDevServer implements RspackPluginInstance {
+  name = "EveryPluginDevServer";
+
+  constructor(private options: EveryPluginOptions = {}) {}
+
+  apply(compiler: Compiler) {
+    const pluginInfo = getPluginInfo(compiler.options.context || process.cwd());
+    const devConfig = loadDevConfig(this.options.devConfigPath || "./plugin.dev.ts");
+    const port = Number(process.env.PORT) || this.options.port || devConfig?.port || 3999;
+
+    this.configureDefaults(compiler, pluginInfo);
+
+    if (!compiler.options.devServer) {
+      compiler.options.devServer = {};
+    }
+
+    this.configureDevServer(compiler, pluginInfo, devConfig, port);
+
+    new ModuleFederationPlugin({
+      name: pluginInfo.normalizedName,
+      filename: "remoteEntry.js",
+      dts: this.options.dts !== false,
+      manifest: {},
+      runtimePlugins: [require.resolve("@module-federation/node/runtimePlugin")],
+      library: { type: "commonjs-module" },
+      exposes: {
+        "./plugin": "./src/index.ts",
+      },
+      shared: buildSharedDependencies(pluginInfo),
+      shareStrategy: "version-first",
+    }).apply(compiler);
+
+    if (this.options.dts === false) {
+      compiler.options.plugins = (compiler.options.plugins ?? []).filter(
+        (p) =>
+          !p ||
+          typeof p !== "object" ||
+          ((p as any).name !== "MFDevPlugin" && (p as any).name !== "ModuleFederationDtsPlugin"),
+      );
+    }
+  }
+
+  private configureDefaults(compiler: Compiler, pluginInfo: any) {
+    const context = compiler.options.context || process.cwd();
+
+    if (!compiler.options.output) {
+      compiler.options.output = {};
+    }
+    compiler.options.output.uniqueName = pluginInfo.normalizedName;
+    compiler.options.output.publicPath = "auto";
+    compiler.options.output.path = path.resolve(context, "dist");
+    compiler.options.output.clean = true;
+    compiler.options.output.library = { type: "commonjs-module" };
+
+    if (!compiler.options.target) {
+      compiler.options.target = "async-node";
+    }
+
+    if (!compiler.options.mode) {
+      compiler.options.mode = process.env.NODE_ENV === "development" ? "development" : "production";
+    }
+
+    if (!compiler.options.devtool) {
+      compiler.options.devtool = "source-map";
+    }
+
+    if (!compiler.options.infrastructureLogging) {
+      compiler.options.infrastructureLogging = {
+        level: "warn",
+      };
+    }
+
+    this.ensureTypeScriptLoader(compiler);
+
+    if (!compiler.options.resolve) {
+      compiler.options.resolve = {};
+    }
+    compiler.options.resolve.extensions = ["...", ".tsx", ".ts"];
+    compiler.options.resolve.fallback = {
+      ...compiler.options.resolve.fallback,
+      bufferutil: false,
+      "utf-8-validate": false,
+    };
+  }
+
+  private ensureTypeScriptLoader(compiler: Compiler) {
+    if (!compiler.options.module) {
+      compiler.options.module = { rules: [] } as any;
+    }
+
+    if (!compiler.options.module.rules) {
+      compiler.options.module.rules = [];
+    }
+
+    const hasTsLoader = compiler.options.module.rules.some(
+      (rule: any) =>
+        typeof rule === "object" &&
+        rule !== null &&
+        "test" in rule &&
+        rule.test instanceof RegExp &&
+        rule.test.test(".ts"),
+    );
+
+    if (!hasTsLoader) {
+      compiler.options.module.rules.push({
+        test: /\.tsx?$/,
+        use: "builtin:swc-loader",
+        exclude: /node_modules/,
+      });
+    }
+  }
+
+  private configureDevServer(compiler: Compiler, pluginInfo: any, devConfig: any, port: number) {
+    if (!compiler.options.devServer) {
+      return;
+    }
+
+    const context = compiler.options.context || process.cwd();
+    const originalSetup = compiler.options.devServer.setupMiddlewares;
+
+    compiler.options.devServer.port = port;
+    compiler.options.devServer.static = path.join(context, "dist");
+    compiler.options.devServer.hot = true;
+    compiler.options.devServer.devMiddleware = { writeToDisk: true };
+    compiler.options.devServer.headers = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+      "Access-Control-Allow-Headers": "X-Requested-With, content-type, Authorization",
+    };
+
+    compiler.options.devServer.client = {
+      logging: "warn",
+      overlay: {
+        warnings: false,
+        errors: true,
+      },
+    };
+
+    compiler.options.devServer.setupMiddlewares = (middlewares, devServer) => {
+      setupPluginMiddleware(devServer, pluginInfo, devConfig, port);
+      return originalSetup ? originalSetup(middlewares, devServer) : middlewares;
+    };
+  }
+}

package/src/build/rspack/utils.ts

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getNormalizedRemoteName } from "every-plugin/normalize";
+
+export interface PluginInfo {
+  name: string;
+  version: string;
+  normalizedName: string;
+  dependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+}
+
+export function getPluginInfo(context: string): PluginInfo {
+  const pkgPath = path.join(context, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+
+  return {
+    name: pkg.name,
+    version: pkg.version,
+    normalizedName: getNormalizedRemoteName(pkg.name),
+    dependencies: pkg.dependencies || {},
+    peerDependencies: pkg.peerDependencies || {},
+  };
+}
+
+const loadedModules = new Set<string>();
+
+export function loadDevConfig(devConfigPath: string) {
+  if (process.env.DEPLOY === "true") {
+    return null;
+  }
+
+  try {
+    const fullPath = path.resolve(devConfigPath);
+
+    if (loadedModules.has(fullPath)) {
+      delete require.cache[fullPath];
+      const dirPath = path.dirname(fullPath);
+      for (const key of Object.keys(require.cache)) {
+        if (key.startsWith(dirPath) && key !== fullPath) {
+          delete require.cache[key];
+        }
+      }
+    }
+
+    const module = require(fullPath).default;
+    loadedModules.add(fullPath);
+    return module;
+  } catch (error) {
+    console.warn(`Could not load dev config from ${devConfigPath}:`, (error as Error).message);
+    return null;
+  }
+}
+
+export function cleanupDevConfig() {
+  for (const modulePath of loadedModules) {
+    delete require.cache[modulePath];
+  }
+  loadedModules.clear();
+}

package/src/build/shared-deps.ts

@@ -0,0 +1,79 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+let pkg: typeof import("../../package.json");
+
+try {
+  pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
+} catch {
+  pkg = require("every-plugin/package.json");
+}
+
+export interface SharedDependencyConfig {
+  version: string;
+  requiredVersion: string | false;
+  singleton: boolean;
+  strictVersion: boolean;
+  eager: boolean;
+}
+
+export type SharedDependencies = Record<string, SharedDependencyConfig>;
+
+const DEFAULT_SHARE_CONFIG: Omit<SharedDependencyConfig, "version"> = {
+  requiredVersion: false,
+  singleton: true,
+  strictVersion: false,
+  eager: false,
+};
+
+function extractExactVersion(input: string): string {
+  const match = input.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  return match ? match[0] : input.replace(/^[\^~>=<\s]+/, "");
+}
+
+function getInstalledPackageVersion(packageName: string, fallbackVersion: string): string {
+  try {
+    return require(`${packageName}/package.json`).version as string;
+  } catch {
+    return extractExactVersion(fallbackVersion);
+  }
+}
+
+export const pluginSharedDependencies = {
+  "every-plugin": { version: pkg.version, ...DEFAULT_SHARE_CONFIG },
+  effect: {
+    version: getInstalledPackageVersion("effect", pkg.peerDependencies.effect),
+    ...DEFAULT_SHARE_CONFIG,
+  },
+  zod: {
+    version: getInstalledPackageVersion("zod", pkg.peerDependencies.zod),
+    ...DEFAULT_SHARE_CONFIG,
+  },
+} satisfies SharedDependencies;
+
+export type PluginSharedDependencyName = keyof typeof pluginSharedDependencies;
+
+export function getPluginSharedDependencies(): SharedDependencies {
+  return pluginSharedDependencies;
+}
+
+export function getPluginSharedDependenciesVersionRange(): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(getPluginSharedDependencies()).map(([name, config]) => [
+      name,
+      getMajorMinorVersion(config.version),
+    ]),
+  );
+}
+
+export function getMajorMinorVersion(version: string): string {
+  const clean = version.replace(/^[\^~>=<]+/, "");
+  const match = clean.match(/^(\d+)\.(\d+)/);
+  if (!match) return "^0.0.0";
+  return `^${match[1]}.${match[2]}.0`;
+}

package/src/effect.ts

@@ -0,0 +1 @@
+export * from "effect";