every-plugin 2.3.0 → 2.4.1

package/skills/plugin-testing/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: plugin-testing
+description: Test every-plugin modules with vitest and the plugin runtime. Use when writing or modifying plugin tests under plugins/*/src/__tests__/ or plugins/*/tests/.
+metadata:
+  sources: "src/testing/index.ts,src/runtime/index.ts"
+---
+
+# every-plugin Testing
+
+## Test Structure
+
+```
+plugins/your-plugin/
+├── src/__tests__/
+│   ├── integration.test.ts   # Full plugin lifecycle via runtime
+│   └── unit.test.ts          # Service class in isolation
+└── vitest.config.ts
+```
+
+## Unit Tests (Service Only)
+
+Test the service class directly without the plugin runtime:
+
+```typescript
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import { MyService } from "../service";
+
+describe("MyService", () => {
+  const service = new MyService("https://api.example.com", "test-key");
+
+  it("ping returns ok", async () => {
+    const result = await Effect.runPromise(service.ping());
+    expect(result.status).toBe("ok");
+  });
+
+  it("getById returns item", async () => {
+    const result = await Effect.runPromise(service.getById("item-1"));
+    expect(result.item.id).toBe("item-1");
+  });
+
+  it("getById throws on missing item", async () => {
+    await expect(Effect.runPromise(service.getById("missing"))).rejects.toThrow();
+  });
+});
+```
+
+## Integration Tests (Plugin Runtime)
+
+Test the full plugin lifecycle — initialization, router execution, shutdown:
+
+```typescript
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+import { createPluginRuntime } from "every-plugin/runtime";
+import Plugin from "../index";
+
+describe("MyPlugin integration", () => {
+  let runtime: Awaited<ReturnType<typeof createPluginRuntime>>;
+  let client: any;
+
+  beforeAll(async () => {
+    runtime = createPluginRuntime();
+    const result = await runtime.usePlugin("my-plugin", {
+      variables: { baseUrl: "https://api.example.com" },
+      secrets: { apiKey: "test-key" },
+    });
+    client = result.createClient();
+  });
+
+  afterAll(async () => {
+    await runtime.dispose();
+  });
+
+  it("ping responds", async () => {
+    const result = await client.ping();
+    expect(result.status).toBe("ok");
+  });
+
+  it("getById returns item", async () => {
+    const result = await client.getById({ id: "item-1" });
+    expect(result.item.id).toBe("item-1");
+  });
+
+  it("getById without auth throws UNAUTHORIZED", async () => {
+    await expect(client.getById({ id: "item-1" })).rejects.toThrow();
+  });
+});
+```
+
+## Testing Plugin Composition
+
+When testing an API plugin that uses `withPlugins`, mock the `pluginsClient`:
+
+```typescript
+import { createPluginRuntime } from "every-plugin/runtime";
+
+const mockRegistryClient = {
+  getRegistryStatus: vi.fn().mockResolvedValue({ status: "ok" }),
+  listRegistryApps: vi.fn().mockResolvedValue({ apps: [] }),
+};
+
+describe("API with mock registry", () => {
+  it("pluginDemo returns composed data", async () => {
+    const runtime = createPluginRuntime();
+    const result = await runtime.usePlugin(
+      "api",
+      { variables: {}, secrets: {} },
+      { registry: () => mockRegistryClient },
+    );
+    const client = result.createClient();
+    const data = await client.pluginDemo();
+    expect(data.registryStatus.status).toBe("ok");
+    await runtime.dispose();
+  });
+});
+```
+
+## Testing Streaming (eventIterator)
+
+Use `for await` to collect streaming results:
+
+```typescript
+it("search streams results", async () => {
+  const chunks: any[] = [];
+  const stream = await client.search({ query: "test", limit: 5 });
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  expect(chunks.length).toBeGreaterThan(0);
+});
+```
+
+## Vitest Config
+
+```typescript
+import { defineConfig } from "vitest/config";
+import tsconfigPaths from "vite-tsconfig-paths";
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  test: {
+    include: ["src/__tests__/**/*.test.ts"],
+  },
+});
+```
+
+## Common Mistakes
+
+- Not calling `runtime.dispose()` in `afterAll` — leaves processes/resources running
+- Using `vi.fn()` without `.mockResolvedValue()` — unhandled promise rejections
+- Forgetting `vite-tsconfig-paths` plugin — path aliases like `every-plugin/orpc` won't resolve
+- Testing only happy paths — always test error channels (Effect failures, ORPCError throws)

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

