every-plugin 0.9.0 → 2.2.3

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,45 +0,0 @@
-
-//#region package.json
-var version = "0.9.0";
-var peerDependencies = {
-	"@rspack/core": "1.7.4",
-	"typescript": "^5.9.3",
-	"effect": "^3.19.15",
-	"zod": "^4.3.6",
-	"@orpc/contract": "^1.13.4",
-	"@orpc/server": "^1.13.4"
-};
-var dependencies = {
-	"@module-federation/enhanced": "^0.23.0",
-	"@module-federation/node": "^2.7.28",
-	"@module-federation/runtime-core": "^0.23.0",
-	"@orpc/client": "^1.13.4",
-	"@orpc/contract": "^1.13.4",
-	"@orpc/experimental-publisher": "^1.13.4",
-	"@orpc/openapi": "^1.13.4",
-	"@orpc/react-query": "^1.13.4",
-	"@orpc/server": "^1.13.4",
-	"@orpc/tanstack-query": "^1.13.4",
-	"@orpc/zod": "^1.13.4"
-};
-
-//#endregion
-Object.defineProperty(exports, 'dependencies', {
-  enumerable: true,
-  get: function () {
-    return dependencies;
-  }
-});
-Object.defineProperty(exports, 'peerDependencies', {
-  enumerable: true,
-  get: function () {
-    return peerDependencies;
-  }
-});
-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,27 +0,0 @@
-//#region package.json
-var version = "0.9.0";
-var peerDependencies = {
-	"@rspack/core": "1.7.4",
-	"typescript": "^5.9.3",
-	"effect": "^3.19.15",
-	"zod": "^4.3.6",
-	"@orpc/contract": "^1.13.4",
-	"@orpc/server": "^1.13.4"
-};
-var dependencies = {
-	"@module-federation/enhanced": "^0.23.0",
-	"@module-federation/node": "^2.7.28",
-	"@module-federation/runtime-core": "^0.23.0",
-	"@orpc/client": "^1.13.4",
-	"@orpc/contract": "^1.13.4",
-	"@orpc/experimental-publisher": "^1.13.4",
-	"@orpc/openapi": "^1.13.4",
-	"@orpc/react-query": "^1.13.4",
-	"@orpc/server": "^1.13.4",
-	"@orpc/tanstack-query": "^1.13.4",
-	"@orpc/zod": "^1.13.4"
-};
-
-//#endregion
-export { dependencies, peerDependencies, version };
-//# sourceMappingURL=package.mjs.map

package/dist/package.mjs.map

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