every-plugin 0.0.5 → 0.1.0

package/dist/runtime/errors.d.ts

@@ -0,0 +1,62 @@
+import type { z } from "zod";
+declare const PluginRuntimeError_base: new <A extends Record<string, any> = {}>(
+	args: import("effect/Types").Equals<A, {}> extends true
+		? void
+		: { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] },
+) => import("effect/Cause").YieldableError & {
+	readonly _tag: "PluginRuntimeError";
+} & Readonly<A>;
+export declare class PluginRuntimeError extends PluginRuntimeError_base<{
+	readonly pluginId?: string;
+	readonly operation: string;
+	readonly cause?: Error;
+	readonly retryable: boolean;
+}> {}
+declare const ModuleFederationError_base: new <
+	A extends Record<string, any> = {},
+>(
+	args: import("effect/Types").Equals<A, {}> extends true
+		? void
+		: { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] },
+) => import("effect/Cause").YieldableError & {
+	readonly _tag: "ModuleFederationError";
+} & Readonly<A>;
+export declare class ModuleFederationError extends ModuleFederationError_base<{
+	readonly pluginId: string;
+	readonly remoteUrl: string;
+	readonly cause?: Error;
+}> {}
+declare const ValidationError_base: new <A extends Record<string, any> = {}>(
+	args: import("effect/Types").Equals<A, {}> extends true
+		? void
+		: { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] },
+) => import("effect/Cause").YieldableError & {
+	readonly _tag: "ValidationError";
+} & Readonly<A>;
+export declare class ValidationError extends ValidationError_base<{
+	readonly pluginId: string;
+	readonly stage: "config" | "input" | "output" | "state";
+	readonly zodError: z.ZodError;
+}> {}
+declare const StreamError_base: new <A extends Record<string, any> = {}>(
+	args: import("effect/Types").Equals<A, {}> extends true
+		? void
+		: { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] },
+) => import("effect/Cause").YieldableError & {
+	readonly _tag: "StreamError";
+} & Readonly<A>;
+export declare class StreamError extends StreamError_base<{
+	readonly pluginId: string;
+	readonly operation:
+		| "callback"
+		| "state-extraction"
+		| "item-extraction"
+		| "stream-termination";
+	readonly cause?: Error;
+	readonly context?: {
+		readonly iteration?: number;
+		readonly itemsProcessed?: number;
+		readonly procedureName?: string;
+	};
+}> {}
+//# sourceMappingURL=errors.d.ts.map

package/dist/runtime/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;;;;AAE7B,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC9E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC5B,CAAC;CAAG;;;;AAEL,qBAAa,qBAAsB,SAAQ,2BAEzC;IACD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACvB,CAAC;CAAG;;;;AAEL,qBAAa,eAAgB,SAAQ,qBAAoC;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IACxD,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC;CAC9B,CAAC;CAAG;;;;AAEL,qBAAa,WAAY,SAAQ,iBAAgC;IAChE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,UAAU,GAAG,kBAAkB,GAAG,iBAAiB,GAAG,oBAAoB,CAAC;IAC/F,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE;QAClB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;KAChC,CAAC;CACF,CAAC;CAAG"}

package/dist/runtime/errors.js

@@ -0,0 +1,9 @@
+import { Data } from "effect";
+export class PluginRuntimeError extends Data.TaggedError(
+	"PluginRuntimeError",
+) {}
+export class ModuleFederationError extends Data.TaggedError(
+	"ModuleFederationError",
+) {}
+export class ValidationError extends Data.TaggedError("ValidationError") {}
+export class StreamError extends Data.TaggedError("StreamError") {}

package/dist/runtime/index.d.ts

