every-plugin 0.8.9 → 2.2.2

package/src/runtime/validation.ts

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+import type { z } from "zod";
+import { ValidationError } from "./errors";
+
+export const validate = <T>(
+  schema: z.ZodSchema<T>,
+  data: unknown,
+  pluginId: string,
+  stage: "config" | "input" | "output" | "state",
+): Effect.Effect<T, ValidationError> =>
+  Effect.gen(function* () {
+    const result = schema.safeParse(data);
+    if (result.success) {
+      return result.data;
+    }
+    return yield* Effect.fail(
+      new ValidationError({
+        pluginId,
+        stage,
+        zodError: result.error,
+      }),
+    );
+  });

package/src/testing/index.ts

@@ -0,0 +1,87 @@
+import type { LoadedPluginWithBinding } from "../plugin";
+import { createPluginRuntime } from "../runtime";
+import type { AnyPluginConstructor, PluginRegistryEntry, PluginRuntimeConfig } from "../types";
+
+export type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;
+
+/**
+ * Simplified type inference for local plugin maps.
+ * Just use the constructor types directly.
+ *
+ * @example
+ * ```ts
+ * const pluginMap = { "my-plugin": MyPlugin } as const;
+ * type MyBindings = InferBindingsFromMap<typeof pluginMap>;
+ * ```
+ */
+export type InferBindingsFromMap<T extends PluginMap> = {
+  [K in keyof T]: T[K];
+};
+
+/**
+ * Converts old pluginMap format to new registry format
+ */
+function convertPluginMapToRegistry<T extends PluginMap>(
+  oldRegistry: Record<string, { remoteUrl: string; version?: string; description?: string }>,
+  pluginMap: T,
+): Record<keyof T, PluginRegistryEntry> {
+  const registry: Record<string, PluginRegistryEntry> = {};
+
+  for (const [pluginId, ctor] of Object.entries(pluginMap)) {
+    const oldEntry = oldRegistry[pluginId];
+    registry[pluginId] = {
+      module: ctor as AnyPluginConstructor,
+      remote: oldEntry?.remoteUrl,
+      version: oldEntry?.version,
+      description: oldEntry?.description,
+    };
+  }
+
+  return registry as Record<keyof T, PluginRegistryEntry>;
+}
+
+/**
+ * Creates a plugin runtime for locally available plugins (non-remote).
+ * Automatically infers type bindings from the plugin map, eliminating
+ * the need for manual RegistryBindings definitions.
+ *
+ * @deprecated Use `createPluginRuntime` with module entries directly instead.
+ * @example
+ * ```ts
+ * // Old API (deprecated)
+ * const runtime = createLocalPluginRuntime(
+ *   { registry: { "my-plugin": { remoteUrl: "..." } }, secrets },
+ *   { "my-plugin": MyPlugin }
+ * );
+ *
+ * // New API (recommended)
+ * const runtime = createPluginRuntime({
+ *   registry: { "my-plugin": { module: MyPlugin } },
+ *   secrets
+ * });
+ * ```
+ */
+export function createLocalPluginRuntime<TMap extends PluginMap>(
+  config: {
+    registry: Record<string, { remoteUrl: string; version?: string; description?: string }>;
+    secrets?: Record<string, string>;
+    options?: any;
+  },
+  pluginMap: TMap,
+) {
+  const newRegistry = convertPluginMapToRegistry(config.registry, pluginMap);
+
+  return createPluginRuntime({
+    registry: newRegistry,
+    secrets: config.secrets,
+    options: config.options,
+  });
+}
+
+/**
+ * @deprecated Use `createLocalPluginRuntime` or `createPluginRuntime` instead.
+ */
+export const createTestPluginRuntime = createLocalPluginRuntime;
+
+export type { EveryPlugin, PluginRegistry, RegisteredPlugins } from "../types";
+export type { PluginRuntimeConfig };

package/src/testing/mocks/module-federation.service.ts

@@ -0,0 +1,41 @@
+import { Effect, Layer } from "effect";
+import type { LoadedPluginWithBinding } from "../../plugin";
+import { ModuleFederationError } from "../../runtime/errors";
+import { ModuleFederationService } from "../../runtime/services/module-federation.service";
+
+export type PluginMap = Record<string, LoadedPluginWithBinding<any, any, any, any>>;
+
+export const createMockModuleFederationServiceLayer = (pluginMap: PluginMap) =>
+  Layer.succeed(ModuleFederationService, {
+    registerRemote: (pluginId: string, url: string) =>
+      Effect.gen(function* () {
+        console.log(`[MOCK] registerRemote called for ${pluginId}`);
+        if (!(pluginId in pluginMap)) {
+          return yield* Effect.fail(
+            new ModuleFederationError({
+              pluginId,
+              remoteUrl: url,
+              cause: new Error(`Mock: Plugin ${pluginId} not available in test plugin map`),
+            }),
+          );
+        }
+        console.log(`[MOCK] registerRemote succeeded for ${pluginId}`);
+      }),
+
+    loadRemoteConstructor: (pluginId: string, url: string) =>
+      Effect.gen(function* () {
+        console.log(`[MOCK] loadRemoteConstructor called for ${pluginId}`);
+        const PluginConstructor = pluginMap[pluginId];
+        if (!PluginConstructor) {
+          return yield* Effect.fail(
+            new ModuleFederationError({
+              pluginId,
+              remoteUrl: url,
+              cause: new Error(`Mock: Constructor for ${pluginId} not found in test plugin map`),
+            }),
+          );
+        }
+        console.log(`[MOCK] loadRemoteConstructor succeeded for ${pluginId}`);
+        return PluginConstructor;
+      }),
+  } as any);