@@ -63,12 +63,7 @@ export function setupPluginMiddleware(
       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();
-        }
+        if (runtime) await runtime.shutdown();
         handlers.rpc = null;
         handlers.api = null;
         if (devServer.app.locals.handlers) {

package/src/build/rspack/plugin.ts

@@ -14,9 +14,15 @@ export interface EveryPluginOptions {
   dts?: boolean;
 }
 
+export interface AdditionalExport {
+  srcPath: string;
+  exportNames: string[];
+}
+
 export interface PluginManifestEmitterOptions {
   manifestFileName?: string;
   contractFileName?: string;
+  additionalExports?: AdditionalExport[];
 }
 
 export class EmitPluginManifest implements RspackPluginInstance {
@@ -73,7 +79,7 @@ export class EmitPluginManifest implements RspackPluginInstance {
         }
 
         const contractSha256 = crypto.createHash("sha256").update(contractTypes).digest("hex");
-        const manifest = {
+        const manifest: Record<string, unknown> = {
           schemaVersion: 1,
           kind: "every-plugin/manifest",
           plugin: {
@@ -94,6 +100,37 @@ export class EmitPluginManifest implements RspackPluginInstance {
           },
         };
 
+        const additionalExportsEntries: Array<{ path: string; exports: string[]; sha256: string }> =
+          [];
+
+        if (this.options.additionalExports?.length) {
+          for (const additional of this.options.additionalExports) {
+            const sourcePath = path.join(context, "types", additional.srcPath);
+            const content = await tryReadFile(sourcePath);
+            if (!content) {
+              console.warn(
+                `[EmitPluginManifest] Additional export file not found at ${sourcePath}. Skipping.`,
+              );
+              continue;
+            }
+            const sha256 = crypto.createHash("sha256").update(content).digest("hex");
+            const distPath = `./types/${additional.srcPath}`;
+            additionalExportsEntries.push({
+              path: distPath,
+              exports: additional.exportNames,
+              sha256,
+            });
+
+            if (rawSource) {
+              compilation.emitAsset(`types/${additional.srcPath}`, new rawSource(content));
+            }
+          }
+
+          if (additionalExportsEntries.length > 0) {
+            manifest.additionalExports = additionalExportsEntries;
+          }
+        }
+
         if (rawSource) {
           compilation.emitAsset(
             manifestFileName,
@@ -168,7 +205,7 @@ export class EveryPluginDevServer implements RspackPluginInstance {
       compiler.options.mode = process.env.NODE_ENV === "development" ? "development" : "production";
     }
 
-    if (!compiler.options.devtool) {
+    if (compiler.options.devtool === undefined) {
       compiler.options.devtool = "source-map";
     }
 

package/src/build/shared-deps.ts

@@ -54,6 +54,22 @@ export const pluginSharedDependencies = {
     version: getInstalledPackageVersion("zod", pkg.peerDependencies.zod),
     ...DEFAULT_SHARE_CONFIG,
   },
+  "better-auth": {
+    version: getInstalledPackageVersion("better-auth", "^1.6.9"),
+    ...DEFAULT_SHARE_CONFIG,
+  },
+  "drizzle-orm": {
+    version: getInstalledPackageVersion("drizzle-orm", "^0.45.1"),
+    ...DEFAULT_SHARE_CONFIG,
+  },
+  "@orpc/contract": {
+    version: getInstalledPackageVersion("@orpc/contract", pkg.peerDependencies["@orpc/contract"]),
+    ...DEFAULT_SHARE_CONFIG,
+  },
+  "@orpc/server": {
+    version: getInstalledPackageVersion("@orpc/server", pkg.peerDependencies["@orpc/server"]),
+    ...DEFAULT_SHARE_CONFIG,
+  },
 } satisfies SharedDependencies;
 
 export type PluginSharedDependencyName = keyof typeof pluginSharedDependencies;

package/src/index.ts

@@ -23,4 +23,5 @@ export type {
   PluginVariables,
   RegisteredPlugins,
   SecretsConfig,
+  UsePluginResult,
 } from "./types";

package/src/plugin.ts

@@ -152,8 +152,15 @@ export const createPlugin: CreatePluginFn = function createPlugin<
       const self = this;
       return Effect.gen(function* () {
         if (config.shutdown && self._deps) {
-          yield* config.shutdown(self._deps).pipe(Effect.catchAll(() => Effect.void));
+          yield* config
+            .shutdown(self._deps)
+            .pipe(
+              Effect.catchAll((error) =>
+                Effect.logWarning(`Plugin shutdown hook failed for ${self.id}`, error),
+              ),
+            );
         }
+        self._deps = null;
       });
     }
 

package/src/runtime/index.ts

@@ -165,10 +165,18 @@ export class PluginRuntime<R = RegisteredPlugins> {
         if (pluginResult) {
           yield* pluginService
             .shutdownPlugin(pluginResult)
-            .pipe(Effect.catchAll(() => Effect.void));
+            .pipe(
+              Effect.catchAll((error) =>
+                Effect.logWarning(`Failed to shutdown evicted plugin ${pluginId}`, error),
+              ),
+            );
         }
       }
-    }).pipe(Effect.catchAll(() => Effect.void));
+    }).pipe(
+      Effect.catchAll((error) =>
+        Effect.logWarning(`Plugin eviction failed for ${pluginId}`, error),
+      ),
+    );
 
     return this.runPromise(effect);
   }

