every-plugin 2.10.1 → 3.0.0-rc.3

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

@@ -1,86 +1,77 @@
-import { Effect, Exit, Ref, Scope } from "effect";
+import { Config, Context, Effect, Exit, Layer, Ref, Scope } from "effect";
 import type { AnyPlugin, InitializedPlugin } from "../../types";
-import { toPluginRuntimeError } from "../errors";
+import type { PluginRuntimeError } from "../errors";
 
-export class PluginLifecycleService extends Effect.Service<PluginLifecycleService>()(
-  "PluginLifecycleService",
-  {
-    effect: Effect.gen(function* () {
-      const activePlugins = yield* Ref.make(new Set<InitializedPlugin<AnyPlugin>>());
+export interface PluginLifecycleServiceShape {
+  register: <T extends AnyPlugin>(plugin: InitializedPlugin<T>) => Effect.Effect<void>;
+  unregister: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void>;
+  shutdown: (plugin: InitializedPlugin<AnyPlugin>) => Effect.Effect<void, PluginRuntimeError>;
+  cleanup: Effect.Effect<void>;
+}
 
-      return {
-        register: <T extends AnyPlugin>(plugin: InitializedPlugin<T>) =>
-          Ref.update(activePlugins, (plugins) =>
-            new Set(plugins).add(plugin as InitializedPlugin<AnyPlugin>),
-          ),
+export class PluginLifecycleService extends Context.Service<
+  PluginLifecycleService,
+  PluginLifecycleServiceShape
+>()("PluginLifecycleService") {}
 
-        unregister: (plugin: InitializedPlugin<AnyPlugin>) =>
-          Ref.update(activePlugins, (plugins) => {
+export const PluginLifecycleServiceDefault = Layer.effect(
+  PluginLifecycleService,
+  Effect.gen(function* () {
+    const activePlugins = yield* Ref.make(new Set<InitializedPlugin<AnyPlugin>>());
+
+    return {
+      register: <T extends AnyPlugin>(plugin: InitializedPlugin<T>) =>
+        Ref.update(activePlugins, (plugins) =>
+          new Set(plugins).add(plugin as InitializedPlugin<AnyPlugin>),
+        ),
+
+      unregister: (plugin: InitializedPlugin<AnyPlugin>) =>
+        Ref.update(activePlugins, (plugins) => {
+          const newSet = new Set(plugins);
+          newSet.delete(plugin);
+          return newSet;
+        }),
+
+      shutdown: (plugin: InitializedPlugin<AnyPlugin>) =>
+        Effect.gen(function* () {
+          yield* Ref.update(activePlugins, (plugins) => {
             const newSet = new Set(plugins);
             newSet.delete(plugin);
             return newSet;
-          }),
-
-        shutdown: (plugin: InitializedPlugin<AnyPlugin>) =>
-          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,
-                  ),
-                ),
-              );
-          }),
+          yield* Scope.close(plugin.scope, Exit.succeed(undefined)).pipe(
+            Effect.catchCause((cause) =>
+              Effect.logWarning(`Failed to close scope for plugin ${plugin.plugin.id}`, cause),
+            ),
+          );
+        }),
 
-        cleanup: () =>
-          Effect.gen(function* () {
-            const plugins = yield* Ref.get(activePlugins);
-            if (typeof process !== "undefined" && process.env?.EVERY_PLUGIN_DEBUG_SCOPES === "1") {
-              yield* Effect.logWarning(
-                `[PluginLifecycle] cleaning up ${plugins.size} active plugin(s)`,
-              );
-            }
+      cleanup: Effect.gen(function* () {
+        const plugins = yield* Ref.get(activePlugins);
+        const debugScopes = yield* Config.String("EVERY_PLUGIN_DEBUG_SCOPES").pipe(
+          Config.withDefault(""),
+          Effect.orElseSucceed(() => ""),
+        );
+        if (debugScopes === "1") {
+          yield* Effect.logWarning(
+            `[PluginLifecycle] cleaning up ${plugins.size} active plugin(s)`,
+          );
+        }
 
-            yield* Effect.forEach(
-              plugins,
-              (plugin) =>
-                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,
-                      ),
-                    ),
-                  );
-                }),
-              { concurrency: "unbounded" },
-            );
+        yield* Effect.forEach(
+          plugins,
+          (plugin) =>
+            Scope.close(plugin.scope, Exit.succeed(undefined)).pipe(
+              Effect.catchCause((cause) =>
+                Effect.logWarning(`Failed to shutdown plugin ${plugin.plugin.id}`, cause),
+              ),
+            ),
+          { concurrency: "unbounded" },
+        );
 
-            yield* Ref.set(activePlugins, new Set());
-          }).pipe(Effect.catchAll((error) => Effect.logWarning("Plugin cleanup failed", error))),
-      };
-    }),
-  },
-) {}
+        yield* Ref.set(activePlugins, new Set());
+      }).pipe(Effect.catchCause((cause) => Effect.logWarning("Plugin cleanup failed", cause))),
+    };
+  }),
+);