every-plugin 0.4.3 → 0.4.5

package/dist/runtime/services/module-federation.service.js

@@ -1,155 +0,0 @@
-import { betterFetch } from "@better-fetch/fetch";
-import { createInstance, getInstance, } from "@module-federation/enhanced/runtime";
-import { setGlobalFederationInstance } from "@module-federation/runtime-core";
-import { Effect } from "effect";
-import { ModuleFederationError } from "../errors";
-import { getNormalizedRemoteName } from "./normalize";
-import pkg from "../../../package.json";
-const createModuleFederationInstance = Effect.cached(Effect.sync(() => {
-    try {
-        let instance = getInstance();
-        if (!instance) {
-            instance = createInstance({
-                name: "host",
-                remotes: [],
-                shared: {
-                    "every-plugin": {
-                        version: pkg.version,
-                        shareConfig: {
-                            singleton: true,
-                            requiredVersion: `^${pkg.version}`,
-                            eager: true,
-                            strictVersion: true,
-                        },
-                    },
-                    effect: {
-                        version: pkg.dependencies.effect,
-                        shareConfig: {
-                            singleton: true,
-                            requiredVersion: "^3.18.0", // Allow any 3.18.x patch version
-                            eager: true,
-                            strictVersion: true, // Enforce major/minor compatibility
-                        },
-                    },
-                    zod: {
-                        version: pkg.dependencies.zod,
-                        shareConfig: {
-                            singleton: true,
-                            requiredVersion: "^4.1.0", // Allow any 4.1.x patch version
-                            eager: true,
-                            strictVersion: true,
-                        },
-                    },
-                    "@orpc/contract": {
-                        version: pkg.dependencies["@orpc/contract"],
-                        shareConfig: {
-                            singleton: true,
-                            requiredVersion: "^1.8.0", // Allow any 1.8.x patch version
-                            eager: true,
-                            strictVersion: true,
-                        },
-                    },
-                    "@orpc/server": {
-                        version: pkg.dependencies["@orpc/server"],
-                        shareConfig: {
-                            singleton: true,
-                            requiredVersion: "^1.8.0", // Allow any 1.8.x patch version
-                            eager: true,
-                            strictVersion: true,
-                        },
-                    }
-                },
-            });
-            setGlobalFederationInstance(instance);
-        }
-        return instance;
-    }
-    catch (error) {
-        throw new Error(`Failed to initialize Module Federation: ${error}`);
-    }
-}));
-export class ModuleFederationService extends Effect.Service()("ModuleFederationService", {
-    effect: Effect.gen(function* () {
-        const mf = yield* Effect.flatten(createModuleFederationInstance);
-        return {
-            registerRemote: (pluginId, url) => Effect.gen(function* () {
-                console.log(`[MF] Registering ${pluginId}`);
-                // Check if remote is available
-                const { error } = yield* Effect.tryPromise({
-                    try: () => betterFetch(url, { method: "HEAD" }),
-                    catch: (error) => new ModuleFederationError({
-                        pluginId,
-                        remoteUrl: url,
-                        cause: error instanceof Error ? error : new Error(String(error)),
-                    }),
-                });
-                if (error) {
-                    console.log(`[MF] ❌ Remote not available for ${pluginId}`);
-                    return yield* Effect.fail(new ModuleFederationError({
-                        pluginId,
-                        remoteUrl: url,
-                        cause: new Error(`Remote not available (${url}): ${JSON.stringify(error)}`),
-                    }));
-                }
-                const remoteName = getNormalizedRemoteName(pluginId);
-                yield* Effect.try({
-                    try: () => mf.registerRemotes([{ name: remoteName, entry: url }]),
-                    catch: (error) => new ModuleFederationError({
-                        pluginId,
-                        remoteUrl: url,
-                        cause: error instanceof Error ? error : new Error(String(error)),
-                    }),
-                });
-                console.log(`[MF] ✅ Registered ${pluginId}`);
-            }),
-            loadRemoteConstructor: (pluginId, url) => Effect.gen(function* () {
-                const remoteName = getNormalizedRemoteName(pluginId);
-                console.log(`[MF] Loading remote ${remoteName}`);
-                const modulePath = `${remoteName}/plugin`;
-                return yield* Effect.tryPromise({
-                    try: async () => {
-                        const container = await mf.loadRemote(modulePath);
-                        if (!container) {
-                            throw new Error(`No container returned for ${modulePath}`);
-                        }
-                        // Support multiple export patterns: direct function, default export, named exports
-                        const Constructor = typeof container === "function"
-                            ? container // Direct function export
-                            : container.default
-                                ? container.default // Default export
-                                : Object.values(container).find(// Named export fallback
-                                (exp) => typeof exp === "function" && exp.prototype?.constructor === exp);
-                        if (!Constructor || typeof Constructor !== "function") {
-                            const containerInfo = typeof container === "object"
-                                ? `Available exports: ${Object.keys(container).join(', ')}`
-                                : `Container type: ${typeof container}`;
-                            throw new Error(`No valid plugin constructor found for '${pluginId}'.\n` +
-                                `Supported patterns:\n` +
-                                `  - export const YourPlugin = createPlugin({...})\n` +
-                                `  - export default createPlugin({...})\n` +
-                                `${containerInfo}`);
-                        }
-                        // Validate it looks like a plugin constructor (has binding property)
-                        if (!Constructor.binding) {
-                            const containerInfo = typeof container === "object"
-                                ? `Found exports: ${Object.keys(container).join(', ')}`
-                                : `Container type: ${typeof container}`;
-                            throw new Error(`Invalid plugin constructor for '${pluginId}'. ` +
-                                `The exported value must be created with createPlugin(). ` +
-                                `Found a function but it's missing the required 'binding' property.\n` +
-                                `${containerInfo}`);
-                        }
-                        console.log(`[MF] ✅ Loaded constructor for ${pluginId}`);
-                        return Constructor;
-                    },
-                    catch: (error) => new ModuleFederationError({
-                        pluginId,
-                        remoteUrl: url,
-                        cause: error instanceof Error ? error : new Error(String(error)),
-                    }),
-                });
-            }),
-        };
-    }),
-}) {
-}