package/src/types.ts

@@ -0,0 +1,309 @@
+import type {
+  AnyContractRouter,
+  AnySchema,
+  InferSchemaInput,
+  InferSchemaOutput,
+} from "@orpc/contract";
+import type { Router, RouterClient } from "@orpc/server";
+import type { Scope } from "effect";
+import type { Plugin } from "./plugin";
+
+/**
+ * Registry bindings interface - populated via module augmentation
+ * Only needed for remote-only plugin entries.
+ * @example
+ * ```typescript
+ * declare module "every-plugin" {
+ *   interface RegisteredPlugins {
+ *     "my-plugin": typeof MyPlugin;
+ *   }
+ * }
+ * ```
+ */
+// biome-ignore lint/suspicious/noEmptyInterface: required for module augmentation pattern
+export interface RegisteredPlugins {}
+
+/**
+ * Base type for any plugin instance.
+ */
+export type AnyPlugin = Plugin<AnyContractRouter, AnySchema, AnySchema, AnySchema | undefined, any>;
+
+/**
+ * Loaded plugin constructor with binding information
+ */
+export type AnyPluginConstructor = {
+  new (): AnyPlugin;
+  binding: {
+    contract: AnyContractRouter;
+    variables: AnySchema;
+    secrets: AnySchema;
+    context: AnySchema | undefined;
+  };
+};
+
+/**
+ * Registry entry that supports both direct module imports and remote URLs
+ */
+export type PluginRegistryEntry =
+  | { module: AnyPluginConstructor; remote?: string; version?: string; description?: string }
+  | { remote: string; version?: string; description?: string };
+
+/**
+ * Extract plugin constructor type from registry entry
+ */
+export type ExtractPluginType<E> = E extends { module: infer M } ? M : never;
+
+/**
+ * Infer registry types from plugin entries with module constructors
+ */
+export type InferRegistryFromEntries<R extends Record<string, PluginRegistryEntry>> = {
+  [K in keyof R]: R[K] extends { module: infer M }
+    ? M
+    : K extends keyof RegisteredPlugins
+      ? RegisteredPlugins[K]
+      : never;
+};
+
+/**
+ * Extract contract type from plugin binding
+ */
+export type PluginContract<T> = T extends {
+  binding: { contract: infer C extends AnyContractRouter };
+}
+  ? C
+  : never;
+
+/**
+ * Extract variables type from plugin binding
+ */
+export type PluginVariables<T> = T extends { binding: { variables: infer V extends AnySchema } }
+  ? V
+  : never;
+
+/**
+ * Extract secrets type from plugin binding
+ */
+export type PluginSecrets<T> = T extends { binding: { secrets: infer S extends AnySchema } }
+  ? S
+  : never;
+
+/**
+ * Extract context schema type from plugin binding
+ */
+export type PluginContext<T> = T extends {
+  binding: { context: infer C extends AnySchema | undefined };
+}
+  ? C
+  : never;
+
+/**
+ * Extract router type from plugin binding
+ * Uses 'any' for context to support nested router compositions
+ */
+export type PluginRouterType<T> = Router<PluginContract<T>, any>;
+
+/**
+ * Extract client type from plugin binding
+ */
+export type PluginClientType<T> = RouterClient<PluginRouterType<T>>;
+
+/**
+ * Extract plugin type from registered plugins by key
+ * @param K - The plugin key
+ * @param R - The registry type (defaults to RegisteredPlugins for module augmentation pattern)
+ */
+export type RegisteredPlugin<K extends keyof R, R = RegisteredPlugins> = R[K] extends {
+  binding: infer B;
+}
+  ? B extends {
+      contract: infer C extends AnyContractRouter;
+      variables: infer V extends AnySchema;
+      secrets: infer S extends AnySchema;
+      context: infer TRequestContext extends AnySchema | undefined;
+    }
+    ? Plugin<C, V, S, TRequestContext, any>
+    : never
+  : never;
+
+/**
+ * Extract plugin constructor type from registry entry
+ */
+export type PluginConstructor<K extends keyof R, R = RegisteredPlugins> = RegisteredPlugin<K, R>;
+
+/**
+ * Extract context input type from plugin binding (for client creation)
+ */
+export type PluginContextInput<T> =
+  PluginContext<T> extends AnySchema ? InferSchemaInput<PluginContext<T>> : never;
+
+/**
+ * Extract config input type from plugin binding
+ */
+export type PluginConfigInput<T> = {
+  variables: InferSchemaInput<PluginVariables<T>>;
+  secrets: InferSchemaInput<PluginSecrets<T>>;
+};
+
+/**
+ * Extract deps context type from plugin instance (used for initialization)
+ */
+export type ContextOf<T extends AnyPlugin> =
+  T extends Plugin<AnyContractRouter, AnySchema, AnySchema, AnySchema | undefined, infer TDeps>
+    ? TDeps
+    : never;
+
+/**
+ * Plugin metadata for remote loading
+ */
+export type PluginMetadata = {
+  readonly remoteUrl: string;
+  readonly version?: string;
+  readonly description?: string;
+};
+
+/**
+ * Runtime registry configuration supporting both module and remote entries
+ */
+export type PluginRegistry = Record<string, PluginRegistryEntry>;
+
+/**
+ * Legacy metadata-only registry (for backwards compatibility)
+ */
+export type PluginMetadataRegistry = Record<string, PluginMetadata>;
+
+/**
+ * Configuration for secrets injection.
+ * Secrets are hydrated into plugin configs using template replacement.
+ */
+export interface SecretsConfig {
+  [key: string]: string;
+}
+
+/**
+ * Loaded plugin
+ */
+export interface LoadedPlugin<T extends AnyPlugin = AnyPlugin> {
+  readonly ctor: new () => T;
+  readonly metadata: PluginMetadata;
+}
+
+/**
+ * Instantiated plugin
+ */
+export interface PluginInstance<T extends AnyPlugin = AnyPlugin> {
+  readonly plugin: T;
+  readonly metadata: PluginMetadata;
+}
+
+/**
+ * Fully initialized plugin ready for use
+ */
+export interface InitializedPlugin<T extends AnyPlugin = AnyPlugin> {
+  readonly plugin: T;
+  readonly metadata: PluginMetadata;
+  readonly config: {
+    variables: InferSchemaOutput<T["configSchema"]["variables"]>;
+    secrets: InferSchemaOutput<T["configSchema"]["secrets"]>;
+  };
+  readonly context: ContextOf<T>;
+  readonly scope: Scope.CloseableScope;
+}
+
+/**
+ * Helper type to detect type errors when looking up RegisteredPlugins
+ */
+type VerifyPluginBinding<K extends keyof R, R = RegisteredPlugins> = R[K] extends {
+  binding: infer B;
+}
+  ? B extends {
+      contract: AnyContractRouter;
+      variables: AnySchema;
+      secrets: AnySchema;
+      context: AnySchema | undefined;
+    }
+    ? true
+    : `❌ Plugin "${K & string}" is not properly registered. Ensure it extends plugin binding layout { contract, variables, secrets, context }.`
+  : `❌ Plugin "${K & string}" is not properly registered. Missing binding property.`;
+
+/**
+ * Result of runtime.usePlugin() call
+ * @param K - The plugin key
+ * @param R - The registry type (defaults to RegisteredPlugins for module augmentation pattern)
+ */
+export type UsePluginResult<K extends keyof R, R = RegisteredPlugins> =
+  VerifyPluginBinding<K, R> extends true
+    ? {
+        readonly createClient: (context?: PluginContextInput<R[K]>) => PluginClientType<R[K]>;
+        readonly router: PluginRouterType<R[K]>;
+        readonly metadata: PluginMetadata;
+        readonly initialized: InitializedPlugin<RegisteredPlugin<K, R>>;
+      }
+    : VerifyPluginBinding<K, R>;
+
+/**
+ * Runtime options
+ */
+export interface RuntimeOptions {
+  isolation?: "strict" | "shared" | "none";
+  memoryLimit?: string;
+  concurrency?: number;
+  resourceTimeout?: string;
+  debug?: boolean;
+  metrics?: boolean;
+}
+
+/**
+ * Extract registry type from runtime instance or use type directly
+ * This allows EveryPlugin.Infer to work with both:
+ * - typeof runtime (extracts registry from PluginRuntime<R> via __registryType)
+ * - Registry types directly
+ */
+type RegistryOf<T> = T extends { __registryType?: infer R } ? R : T;
+
+/**
+ * Namespace containing type utilities for working with plugin results.
+ */
+export namespace EveryPlugin {
+  /**
+   * Extract plugin runtime instance type from registered plugins or runtime.
+   * Provides full type safety for plugin clients, routers, and metadata.
+   *
+   * @example
+   * ```ts
+   * // From RegisteredPlugins (module augmentation)
+   * type Plugin = EveryPlugin.Infer<"my-plugin">;
+   *
+   * // From runtime instance (when using module entries)
+   * const runtime = createPluginRuntime({ registry: { "my-plugin": { module: MyPlugin } } });
+   * type Plugin = EveryPlugin.Infer<"my-plugin", typeof runtime>;
+   *
+   * // From explicit registry type
+   * type Plugin = EveryPlugin.Infer<"my-plugin", MyRegistryType>;
+   * ```
+   */
+  export type Infer<
+    K extends string,
+    Source = RegisteredPlugins,
+  > = K extends keyof RegistryOf<Source> ? UsePluginResult<K, RegistryOf<Source>> : never;
+}
+
+/**
+ * Plugin runtime configuration with support for both module and remote entries
+ */
+export interface PluginRuntimeConfig<
+  R extends Record<string, PluginRegistryEntry> = Record<string, PluginRegistryEntry>,
+> {
+  registry: R;
+  secrets?: SecretsConfig;
+  options?: RuntimeOptions;
+}
+
+/**
+ * Legacy plugin runtime configuration (metadata-only registry)
+ * @deprecated Use PluginRuntimeConfig with module/remote entries instead
+ */
+export interface LegacyPluginRuntimeConfig {
+  registry: PluginMetadataRegistry;
+  secrets?: SecretsConfig;
+  options?: RuntimeOptions;
+}

