fix: close plugin activation context promptly

t3-code[bot] committed 2 months ago

Commit fd92f381 parent a390b303 files · +79 −14Browse files

Unified · Split

3 files

packages/plugin-runtime-poc/README.md +1 −1
packages/plugin-runtime-poc/src/effectScopeRuntime.ts +49 −13
packages/plugin-runtime-poc/src/runtimeContract.ts +29 −0

packages/plugin-runtime-poc/README.md+1−1

@@ -14,7 +14,7 @@ this is the recommended base because t3 already uses effect. it keeps cordis's o · 13 unmodified lines
14		14
15	## proved	15	## proved
16		16
17	- 31 tests cover dependency order, blocking, rollback, cycles, unchanged instance reuse, order-insensitive declarations, activation implementation replacement, schema-tagged errors, active callback reentrancy, synchronous callback microtasks, plain-function callback returns, descendant async tasks, late activation-context calls, queued input snapshots, observer isolation, cleanup reporting, unusual ids and slots, and immutable snapshots	17	- 32 tests cover dependency order, blocking, rollback, cycles, unchanged instance reuse, order-insensitive declarations, activation implementation replacement, schema-tagged errors, active callback reentrancy, synchronous callback microtasks, plain-function callback returns, prompt activation-context expiry, descendant async tasks, late activation-context calls, queued input snapshots, observer isolation, cleanup reporting, unusual ids and slots, and immutable snapshots
18	- manifest validation enforces semver, prevents entrypoint path escape, and keeps mobile declarative	18	- manifest validation enforces semver, prevents entrypoint path escape, and keeps mobile declarative
19	- the demo exercises activation, replacement, teardown, and a 250-plugin chain	19	- the demo exercises activation, replacement, teardown, and a 250-plugin chain
20		20

packages/plugin-runtime-poc/src/effectScopeRuntime.ts+49−13

   }
 }
+class PluginActivationContextExpiredError extends Schema.TaggedErrorClass<PluginActivationContextExpiredError>()(
+  "PluginActivationContextExpiredError",
+  {
+    method: Schema.Literals(["resolve", "register", "onDispose"]),
+    pluginId: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `activation context for ${this.pluginId} is no longer active (${this.method})`;
+  }
+}
 class PluginCallbackError extends Schema.TaggedErrorClass<PluginCallbackError>()(
   "PluginCallbackError",
   {
 type PluginPlanningError = DuplicatePluginIdError | DuplicateCapabilityError | DependencyCycleError;
+const isDuplicatePluginIdError = Schema.is(DuplicatePluginIdError);
+const isDuplicateCapabilityError = Schema.is(DuplicateCapabilityError);
+const isDependencyCycleError = Schema.is(DependencyCycleError);
+const isPluginPlanningError = (error: unknown): error is PluginPlanningError =>
+  isDuplicatePluginIdError(error) ||
+  isDuplicateCapabilityError(error) ||
+  isDependencyCycleError(error);
 type PluginReconcileError =
   | PluginPlanningError
   | PluginCallbackError
     callback: PluginCallback,
     pluginId: string,
     invoke: () => Result | PromiseLike<Result>,
+    onSettled?: () => void,
   ): Effect.Effect<Result, PluginCallbackError> =>
     Effect.tryPromise({
       try: async () => {
         const callbackState: PluginCallbackContext = { active: true, callback, pluginId };
+        let settled = false;
+        const settle = () => {
+          if (settled) return;
+          settled = true;
+          callbackState.active = false;
+          onSettled?.();
+        };
         try {
           const result = callbackContext.run(callbackState, invoke);
           if (typeof result === "object" && result !== null && "then" in result) {
-            return await Promise.resolve(result).finally(() => {
+            return await Promise.resolve(result).finally(settle);
-              callbackState.active = false;
-            });
           }
-          callbackState.active = false;
+          settle();
           return result;
         } catch (error) {
-          callbackState.active = false;
+          settle();
           throw error;
         }
       },
       const finalizers: Array<() => void | Promise<void>> = [];
       const plugin: LivePlugin = { definition, scope, contributions, cleanupErrors };
       let activating = true;
-      const assertActivating = () => {
+      const assertActivating = (method: "resolve" | "register" | "onDispose") => {
         if (!activating) {
-          throw new Error(`activation context for ${definition.id} is no longer active`);
+          throw new PluginActivationContextExpiredError({ method, pluginId: definition.id });
         }
       };
       const context: PluginActivationContext = {
         resolve: <Service>(capability: string): Service => {
-          assertActivating();
+          assertActivating("resolve");
           if (!capabilities.has(capability)) {
             throw new PluginResolutionError({ capability, pluginId: definition.id });
           }
           return capabilities.get(capability) as Service;
         },
         register: (slot, contribution) => {
-          assertActivating();
+          assertActivating("register");
           const values = contributions.get(slot) ?? [];
           values.push(contribution);
           contributions.set(slot, values);
         },
         onDispose: (finalizer) => {
-          assertActivating();
+          assertActivating("onDispose");
           finalizers.push(finalizer);
         },
       };
       const activationExit = yield* Effect.exit(
-        invokePluginCallback("activate", definition.id, () => definition.activate(context)),
+        invokePluginCallback(
+          "activate",
+          definition.id,
+          () => definition.activate(context),
+          () => {
+            activating = false;
+          },
+        ),
       );
-      activating = false;
       for (const finalizer of finalizers) {
         const finalizerEffect = invokePluginCallback("finalizer", definition.id, finalizer).pipe(
           Effect.catch((error) =>
       const plan = yield* Effect.try({
         try: () => planComposition(definitions),
-        catch: (error) => error as PluginPlanningError,
+        catch: (error) => {
+          if (!isPluginPlanningError(error)) throw error;
+          return error;
+        },
       });
       const affected = affectedPluginIds(current.plugins, plan.definitions);
       const currentById = new Map(current.plugins.map((plugin) => [plugin.definition.id, plugin]));

packages/plugin-runtime-poc/src/runtimeContract.ts+29−0

@@ -588,6 +588,35 @@ export function defineRuntimeContract(name: string, createRuntime: PluginRuntime · 587 unmodified lines
588	await runtime.dispose();	588	await runtime.dispose();
589	});	589	});
590		590
		591	it("rejects activation-context calls from microtasks queued by synchronous callbacks", async () => {
		592	let lateFailure: unknown;
		593	let disposed = false;
		594	const runtime = createRuntime();
		595
		596	await runtime.reconcile([
		597	{
		598	id: "acme.microtask-context",
		599	version: "1.0.0",
		600	activate(context) {
		601	queueMicrotask(() => {
		602	try {
		603	context.onDispose(() => {
		604	disposed = true;
		605	});
		606	} catch (error) {
		607	lateFailure = error;
		608	}
		609	});
		610	},
		611	},
		612	]);
		613
		614	expect(lateFailure).toBeInstanceOf(Error);
		615	expect((lateFailure as Error).message).toContain("no longer active");
		616	await runtime.dispose();
		617	expect(disposed).toBe(false);
		618	});
		619
591	it("rejects finalizers registered after activation settles", async () => {	620	it("rejects finalizers registered after activation settles", async () => {
592	let registerLateFinalizer!: () => void;	621	let registerLateFinalizer!: () => void;
593	let disposed = false;	622	let disposed = false;

fix: close plugin activation context promptly

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code