package/dist/runtime/services/normalize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,KAAG,MACG,CAAC"}

package/dist/runtime/services/plugin-lifecycle.service.d.ts

@@ -1,14 +0,0 @@
-import { Effect } from "effect";
-import type { AnyPlugin, InitializedPlugin } from "../../types";
-declare const PluginLifecycleService_base: Effect.Service.Class<PluginLifecycleService, "PluginLifecycleService", {
-    readonly effect: Effect.Effect<{
-        register: <T extends AnyPlugin>(plugin: InitializedPlugin<T>) => Effect.Effect<void, never, never>;
-        unregister: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void, never, never>;
-        shutdown: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void, import("../errors").PluginRuntimeError, never>;
-        cleanup: () => Effect.Effect<void, never, never>;
-    }, never, never>;
-}>;
-export declare class PluginLifecycleService extends PluginLifecycleService_base {
-}
-export {};
-//# sourceMappingURL=plugin-lifecycle.service.d.ts.map

package/dist/runtime/services/plugin-lifecycle.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-lifecycle.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin-lifecycle.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAO,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;;;mBAQ/C,CAAC,SAAS,SAAS,UAAU,iBAAiB,CAAC,CAAC,CAAC;6BAKvC,iBAAiB,CAAC,SAAS,CAAC;2BAO9B,iBAAiB,CAAC,SAAS,CAAC;;;;AAjBrD,qBAAa,sBAAuB,SAAQ,2BAgE1C;CAAI"}

package/dist/runtime/services/plugin-lifecycle.service.js