package/src/runtime/mf-config.ts

@@ -43,6 +43,22 @@ export const MF_SHARED_DEPS = {
     version: getInstalledPackageVersion("zod", "^4.3.6"),
     shareConfig: SHARE_CONFIG,
   },
+  "better-auth": {
+    version: getInstalledPackageVersion("better-auth", "^1.6.9"),
+    shareConfig: SHARE_CONFIG,
+  },
+  "drizzle-orm": {
+    version: getInstalledPackageVersion("drizzle-orm", "^0.45.1"),
+    shareConfig: SHARE_CONFIG,
+  },
+  "@orpc/contract": {
+    version: getInstalledPackageVersion("@orpc/contract", "^1.13.4"),
+    shareConfig: SHARE_CONFIG,
+  },
+  "@orpc/server": {
+    version: getInstalledPackageVersion("@orpc/server", "^1.13.4"),
+    shareConfig: SHARE_CONFIG,
+  },
 } as const;
 
 export type SharedDepName = keyof typeof MF_SHARED_DEPS;

package/src/runtime/services/module-federation.service.ts

@@ -12,38 +12,49 @@ const sharedModuleLoaders = {
   "every-plugin": () => import("every-plugin"),
   effect: () => import("effect"),
   zod: () => import("zod"),
+  "better-auth": () => import("better-auth"),
+  "drizzle-orm": () => import("drizzle-orm"),
+  "@orpc/contract": () => import("@orpc/contract"),
+  "@orpc/server": () => import("@orpc/server"),
 } satisfies Record<SharedDepName, () => Promise<unknown>>;
 
