every-plugin 0.0.6 → 0.1.0

package/dist/runtime/index.js

@@ -1,34 +1,133 @@
 import { Effect, Layer, ManagedRuntime } from "effect";
 import { PluginLoggerTag } from "../plugin";
-import { ModuleFederationService, PluginCacheService, PluginService, SecretsService, } from "./services";
+import { PluginRuntimeError } from "./errors";
+import {
+	ModuleFederationService,
+	PluginService,
+	SecretsService,
+} from "./services";
+import { createSourceStream } from "./streaming";
+import { validate } from "./validation";
+
 // Default logger implementation
 const createDefaultLogger = () => ({
-    logInfo: (message, context) => Effect.logInfo(message).pipe(Effect.annotateLogs({ source: "plugin", context })),
-    logWarning: (message, context) => Effect.logWarning(message).pipe(Effect.annotateLogs({ source: "plugin", context })),
-    logError: (message, error, context) => Effect.logError(message, error).pipe(Effect.annotateLogs({ source: "plugin", error, context })),
-    logDebug: (message, context) => Effect.logDebug(message).pipe(Effect.annotateLogs({ source: "plugin", context })),
+	logInfo: (message, context) =>
+		Effect.logInfo(message).pipe(
+			Effect.annotateLogs({ source: "plugin", context }),
+		),
+	logWarning: (message, context) =>
+		Effect.logWarning(message).pipe(
+			Effect.annotateLogs({ source: "plugin", context }),
+		),
+	logError: (message, error, context) =>
+		Effect.logError(message, error).pipe(
+			Effect.annotateLogs({ source: "plugin", error, context }),
+		),
+	logDebug: (message, context) =>
+		Effect.logDebug(message).pipe(
+			Effect.annotateLogs({ source: "plugin", context }),
+		),
 });
 export class PluginRuntime extends Effect.Tag("PluginRuntime")() {
-    static Live = (config) => {
-        const secrets = config.secrets || {};
-        const logger = config.logger || createDefaultLogger();
-        return Layer.effect(PluginRuntime, Effect.gen(function* () {
-            const pluginService = yield* PluginService;
-            return {
-                loadPlugin: pluginService.loadPlugin,
-                instantiatePlugin: pluginService.instantiatePlugin,
-                initializePlugin: pluginService.initializePlugin,
-                executePlugin: pluginService.executePlugin,
-                createPlugin: (pluginId, config) => Effect.gen(function* () {
-                    const ctor = yield* pluginService.loadPlugin(pluginId);
-                    const instance = yield* pluginService.instantiatePlugin(ctor);
-                    return yield* pluginService.initializePlugin(instance, config);
-                }),
-                shutdown: () => Effect.sync(() => {
-                    // Cleanup handled by Layer disposal
-                }),
-            };
-        })).pipe(Layer.provide(PluginService.Live(config.registry, secrets).pipe(Layer.provide(Layer.mergeAll(ModuleFederationService.Live, PluginCacheService.Live.pipe(Layer.provide(ModuleFederationService.Live)), SecretsService.Live(secrets), Layer.succeed(PluginLoggerTag, logger))))));
-    };
+	static Live = (config) => {
+		const secrets = config.secrets || {};
+		const logger = config.logger || createDefaultLogger();
+		return Layer.effect(
+			PluginRuntime,
+			Effect.gen(function* () {
+				const pluginService = yield* PluginService;
+				return {
+					loadPlugin: pluginService.loadPlugin,
+					instantiatePlugin: pluginService.instantiatePlugin,
+					initializePlugin: pluginService.initializePlugin,
+					executePlugin: pluginService.executePlugin,
+					usePlugin: (pluginId, config) =>
+						pluginService.usePlugin(pluginId, config),
+					streamPlugin: (pluginId, config, input, options) =>
+						Effect.gen(function* () {
+							// Get initialized plugin (benefits from caching)
+							const initializedPlugin = yield* pluginService.usePlugin(
+								pluginId,
+								config,
+							);
+							// Validate plugin type
+							if (initializedPlugin.plugin.type !== "source") {
+								return yield* Effect.fail(
+									new PluginRuntimeError({
+										pluginId,
+										operation: "stream-plugin-validate",
+										cause: new Error(
+											`Plugin ${pluginId} is not a source plugin (type: ${initializedPlugin.plugin.type})`,
+										),
+										retryable: false,
+									}),
+								);
+							}
+							// Check if procedure is streamable and validate state
+							const procedureName = input.procedure;
+							const isStreamable =
+								initializedPlugin.plugin.isStreamable(procedureName);
+							if (isStreamable) {
+								// Check stateSchema exists
+								if (
+									!("stateSchema" in initializedPlugin.plugin) ||
+									!initializedPlugin.plugin.stateSchema
+								) {
+									return yield* Effect.fail(
+										new PluginRuntimeError({
+											pluginId: initializedPlugin.plugin.id,
+											operation: "validate-state",
+											cause: new Error(
+												`Streamable plugin ${initializedPlugin.plugin.id} must have a stateSchema`,
+											),
+											retryable: false,
+										}),
+									);
+								}
+								// Validate initial state
+								yield* validate(
+									initializedPlugin.plugin.stateSchema,
+									input.state,
+									initializedPlugin.plugin.id,
+									"state",
+								).pipe(
+									Effect.mapError(
+										(validationError) =>
+											new PluginRuntimeError({
+												pluginId: initializedPlugin.plugin.id,
+												operation: "validate-state",
+												cause: validationError.zodError,
+												retryable: false,
+											}),
+									),
+								);
+							}
+							// Create and return the stream
+							return createSourceStream(
+								initializedPlugin,
+								pluginService.executePlugin,
+								input,
+								options,
+								isStreamable,
+							);
+						}),
+					shutdown: () => pluginService.cleanup(),
+				};
+			}),
+		).pipe(
+			Layer.provide(
+				PluginService.Live(config.registry, secrets).pipe(
+					Layer.provide(
+						Layer.mergeAll(
+							ModuleFederationService.Live,
+							SecretsService.Live(secrets),
+							Layer.succeed(PluginLoggerTag, logger),
+						),
+					),
+				),
+			),
+		);
+	};
 }