@@ -1,34 +0,0 @@
-import { Effect, Ref } from "effect";
-import { toPluginRuntimeError } from "../errors";
-export class PluginLifecycleService extends Effect.Service()("PluginLifecycleService", {
-    effect: Effect.gen(function* () {
-        const activePlugins = yield* Ref.make(new Set());
-        return {
-            register: (plugin) => Ref.update(activePlugins, plugins => new Set(plugins).add(plugin)),
-            unregister: (plugin) => Ref.update(activePlugins, plugins => {
-                const newSet = new Set(plugins);
-                newSet.delete(plugin);
-                return newSet;
-            }),
-            shutdown: (plugin) => Effect.gen(function* () {
-                // Remove from active plugins
-                yield* Ref.update(activePlugins, plugins => {
-                    const newSet = new Set(plugins);
-                    newSet.delete(plugin);
-                    return newSet;
-                });
-                // Shutdown the plugin
-                yield* plugin.plugin.shutdown().pipe(Effect.mapError(error => toPluginRuntimeError(error, plugin.plugin.id, undefined, "shutdown-plugin", false)));
-            }),
-            cleanup: () => 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.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
-            ),
-        };
-    }),
-}) {
-}

package/dist/runtime/services/plugin-loader.service.d.ts

@@ -1,45 +0,0 @@
-import type { InferSchemaInput, InferSchemaOutput } from "@orpc/contract";
-import { Context, Effect, Scope } from "effect";
-import type { AnyPlugin, LoadedPlugin, PluginInstance, PluginRegistry } from "../../types";
-import { PluginRuntimeError } from "../errors";
-import { ModuleFederationService } from "./module-federation.service";
-import { SecretsService } from "./secrets.service";
-declare const PluginRegistryTag_base: Context.TagClass<PluginRegistryTag, "PluginRegistry", PluginRegistry>;
-export declare class PluginRegistryTag extends PluginRegistryTag_base {
-}
-declare const RegistryService_base: Effect.Service.Class<RegistryService, "RegistryService", {
-    readonly effect: Effect.Effect<{
-        get: (pluginId: string) => Effect.Effect<import("../..").PluginMetadata, PluginRuntimeError, never>;
-    }, never, PluginRegistryTag>;
-}>;
-export declare class RegistryService extends RegistryService_base {
-}
-declare const PluginLoaderService_base: Effect.Service.Class<PluginLoaderService, "PluginLoaderService", {
-    readonly effect: Effect.Effect<{
-        loadPlugin: (pluginId: string) => Effect.Effect<{
-            ctor: new () => AnyPlugin;
-            metadata: import("../..").PluginMetadata;
-        }, PluginRuntimeError, never>;
-        instantiatePlugin: <T extends AnyPlugin>(pluginId: string, loadedPlugin: LoadedPlugin<T>) => Effect.Effect<{
-            plugin: T;
-            metadata: import("../..").PluginMetadata;
-        }, PluginRuntimeError, never>;
-        initializePlugin: <T extends AnyPlugin>(pluginInstance: PluginInstance<T>, config: {
-            variables: InferSchemaInput<T["configSchema"]["variables"]>;
-            secrets: InferSchemaInput<T["configSchema"]["secrets"]>;
-        }) => Effect.Effect<{
-            plugin: T;
-            metadata: import("../..").PluginMetadata;
-            config: {
-                variables: InferSchemaOutput<T["configSchema"]["variables"]>;
-                secrets: InferSchemaOutput<T["configSchema"]["secrets"]>;
-            };
-            context: any;
-            scope: Scope.CloseableScope;
-        }, PluginRuntimeError, never>;
-    }, never, ModuleFederationService | SecretsService | RegistryService>;
-}>;
-export declare class PluginLoaderService extends PluginLoaderService_base {
-}
-export {};
-//# sourceMappingURL=plugin-loader.service.d.ts.map

