refactor(commands): build one context per invocation

canExecute opens the invocation with the context it builds; execute and
postCommandAction reuse it, so every stage, the class instance and
COMMAND_CONTEXT hold the same object.

Author: edusperoni

lib/common/services/command-definition-adapter.ts

@@ -254,8 +254,9 @@ export function createCommandFromDefinition<
 		return values;
 	};
 
-	// Read per call rather than snapshotted here: the options service only holds
-	// this command's parsed values once validateOptions has run for it.
+	// Read when an invocation opens rather than at definition time: the options
+	// service only holds this command's parsed values once validateOptions has
+	// run for it.
 	const buildContext = (args: string[]): CommandContext<TSchema> => {
 		const options: any = {};
 		for (const optionName of optionNames) {
@@ -339,7 +340,7 @@ export function createCommandFromDefinition<
 	// The state of one invocation. The command object itself is cached for the
 	// process, so nothing invocation-scoped may live outside one of these.
 	interface Invocation {
-		/** The context of the stage that is running; COMMAND_CONTEXT reads it. */
+		/** Built once when the invocation opens; every stage and COMMAND_CONTEXT share it. */
 		context: CommandContext<TSchema>;
 		injector: Injector;
 		setup: Promise<Awaited<TSetup>>;
@@ -375,15 +376,8 @@ export function createCommandFromDefinition<
 	const beginInvocation = (context: CommandContext<TSchema>): Invocation => {
 		const invocation: Invocation = {
 			context,
-			// Each entry point builds its own context object, so the token reads
-			// the live one rather than a snapshot: a handler that injects it gets
-			// the very context it was handed.
 			injector: targetInjector.createChild([
-				{
-					provide: COMMAND_CONTEXT,
-					useFactory: () => invocation.context,
-					shared: false,
-				},
+				{ provide: COMMAND_CONTEXT, useValue: context },
 			]),
 			setup: undefined,
 			hasRun: false,
@@ -452,9 +446,9 @@ export function createCommandFromDefinition<
 			? {}
 			: {
 					postCommandAction: async (args: string[]): Promise<void> => {
-						const context = buildContext(args);
-						const invocation = currentInvocation || beginInvocation(context);
-						invocation.context = context;
+						const invocation =
+							currentInvocation || beginInvocation(buildContext(args));
+						const context = invocation.context;
 						const setupResult = await invocation.setup;
 						await runInInjectionContext(invocation.injector, () =>
 							definition.postRun.call(
@@ -490,12 +484,11 @@ export function createCommandFromDefinition<
 			);
 		},
 		execute: async (args: string[]): Promise<void> => {
-			const context = buildContext(args);
 			const invocation =
 				currentInvocation && !currentInvocation.hasRun
 					? currentInvocation
-					: beginInvocation(context);
-			invocation.context = context;
+					: beginInvocation(buildContext(args));
+			const context = invocation.context;
 			invocation.hasRun = true;
 
 			const setupResult = await invocation.setup;

test/define-command.ts

@@ -2550,6 +2550,40 @@ describe("defineCommand", () => {
 			assert.strictEqual(injectedInRun, runContext);
 		});
 
+		it("hands one context object to every stage of an invocation", async () => {
+			const testInjector = createTestInjector();
+			const seen: any[] = [];
+
+			const command = createCommandFromDefinition(
+				defineCommand({
+					name: "dctest-command-context-shared",
+					setup: (ctx) => {
+						seen.push(ctx, inject(COMMAND_CONTEXT));
+					},
+					canExecute: (ctx) => {
+						seen.push(ctx, inject(COMMAND_CONTEXT));
+						return true;
+					},
+					run: (ctx) => {
+						seen.push(ctx, inject(COMMAND_CONTEXT));
+					},
+					postRun: (ctx) => {
+						seen.push(ctx, inject(COMMAND_CONTEXT));
+					},
+				}),
+				testInjector,
+			);
+
+			await command.canExecute([]);
+			await command.execute([]);
+			await command.postCommandAction([]);
+
+			assert.lengthOf(seen, 8);
+			for (const context of seen) {
+				assert.strictEqual(context, seen[0]);
+			}
+		});
+
 		it("is scoped to the invocation, so the root injector never sees it", async () => {
 			const testInjector = createTestInjector();