package/src/zod-core.ts

@@ -0,0 +1,4 @@
+/**
+ * necessary for portable type annotations
+ */
+export * from "zod/v4/core";

package/src/zod.ts

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

package/dist/package.cjs

@@ -1,47 +0,0 @@
-
-//#region package.json
-var version = "0.8.8";
-var dependencies = {
-	"@module-federation/enhanced": "^0.22.1",
-	"@module-federation/node": "^2.7.27",
-	"@module-federation/runtime-core": "^0.22.1",
-	"@orpc/client": "^1.12.3",
-	"@orpc/contract": "^1.13.4",
-	"@orpc/experimental-publisher": "^1.13.4",
-	"@orpc/openapi": "^1.12.3",
-	"@orpc/react-query": "^1.13.4",
-	"@orpc/server": "^1.13.4",
-	"@orpc/tanstack-query": "^1.13.4",
-	"@orpc/zod": "^1.13.4",
-	"effect": "3.19.14",
-	"zod": "4.3.5"
-};
-var sharedDependencies = { "ui": {
-	"react": "^19.2.3",
-	"react-dom": "^19.2.3",
-	"@tanstack/react-query": "^5.90.11",
-	"@tanstack/react-router": "^1.153.2",
-	"@hot-labs/near-connect": "^0.8.2",
-	"near-kit": "^0.7.0"
-} };
-
-//#endregion
-Object.defineProperty(exports, 'dependencies', {
-  enumerable: true,
-  get: function () {
-    return dependencies;
-  }
-});
-Object.defineProperty(exports, 'sharedDependencies', {
-  enumerable: true,
-  get: function () {
-    return sharedDependencies;
-  }
-});
-Object.defineProperty(exports, 'version', {
-  enumerable: true,
-  get: function () {
-    return version;
-  }
-});
-//# sourceMappingURL=package.cjs.map