package/dist/runtime/services/plugin-loader.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-loader.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin-loader.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEhD,OAAO,KAAK,EACX,SAAS,EAET,YAAY,EACZ,cAAc,EACd,cAAc,EACd,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,kBAAkB,EAAwB,MAAM,WAAW,CAAC;AAErE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;;AAEnD,qBAAa,iBAAkB,SAAQ,sBAGpC;CAAI;;;wBAOY,MAAM;;;AALzB,qBAAa,eAAgB,SAAQ,oBAkBnC;CAAI;;;+BAgBoB,MAAM;;;;4BAyBT,CAAC,SAAS,SAAS,YAC5B,MAAM,gBACF,YAAY,CAAC,CAAC,CAAC;;;;2BAuBX,CAAC,SAAS,SAAS,kBACrB,cAAc,CAAC,CAAC,CAAC,UACzB;YAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;YAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;SAAE;;;;;;;;;;;;AAlEpI,qBAAa,mBAAoB,SAAQ,wBAoJvC;CACD"}

package/dist/runtime/services/plugin-loader.service.js

@@ -1,93 +0,0 @@
-import { Context, Effect, Scope } from "effect";
-import { PluginRuntimeError, toPluginRuntimeError } from "../errors";
-import { validate } from "../validation";
-import { ModuleFederationService } from "./module-federation.service";
-import { SecretsService } from "./secrets.service";
-export class PluginRegistryTag extends Context.Tag("PluginRegistry")() {
-}
-export class RegistryService extends Effect.Service()("RegistryService", {
-    effect: Effect.gen(function* () {
-        const registry = yield* PluginRegistryTag;
-        return {
-            get: (pluginId) => Effect.fromNullable(registry[pluginId]).pipe(Effect.mapError(() => new PluginRuntimeError({
-                pluginId,
-                operation: "validate-plugin-id",
-                cause: new Error(`Plugin ${pluginId} not found in registry`),
-                retryable: false,
-            }))),
-        };
-    }),
-}) {
-}
-export class PluginLoaderService extends Effect.Service()("PluginLoaderService", {
-    effect: Effect.gen(function* () {
-        const moduleFederationService = yield* ModuleFederationService;
-        const secretsService = yield* SecretsService;
-        const registryService = yield* RegistryService;
-        const resolveUrl = (baseUrl, version) => version && version !== "latest"
-            ? baseUrl.replace("@latest", `@${version}`)
-            : baseUrl;
-        const getMetadata = (pluginId) => registryService.get(pluginId);
-        return {
-            loadPlugin: (pluginId) => Effect.gen(function* () {
-                const metadata = yield* getMetadata(pluginId);
-                const url = resolveUrl(metadata.remoteUrl);
-                yield* moduleFederationService.registerRemote(pluginId, url).pipe(Effect.mapError((error) => toPluginRuntimeError(error.cause, pluginId, undefined, "register-remote", true)));
-                yield* Effect.logDebug("Loading plugin", { pluginId, url });
-                const ctor = yield* moduleFederationService.loadRemoteConstructor(pluginId, url).pipe(Effect.mapError((error) => toPluginRuntimeError(error.cause, pluginId, undefined, "load-remote", false)));
-                return {
-                    ctor,
-                    metadata: metadata,
-                };
-            }),
-            instantiatePlugin: (pluginId, loadedPlugin) => Effect.gen(function* () {
-                const instance = yield* Effect.try(() => new loadedPlugin.ctor()).pipe(Effect.mapError((error) => toPluginRuntimeError(error, pluginId, undefined, "instantiate-plugin", false)));
-                instance.id = pluginId;
-                return {
-                    plugin: instance,
-                    metadata: loadedPlugin.metadata,
-                };
-            }),
-            initializePlugin: (pluginInstance, config) => Effect.gen(function* () {
-                const { plugin } = pluginInstance;
-                // Validate and hydrate config
-                const validatedVariables = yield* validate(plugin.configSchema.variables, config.variables, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "validate-config",
-                    cause: validationError.zodError,
-                    retryable: false,
-                })));
-                // Validate secrets
-                const validatedSecrets = yield* validate(plugin.configSchema.secrets, config.secrets, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "validate-secrets",
-                    cause: validationError.zodError,
-                    retryable: false,
-                })));
-                // Hydrate secrets in variables
-                const hydratedConfig = yield* secretsService.hydrateSecrets({
-                    variables: validatedVariables,
-                    secrets: validatedSecrets,
-                });
-                const _variables = yield* validate(plugin.configSchema.variables, hydratedConfig.variables, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "validate-hydrated-config",
-                    cause: validationError.zodError,
-                    retryable: false,
-                })));
-                // Create a long-lived scope for this plugin instance
-                const scope = yield* Scope.make();
-                // Initialize plugin within the scope
-                const context = yield* plugin.initialize({ variables: _variables, secrets: hydratedConfig.secrets }).pipe(Effect.provideService(Scope.Scope, scope), Effect.mapError((error) => toPluginRuntimeError(error, plugin.id, undefined, "initialize-plugin", false)));
-                return {
-                    plugin,
-                    metadata: pluginInstance.metadata,
-                    config: { variables: _variables, secrets: hydratedConfig.secrets },
-                    context,
-                    scope,
-                };
-            }),
-        };
-    }),
-}) {
-}