-export const createPluginRuntime = (config) => ManagedRuntime.make(PluginRuntime.Live(config));
+export const createPluginRuntime = (config) =>
+	ManagedRuntime.make(PluginRuntime.Live(config));

package/dist/runtime/mf.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mf.test.d.ts.map

package/dist/runtime/mf.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mf.test.d.ts","sourceRoot":"","sources":["../../src/runtime/mf.test.ts"],"names":[],"mappings":""}

package/dist/runtime/mf.test.js

@@ -0,0 +1,135 @@
+import { Effect, Layer } from "effect";
+import { describe, expect, it } from "vitest";
+import { PluginLoggerTag } from "../plugin";
+import { ModuleFederationService } from "./services/module-federation.service";
+import { createTestLogger } from "./test-utils";
+
+// Test registry for diagnostics
+const TEST_PLUGIN_ID = "test-plugin";
+const TEST_REMOTE_URL = "http://localhost:3000/remoteEntry.js";
+const testLayer = Layer.succeed(PluginLoggerTag, createTestLogger());
+describe("Module Federation Diagnostics", () => {
+	it("should verify remote URL is accessible (sanity check)", async () => {
+		console.log("=== Testing Remote URL Accessibility ===");
+		try {
+			const response = await fetch(TEST_REMOTE_URL, { method: "HEAD" });
+			console.log(`Remote URL status: ${response.status}`);
+			console.log(
+				`Remote URL headers:`,
+				Object.fromEntries(response.headers.entries()),
+			);
+			expect(response.ok).toBe(true);
+		} catch (error) {
+			console.error("Failed to access remote URL:", error);
+			throw error;
+		}
+	});
+	it("should test name transformation logic", async () => {
+		console.log("=== Testing Name Transformation ===");
+		// Test the same logic used in module-federation.service.ts
+		const remoteName = TEST_PLUGIN_ID.toLowerCase()
+			.replace("@", "")
+			.replace("/", "_");
+		const modulePath = `${remoteName}/plugin`;
+		console.log(`Original plugin ID: ${TEST_PLUGIN_ID}`);
+		console.log(`Transformed remote name: ${remoteName}`);
+		console.log(`Module path: ${modulePath}`);
+		expect(remoteName).toBe("test-plugin");
+		expect(modulePath).toBe("test-plugin/plugin");
+	});
+	it("should register remote successfully", async () => {
+		console.log("=== Testing Remote Registration ===");
+		const result = await Effect.runPromise(
+			Effect.gen(function* () {
+				const mfService = yield* ModuleFederationService;
+				console.log("Attempting to register remote...");
+				yield* mfService.registerRemote(TEST_PLUGIN_ID, TEST_REMOTE_URL);
+				console.log("Remote registration completed successfully");
+				return "success";
+			}).pipe(
+				Effect.provide(ModuleFederationService.Live),
+				Effect.provide(testLayer),
+				Effect.catchAll((error) => {
+					console.error("Remote registration failed:", error);
+					return Effect.succeed(`failed: ${error}`);
+				}),
+			),
+		);
+		console.log(`Registration result: ${result}`);
+		expect(result).toBe("success");
+	});
+	it.skip("should inspect module federation instance", async () => {
+		console.log("=== Inspecting Module Federation Instance ===");
+		const result = await Effect.runPromise(
+			Effect.gen(function* () {
+				const mfService = yield* ModuleFederationService;
+				// First register the remote
+				yield* mfService.registerRemote(TEST_PLUGIN_ID, TEST_REMOTE_URL);
+				// Access the internal MF instance to inspect it
+				// Note: This is a bit hacky but needed for diagnostics
+				const mfInstance = mfService.mf || globalThis.__FEDERATION__;
+				console.log("Module Federation instance:", typeof mfInstance);
+				console.log(
+					"Available methods:",
+					Object.getOwnPropertyNames(mfInstance || {}),
+				);
+				if (mfInstance && mfInstance.options) {
+					console.log("MF options:", mfInstance.options);
+				}
+				return "inspected";
+			}).pipe(
+				Effect.provide(ModuleFederationService.Live),
+				Effect.provide(testLayer),
+				Effect.catchAll((error) => {
+					console.error("MF instance inspection failed:", error);
+					return Effect.succeed(`failed: ${error}`);
+				}),
+			),
+		);
+		expect(result).toBe("inspected");
+	});
+	it.skip("should attempt to load remote container with detailed logging", async () => {
+		console.log("=== Testing Remote Container Loading ===");
+		const result = await Effect.runPromise(
+			Effect.gen(function* () {
+				const mfService = yield* ModuleFederationService;
+				// Register remote first
+				console.log("Step 1: Registering remote...");
+				yield* mfService.registerRemote(TEST_PLUGIN_ID, TEST_REMOTE_URL);
+				console.log("Step 1: ✓ Remote registered");
+				// Now try to load the constructor
+				console.log("Step 2: Loading remote constructor...");
+				const ctor = yield* mfService.loadRemoteConstructor(
+					TEST_PLUGIN_ID,
+					TEST_REMOTE_URL,
+				);
+				console.log("Step 2: ✓ Constructor loaded:", typeof ctor);
+				// Try to instantiate it
+				console.log("Step 3: Attempting to instantiate constructor...");
+				const instance = new ctor();
+				console.log("Step 3: ✓ Instance created:", typeof instance);
+				console.log(
+					"Instance properties:",
+					Object.getOwnPropertyNames(instance),
+				);
+				console.log("Instance id:", instance.id);
+				return "success";
+			}).pipe(
+				Effect.provide(ModuleFederationService.Live),
+				Effect.provide(testLayer),
+				Effect.catchAll((error) => {
+					console.error("Container loading failed at some step:", error);
+					console.error("Error details:", {
+						message: error.message,
+						cause: error.cause,
+						stack: error.stack,
+					});
+					return Effect.succeed(`failed: ${error.message}`);
+				}),
+			),
+		);
+		console.log(`Final result: ${result}`);
+		// Don't fail the test - we want to see what happens
+		expect(typeof result).toBe("string");
+	});
+});

package/dist/runtime/runtime.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=runtime.test.d.ts.map
+//# sourceMappingURL=runtime.test.d.ts.map