@@ -0,0 +1,73 @@
+import { Effect, Layer, ManagedRuntime, type Stream } from "effect";
+import type { z } from "zod";
+import type { SourcePlugin } from "../source";
+import { PluginRuntimeError } from "./errors";
+import { type SourceStreamOptions } from "./streaming";
+import type {
+	AnyPlugin,
+	InitializedPlugin,
+	PluginConstructor,
+	PluginInstance,
+	PluginRuntimeConfig,
+} from "./types";
+export interface IPluginRuntime {
+	readonly loadPlugin: (
+		pluginId: string,
+	) => Effect.Effect<PluginConstructor, PluginRuntimeError>;
+	readonly instantiatePlugin: <T extends AnyPlugin>(
+		ctor: PluginConstructor,
+	) => Effect.Effect<PluginInstance<T>, PluginRuntimeError>;
+	readonly initializePlugin: <T extends AnyPlugin>(
+		instance: PluginInstance<T>,
+		config: z.infer<T["configSchema"]>,
+	) => Effect.Effect<InitializedPlugin<T>, PluginRuntimeError>;
+	readonly executePlugin: <T extends AnyPlugin>(
+		initializedPlugin: InitializedPlugin<T>,
+		input: z.infer<T["inputSchema"]>,
+	) => Effect.Effect<z.infer<T["outputSchema"]>, PluginRuntimeError>;
+	readonly usePlugin: <T extends AnyPlugin>(
+		pluginId: string,
+		config: z.infer<T["configSchema"]>,
+	) => Effect.Effect<InitializedPlugin<T>, PluginRuntimeError>;
+	readonly streamPlugin: <
+		T extends SourcePlugin,
+		TInput extends z.infer<T["inputSchema"]> = z.infer<T["inputSchema"]>,
+		TItem = unknown,
+	>(
+		pluginId: string,
+		config: z.infer<T["configSchema"]>,
+		input: TInput,
+		options?: SourceStreamOptions<TItem>,
+	) => Effect.Effect<
+		Stream.Stream<TItem, PluginRuntimeError>,
+		PluginRuntimeError
+	>;
+	readonly shutdown: () => Effect.Effect<void, never, never>;
+}
+declare const PluginRuntime_base: import("effect/Context").TagClass<
+	PluginRuntime,
+	"PluginRuntime",
+	IPluginRuntime
+> &
+	Effect.Tag.Proxy<PluginRuntime, IPluginRuntime> & {
+		use: <X>(
+			body: (_: IPluginRuntime) => X,
+		) => [X] extends [Effect.Effect<infer A, infer E, infer R>]
+			? Effect.Effect<A, E, PluginRuntime | R>
+			: [X] extends [PromiseLike<infer A_1>]
+				? Effect.Effect<
+						A_1,
+						import("effect/Cause").UnknownException,
+						PluginRuntime
+					>
+				: Effect.Effect<X, never, PluginRuntime>;
+	};
+export declare class PluginRuntime extends PluginRuntime_base {
+	static Live: (
+		config: PluginRuntimeConfig,
+	) => Layer.Layer<PluginRuntime, never, never>;
+}
+export declare const createPluginRuntime: (
+	config: PluginRuntimeConfig,
+) => ManagedRuntime.ManagedRuntime<PluginRuntime, never>;
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AACpE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAM9C,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,KAAK,EACX,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,MAAM,SAAS,CAAC;AAwBjB,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,UAAU,EAAE,CACpB,QAAQ,EAAE,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC/C,IAAI,EAAE,iBAAiB,KACnB,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAC,SAAS,SAAS,EAC9C,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,EAC3B,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,KAC9B,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC7D,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC,SAAS,SAAS,EAC3C,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC,EACvC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IACnE,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,SAAS,EACvC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,KAC9B,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAC7D,QAAQ,CAAC,YAAY,EAAE,CACtB,CAAC,SAAS,YAAY,EACtB,MAAM,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,EACpE,KAAK,GAAG,OAAO,EAEf,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,EAClC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAChC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,CAAC;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;CAC3D;;;;AAED,qBAAa,aAAc,SAAQ,kBAGhC;IACF,MAAM,CAAC,IAAI,GAAI,QAAQ,mBAAmB,8CAyGzC;CACD;AAED,eAAO,MAAM,mBAAmB,GAAI,QAAQ,mBAAmB,wDACf,CAAC"}

package/dist/runtime/index.js

@@ -0,0 +1,133 @@
+import { Effect, Layer, ManagedRuntime } from "effect";
+import { PluginLoggerTag } from "../plugin";
+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 }),
+		),
+});
+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,
+					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));

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

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

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

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