package/dist/runtime/services/plugin.service.d.ts

@@ -1,36 +0,0 @@
-import { Effect, Layer, Scope } from "effect";
-import type { AnyPlugin, InitializedPlugin, PluginRegistry, SecretsConfig } from "../../types";
-import { PluginLifecycleService } from "./plugin-lifecycle.service";
-import { PluginLoaderService } from "./plugin-loader.service";
-declare const PluginService_base: Effect.Service.Class<PluginService, "PluginService", {
-    readonly scoped: Effect.Effect<{
-        loadPlugin: (pluginId: string) => Effect.Effect<{
-            ctor: new () => AnyPlugin;
-            metadata: import("../..").PluginMetadata;
-        }, import("../errors").PluginRuntimeError, never>;
-        instantiatePlugin: <T extends AnyPlugin>(pluginId: string, loadedPlugin: import("../..").LoadedPlugin<T>) => Effect.Effect<{
-            plugin: T;
-            metadata: import("../..").PluginMetadata;
-        }, import("../errors").PluginRuntimeError, never>;
-        initializePlugin: <T extends AnyPlugin>(pluginInstance: import("../..").PluginInstance<T>, config: {
-            variables: import("@orpc/contract").InferSchemaInput<T["configSchema"]["variables"]>;
-            secrets: import("@orpc/contract").InferSchemaInput<T["configSchema"]["secrets"]>;
-        }) => Effect.Effect<{
-            plugin: T;
-            metadata: import("../..").PluginMetadata;
-            config: {
-                variables: import("@orpc/contract").InferSchemaOutput<T["configSchema"]["variables"]>;
-                secrets: import("@orpc/contract").InferSchemaOutput<T["configSchema"]["secrets"]>;
-            };
-            context: any;
-            scope: Scope.CloseableScope;
-        }, import("../errors").PluginRuntimeError, never>;
-        shutdownPlugin: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void, never, never>;
-        cleanup: () => Effect.Effect<void, never, never>;
-    }, never, PluginLifecycleService | PluginLoaderService>;
-}>;
-export declare class PluginService extends PluginService_base {
-    static Live: (registry: PluginRegistry, secrets: SecretsConfig) => Layer.Layer<PluginService, never, never>;
-}
-export {};
-//# sourceMappingURL=plugin.service.d.ts.map

package/dist/runtime/services/plugin.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/plugin.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACpD,OAAO,KAAK,EACX,SAAS,EACT,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAsC,MAAM,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;iCAYtE,iBAAiB,CAAC,SAAS,CAAC;;;;AATxD,qBAAa,aAAc,SAAQ,kBAyBjC;IACD,MAAM,CAAC,IAAI,GAAI,UAAU,cAAc,EAAE,SAAS,aAAa,8CAmB9D;CACD"}