+function buildSharedConfig(): Record<
+  string,
+  {
+    version: string;
+    get: () => Promise<() => unknown>;
+    shareConfig: (typeof MF_SHARED_DEPS)[SharedDepName]["shareConfig"];
+  }
+> {
+  return Object.fromEntries(
+    (
+      Object.entries(MF_SHARED_DEPS) as [SharedDepName, (typeof MF_SHARED_DEPS)[SharedDepName]][]
+    ).map(([name, config]) => {
+      const load = sharedModuleLoaders[name];
+
+      if (!load) {
+        throw new Error(`Missing shared module loader for ${name}`);
+      }
+
+      return [
+        name,
+        {
+          version: config.version,
+          get: () => load().then((mod) => () => mod),
+          shareConfig: config.shareConfig,
+        },
+      ];
+    }),
+  );
+}
+
 const createModuleFederationInstance = Effect.cached(
   Effect.sync(() => {
     try {
+      const shared = buildSharedConfig();
       let instance = getInstance();
 
       if (!instance) {
-        const shared = Object.fromEntries(
-          (
-            Object.entries(MF_SHARED_DEPS) as [
-              SharedDepName,
-              (typeof MF_SHARED_DEPS)[SharedDepName],
-            ][]
-          ).map(([name, config]) => {
-            const load = sharedModuleLoaders[name];
-
-            if (!load) {
-              throw new Error(`Missing shared module loader for ${name}`);
-            }
-
-            return [
-              name,
-              {
-                version: config.version,
-                get: () => load().then((mod) => () => mod),
-                shareConfig: config.shareConfig,
-              },
-            ];
-          }),
-        );
-
         instance = createInstance({
           name: "host",
           remotes: [],
@@ -51,6 +62,8 @@ const createModuleFederationInstance = Effect.cached(
         });
 
         setGlobalFederationInstance(instance);
+      } else {
+        instance.registerShared(shared);
       }
 
       return instance;

package/src/runtime/services/plugin-lifecycle.service.ts

@@ -1,4 +1,4 @@
-import { Effect, Ref } from "effect";
+import { Effect, Exit, Ref, Scope } from "effect";
 import type { AnyPlugin, InitializedPlugin } from "../../types";
 import { toPluginRuntimeError } from "../errors";
 
@@ -50,36 +50,31 @@ export class PluginLifecycleService extends Effect.Service<PluginLifecycleServic
           Effect.gen(function* () {
             const plugins = yield* Ref.get(activePlugins);
 
-            // Shutdown all active plugins concurrently
             yield* Effect.forEach(
               plugins,
               (plugin) =>
-                plugin.plugin.shutdown().pipe(
-                  Effect.mapError((error) =>
-                    toPluginRuntimeError(
-                      error,
-                      plugin.plugin.id,
-                      undefined,
-                      "cleanup-shutdown",
-                      false,
+                Effect.gen(function* () {
+                  yield* plugin.plugin
+                    .shutdown()
+                    .pipe(
+                      Effect.catchAll((error) =>
+                        Effect.logWarning(`Failed to shutdown plugin ${plugin.plugin.id}`, error),
+                      ),
+                    );
+                  yield* Scope.close(plugin.scope, Exit.succeed(undefined)).pipe(
+                    Effect.catchAll((error) =>
+                      Effect.logWarning(
+                        `Failed to close scope for plugin ${plugin.plugin.id}`,
+                        error,
+                      ),
                     ),
-                  ),
-                  Effect.catchAll((error) =>
-                    Effect.logError(
-                      `Failed to shutdown plugin ${plugin.plugin.id} during cleanup`,
-                      error,
-                      { pluginId: plugin.plugin.id },
-                    ),
-                  ),
-                ),
+                  );
+                }),
               { concurrency: "unbounded" },
             );
 
-            // Clear the active plugins set
             yield* Ref.set(activePlugins, new Set());
-          }).pipe(
-            Effect.catchAll(() => Effect.void), // Convert errors to void for cleanup
-          ),
+          }).pipe(Effect.catchAll((error) => Effect.logWarning("Plugin cleanup failed", error))),
       };
     }),
   },

package/src/runtime/services/plugin.service.ts

@@ -27,13 +27,16 @@ export class PluginService extends Effect.Service<PluginService>()("PluginServic
       initializePlugin: loader.initializePlugin,
       shutdownPlugin: (plugin: InitializedPlugin<AnyPlugin>) =>
         Effect.gen(function* () {
-          // Shutdown the plugin first (graceful cleanup)
-          yield* plugin.plugin.shutdown().pipe(Effect.catchAll(() => Effect.void));
+          yield* plugin.plugin
+            .shutdown()
+            .pipe(
+              Effect.catchAll((error) =>
+                Effect.logWarning(`Failed to shutdown plugin ${plugin.plugin.id}`, error),
+              ),
+            );
 
-          // Close the plugin scope to interrupt fibers and release resources
           yield* Scope.close(plugin.scope, Exit.succeed(undefined));
 
-          // Unregister from lifecycle tracking
           yield* lifecycle.unregister(plugin);
         }),
       cleanup: lifecycle.cleanup,