package/dist/package.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"package.cjs","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}

package/dist/package.mjs

@@ -1,29 +0,0 @@
-//#region package.json
-var version = "0.8.9";
-var dependencies = {
-	"@module-federation/enhanced": "^0.22.1",
-	"@module-federation/node": "^2.7.27",
-	"@module-federation/runtime-core": "^0.22.1",
-	"@orpc/client": "^1.12.3",
-	"@orpc/contract": "^1.13.4",
-	"@orpc/experimental-publisher": "^1.13.4",
-	"@orpc/openapi": "^1.12.3",
-	"@orpc/react-query": "^1.13.4",
-	"@orpc/server": "^1.13.4",
-	"@orpc/tanstack-query": "^1.13.4",
-	"@orpc/zod": "^1.13.4",
-	"effect": "3.19.14",
-	"zod": "4.3.5"
-};
-var sharedDependencies = { "ui": {
-	"react": "^19.2.3",
-	"react-dom": "^19.2.3",
-	"@tanstack/react-query": "^5.90.11",
-	"@tanstack/react-router": "^1.153.2",
-	"@hot-labs/near-connect": "^0.8.2",
-	"near-kit": "^0.7.0"
-} };
-
-//#endregion
-export { dependencies, sharedDependencies, version };
-//# sourceMappingURL=package.mjs.map

package/dist/package.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"package.mjs","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}