package/dist/runtime/services/plugin.service.js

@@ -1,31 +0,0 @@
-import { Effect, Exit, Layer, Scope } from "effect";
-import { ModuleFederationService } from "./module-federation.service";
-import { PluginLifecycleService } from "./plugin-lifecycle.service";
-import { PluginLoaderService, PluginRegistryTag, RegistryService } from "./plugin-loader.service";
-import { SecretsConfigTag, SecretsService } from "./secrets.service";
-export class PluginService extends Effect.Service()("PluginService", {
-    scoped: Effect.gen(function* () {
-        const loader = yield* PluginLoaderService;
-        const lifecycle = yield* PluginLifecycleService;
-        return {
-            loadPlugin: loader.loadPlugin,
-            instantiatePlugin: loader.instantiatePlugin,
-            initializePlugin: loader.initializePlugin,
-            shutdownPlugin: (plugin) => Effect.gen(function* () {
-                // Shutdown the plugin first (graceful cleanup)
-                yield* plugin.plugin.shutdown().pipe(Effect.catchAll(() => Effect.void));
-                // 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,
-        };
-    }),
-}) {
-    static Live = (registry, secrets) => {
-        const contextLayer = Layer.mergeAll(Layer.succeed(PluginRegistryTag, registry), Layer.succeed(SecretsConfigTag, secrets));
-        const servicesLayer = Layer.mergeAll(ModuleFederationService.Default, SecretsService.Default, RegistryService.Default, PluginLifecycleService.Default).pipe(Layer.provide(contextLayer));
-        return PluginService.Default.pipe(Layer.provide(PluginLoaderService.Default), Layer.provide(servicesLayer));
-    };
-}

package/dist/runtime/services/secrets.service.d.ts

@@ -1,15 +0,0 @@
-import { Context, Effect } from "effect";
-import type { SecretsConfig } from "../../types";
-import { PluginRuntimeError } from "../errors";
-declare const SecretsConfigTag_base: Context.TagClass<SecretsConfigTag, "SecretsConfig", SecretsConfig>;
-export declare class SecretsConfigTag extends SecretsConfigTag_base {
-}
-declare const SecretsService_base: Effect.Service.Class<SecretsService, "SecretsService", {
-    readonly effect: Effect.Effect<{
-        hydrateSecrets: <T>(config: T) => Effect.Effect<T, PluginRuntimeError, never>;
-    }, never, SecretsConfigTag>;
-}>;
-export declare class SecretsService extends SecretsService_base {
-}
-export {};
-//# sourceMappingURL=secrets.service.d.ts.map

package/dist/runtime/services/secrets.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"secrets.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/secrets.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;;AAM/C,qBAAa,gBAAiB,SAAQ,qBAGnC;CAAI;;;yBAOa,CAAC,UAAU,CAAC;;;AALhC,qBAAa,cAAe,SAAQ,mBA+BlC;CAAI"}

package/dist/runtime/services/secrets.service.js

@@ -1,35 +0,0 @@
-import { Context, Effect } from "effect";
-import { z } from "zod";
-import { PluginRuntimeError } from "../errors";
-const configSchema = z.object({
-    secrets: z.record(z.string(), z.unknown())
-}).loose();
-export class SecretsConfigTag extends Context.Tag("SecretsConfig")() {
-}
-export class SecretsService extends Effect.Service()("SecretsService", {
-    effect: Effect.gen(function* () {
-        const secrets = yield* SecretsConfigTag;
-        return {
-            hydrateSecrets: (config) => Effect.gen(function* () {
-                const parseResult = configSchema.parse(config);
-                try {
-                    const configString = JSON.stringify(parseResult);
-                    let hydratedString = configString;
-                    for (const [key, value] of Object.entries(secrets)) {
-                        const pattern = new RegExp(`{{${key}}}`, "g");
-                        hydratedString = hydratedString.replace(pattern, String(value));
-                    }
-                    return JSON.parse(hydratedString);
-                }
-                catch (error) {
-                    return yield* Effect.fail(new PluginRuntimeError({
-                        operation: "hydrate-secrets",
-                        cause: error instanceof Error ? error : new Error(String(error)),
-                        retryable: false,
-                    }));
-                }
-            }),
-        };
-    }),
-}) {
-}

package/dist/runtime/services.d.ts

@@ -1,6 +0,0 @@
-export * from "./services/module-federation.service";
-export * from "./services/plugin.service";
-export * from "./services/plugin-lifecycle.service";
-export * from "./services/plugin-loader.service";
-export * from "./services/secrets.service";
-//# sourceMappingURL=services.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/runtime/services.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAA;AACpD,cAAc,2BAA2B,CAAA;AACzC,cAAc,qCAAqC,CAAA;AACnD,cAAc,kCAAkC,CAAA;AAChD,cAAc,4BAA4B,CAAA"}

package/dist/runtime/services.js

@@ -1,5 +0,0 @@
-export * from "./services/module-federation.service";
-export * from "./services/plugin.service";
-export * from "./services/plugin-lifecycle.service";
-export * from "./services/plugin-loader.service";
-export * from "./services/secrets.service";

package/dist/runtime/validation.d.ts

@@ -1,5 +0,0 @@
-import { Effect } from "effect";
-import type { z } from "zod";
-import { ValidationError } from "./errors";
-export declare const validate: <T>(schema: z.ZodSchema<T>, data: unknown, pluginId: string, stage: "config" | "input" | "output" | "state") => Effect.Effect<T, ValidationError>;
-//# sourceMappingURL=validation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/runtime/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,eAAO,MAAM,QAAQ,GAAI,CAAC,EACzB,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACtB,MAAM,OAAO,EACb,UAAU,MAAM,EAChB,OAAO,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,KAC5C,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,eAAe,CAahC,CAAC"}

package/dist/runtime/validation.js

@@ -1,13 +0,0 @@
-import { Effect } from "effect";
-import { ValidationError } from "./errors";
-export const validate = (schema, data, pluginId, stage) => 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/dist/testing/index.d.ts

@@ -1,59 +0,0 @@
-import { Layer } from "effect";
-import { PluginRuntime } from "../runtime";
-import { PluginService } from "../runtime/services";
-import type { PluginRuntimeConfig, RegisteredPlugins } from "../types";
-import { type PluginMap } from "./mocks/module-federation.service";
-/**
- * Validates that all plugin map keys exist in RegisteredPlugins.
- * This ensures proper type inference for client methods.
- */
-type ValidatePluginMap<T extends PluginMap> = {
-    [K in keyof T]: K extends keyof RegisteredPlugins ? T[K] : `❌ Plugin key "${K & string}" not registered in RegisteredPlugins. Add it to your types.d.ts file.`;
-};
-/**
- * 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];
-} & RegisteredPlugins;
-/**
- * Creates a test layer with mock ModuleFederationService for unit testing.
- * This mirrors PluginService.Live() but uses mock ModuleFederationService.
- */
-export declare const createTestLayer: <R extends RegisteredPlugins = RegisteredPlugins>(config: PluginRuntimeConfig<R>, pluginMap: PluginMap) => Layer.Layer<PluginService, never, never>;
-/**
- * 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.
- *
- * Ideal for:
- * - Unit and integration tests
- * - Local development and debugging
- * - Monorepo setups where all plugins are in the same workspace
- *
- * For production with remote Module Federation plugins, use createPluginRuntime().
- *
- * @example
- * ```ts
- * const pluginMap = { "my-plugin": MyPlugin } as const;
- * const runtime = createLocalPluginRuntime({ registry, secrets }, pluginMap);
- *
- * // Types are automatically inferred - no manual bindings needed!
- * const plugin = await runtime.usePlugin("my-plugin", config);
- * ```
- */
-export declare function createLocalPluginRuntime<TMap extends PluginMap & ValidatePluginMap<TMap>>(config: PluginRuntimeConfig, pluginMap: TMap): PluginRuntime<InferBindingsFromMap<TMap>>;
-/**
- * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
- */
-export declare const createTestPluginRuntime: typeof createLocalPluginRuntime;
-export type { EveryPlugin, PluginRegistry, RegisteredPlugins } from "../types";
-export type { PluginMap, PluginRuntimeConfig };
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,QAAQ,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAIN,aAAa,EAIb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACvE,OAAO,EAA0C,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAE3G;;;GAGG;AACH,KAAK,iBAAiB,CAAC,CAAC,SAAS,SAAS,IAAI;KAC5C,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,MAAM,iBAAiB,GAC9C,CAAC,CAAC,CAAC,CAAC,GACJ,iBAAiB,CAAC,GAAG,MAAM,wEAAwE;CACtG,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,SAAS,IAAI;KACtD,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACpB,GAAG,iBAAiB,CAAC;AAEtB;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,EAC9E,QAAQ,mBAAmB,CAAC,CAAC,CAAC,EAC9B,WAAW,SAAS,6CAwBpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,SAAS,SAAS,GAAG,iBAAiB,CAAC,IAAI,CAAC,EACxF,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,IAAI,GACb,aAAa,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAK3C;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,iCAA2B,CAAC;AAGhE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC/E,YAAY,EAAE,SAAS,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/testing/index.js

@@ -1,45 +0,0 @@
-import { Layer, ManagedRuntime } from "effect";
-import { PluginRuntime } from "../runtime";
-import { PluginLifecycleService, PluginLoaderService, PluginRegistryTag, PluginService, RegistryService, SecretsConfigTag, SecretsService } from "../runtime/services";
-import { createMockModuleFederationServiceLayer } from "./mocks/module-federation.service";
-/**
- * Creates a test layer with mock ModuleFederationService for unit testing.
- * This mirrors PluginService.Live() but uses mock ModuleFederationService.
- */
-export const createTestLayer = (config, pluginMap) => {
-    const secrets = config.secrets || {};
-    const contextLayer = Layer.mergeAll(Layer.succeed(PluginRegistryTag, config.registry), Layer.succeed(SecretsConfigTag, secrets));
-    const mockModuleFederationLayer = createMockModuleFederationServiceLayer(pluginMap);
-    const servicesLayer = Layer.mergeAll(mockModuleFederationLayer, SecretsService.Default, RegistryService.Default, PluginLifecycleService.Default).pipe(Layer.provide(contextLayer));
-    return PluginService.Default.pipe(Layer.provide(PluginLoaderService.Default), Layer.provide(servicesLayer));
-};
-/**
- * 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.
- *
- * Ideal for:
- * - Unit and integration tests
- * - Local development and debugging
- * - Monorepo setups where all plugins are in the same workspace
- *
- * For production with remote Module Federation plugins, use createPluginRuntime().
- *
- * @example
- * ```ts
- * const pluginMap = { "my-plugin": MyPlugin } as const;
- * const runtime = createLocalPluginRuntime({ registry, secrets }, pluginMap);
- *
- * // Types are automatically inferred - no manual bindings needed!
- * const plugin = await runtime.usePlugin("my-plugin", config);
- * ```
- */
-export function createLocalPluginRuntime(config, pluginMap) {
-    const layer = createTestLayer(config, pluginMap);
-    const runtime = ManagedRuntime.make(layer);
-    return new PluginRuntime(runtime, config.registry);
-}
-/**
- * @deprecated Use `createLocalPluginRuntime` instead. This alias is kept for backward compatibility.
- */
-export const createTestPluginRuntime = createLocalPluginRuntime;