every-plugin 0.9.0 → 2.2.2

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";

package/src/errors.ts

@@ -0,0 +1,140 @@
+import { z } from "./zod";
+
+/**
+ * Error pattern constants for categorizing infrastructure errors
+ */
+export const ERROR_PATTERNS = {
+  CONNECTION_REFUSED: ["ECONNREFUSED"],
+  HOST_NOT_FOUND: ["ENOTFOUND", "EHOSTUNREACH"],
+  TIMEOUT: ["ETIMEDOUT", "ESOCKETTIMEDOUT", "timeout"],
+  CONNECTION_RESET: ["ECONNRESET", "EPIPE"],
+  PERMISSION: ["EACCES", "EPERM", "permission denied"],
+  AUTH: ["401", "unauthorized", "authentication failed"],
+  RATE_LIMITED: ["429", "too many requests", "rate limit"],
+  SERVICE_UNAVAILABLE: ["503", "service unavailable"],
+} as const;
+
+/**
+ * Common error schemas for plugin contracts.
+ * Import individually or use the grouped PluginErrors export.
+ *
+ * @example
+ * ```typescript
+ * import { NOT_FOUND, FORBIDDEN, UNAUTHORIZED } from "every-plugin/errors";
+ *
+ * export const contract = oc.router({
+ *   getData: oc.route(...)
+ *     .errors({ NOT_FOUND, FORBIDDEN, UNAUTHORIZED })
+ * });
+ * ```
+ */
+
+export const UNAUTHORIZED = {
+  status: 401,
+  data: z.object({
+    apiKeyProvided: z.boolean(),
+    provider: z.string().optional(),
+    authType: z.enum(["apiKey", "oauth", "token"]).optional(),
+  }),
+} as const;
+
+export const RATE_LIMITED = {
+  status: 429,
+  data: z.object({
+    retryAfter: z.number().int().min(1),
+    remainingRequests: z.number().int().min(0).optional(),
+    resetTime: z.string().datetime().optional(),
+    limitType: z.enum(["requests", "tokens", "bandwidth"]).optional(),
+  }),
+} as const;
+
+export const SERVICE_UNAVAILABLE = {
+  status: 503,
+  data: z.object({
+    retryAfter: z.number().int().optional(),
+    maintenanceWindow: z.boolean().default(false),
+    estimatedUptime: z.string().datetime().optional(),
+  }),
+} as const;
+
+export const BAD_REQUEST = {
+  status: 400,
+  data: z.object({
+    invalidFields: z.array(z.string()).optional(),
+    validationErrors: z
+      .array(
+        z.object({
+          field: z.string(),
+          message: z.string(),
+          code: z.string().optional(),
+        }),
+      )
+      .optional(),
+  }),
+} as const;
+
+export const NOT_FOUND = {
+  status: 404,
+  data: z.object({
+    resource: z.string().optional(),
+    resourceId: z.string().optional(),
+  }),
+} as const;
+
+export const FORBIDDEN = {
+  status: 403,
+  data: z.object({
+    requiredPermissions: z.array(z.string()).optional(),
+    action: z.string().optional(),
+  }),
+} as const;
+
+export const TIMEOUT = {
+  status: 504,
+  data: z.object({
+    timeoutMs: z.number().int().min(0).optional(),
+    operation: z.string().optional(),
+    retryable: z.boolean().default(true),
+  }),
+} as const;
+
+export const CONNECTION_ERROR = {
+  status: 502,
+  data: z.object({
+    errorCode: z.string().optional(),
+    host: z.string().optional(),
+    port: z.number().int().optional(),
+    suggestion: z.string().optional(),
+  }),
+} as const;
+
+/**
+ * Grouped export for all plugin errors.
+ * Use individual imports for cleaner code.
+ */
+export const PluginErrors = {
+  UNAUTHORIZED,
+  RATE_LIMITED,
+  SERVICE_UNAVAILABLE,
+  BAD_REQUEST,
+  NOT_FOUND,
+  FORBIDDEN,
+  TIMEOUT,
+  CONNECTION_ERROR,
+} as const;
+
+/**
+ * @deprecated Use individual imports or PluginErrors instead
+ */
+export const CommonPluginErrors = PluginErrors;
+
+export {
+  extractFromFiberFailure,
+  formatORPCError,
+  isRetryableORPCCode,
+  ModuleFederationError,
+  PluginRuntimeError,
+  toPluginRuntimeError,
+  ValidationError,
+  wrapORPCError,
+} from "./runtime/errors";

package/src/index.ts

@@ -0,0 +1,26 @@
+export * from "./errors";
+export * from "./plugin";
+export * from "./runtime";
+
+// Re-export the normalize helper for build configs
+export { getNormalizedRemoteName } from "./runtime/services/normalize";
+
+export type {
+  AnyPlugin,
+  EveryPlugin,
+  InitializedPlugin,
+  LoadedPlugin,
+  PluginClientType,
+  PluginConfigInput,
+  PluginContext,
+  PluginContract,
+  PluginInstance,
+  PluginMetadata,
+  PluginRegistry,
+  PluginRouterType,
+  PluginRuntimeConfig,
+  PluginSecrets,
+  PluginVariables,
+  RegisteredPlugins,
+  SecretsConfig,
+} from "./types";

package/src/orpc-client.ts

@@ -0,0 +1,2 @@
+export * from "@orpc/client";
+export * from "@orpc/react-query";

package/src/orpc-openapi.ts

@@ -0,0 +1,2 @@
+export * from "@orpc/openapi";
+export * from "@orpc/zod";

package/src/orpc.ts

@@ -0,0 +1,9 @@
+export * from "@orpc/contract";
+export * from "@orpc/experimental-publisher";
+export type { IORedisPublisherOptions } from "@orpc/experimental-publisher/ioredis";
+export { IORedisPublisher } from "@orpc/experimental-publisher/ioredis";
+export type { MemoryPublisherOptions } from "@orpc/experimental-publisher/memory";
+export { MemoryPublisher } from "@orpc/experimental-publisher/memory";
+export type { UpstashRedisPublisherOptions } from "@orpc/experimental-publisher/upstash-redis";
+export { UpstashRedisPublisher } from "@orpc/experimental-publisher/upstash-redis";
+export * from "@orpc/server";