refactor: reach the process-wide injector through getInjector()

Internal code no longer reads global.$injector: the two cycle-bound
sites (the deprecation tracer's logger fallback and @hook's last-resort
lookup) go through a getInjector() accessor required at call time. The
global property remains write-only from the CLI's side - it exists as
the published surface for extensions and hooks.

Author: edusperoni

lib/common/deprecation.ts

@@ -80,11 +80,13 @@ function getDeprecationStage(): DeprecationStage {
 
 function tryResolveGlobalLogger(): IDeprecationLogger | null {
 	try {
-		const globalInjector = (<any>global).$injector;
-		if (!globalInjector) {
+		// Required at call time: yok imports this module, so a static import
+		// would be a cycle. Every reporting site already runs with yok loaded.
+		const injector = require("./yok").getInjector();
+		if (!injector) {
 			return null;
 		}
-		return globalInjector.resolve("logger");
+		return injector.resolve("logger");
 	} catch (err) {
 		return null;
 	}

lib/common/helpers.ts

@@ -567,10 +567,11 @@ export function hook(commandName: string) {
 	function getHooksService(self: any): IHooksService {
 		let hooksService: IHooksService = self.$hooksService;
 		if (!hooksService) {
-			// The global injector must stay the LAST resort: tests stub
+			// The process-wide injector must stay the LAST resort: tests stub
 			// self.$hooksService / self.$injector, and a class migrated off
-			// property injection has neither — only then may the global be used.
-			const injector = self.$injector || (<any>global).$injector;
+			// property injection has neither — only then may it be used. It is
+			// required at call time because yok imports this module (cycle).
+			const injector = self.$injector || require("./yok").getInjector();
 			if (!injector) {
 				throw Error(
 					"Type with hooks needs to have either $hooksService or $injector injected.",

lib/common/yok.ts

@@ -589,6 +589,17 @@ if (!(<any>global).$injector) {
 	injector = (<any>global).$injector;
 }
 
+/**
+ * Accessor for the process-wide facade, for code that cannot receive the
+ * injector through DI or a static import (import cycles, decorator bodies).
+ * Prefer inject(Injector) in an injection context; prefer a constructor
+ * dependency in services. Never read global.$injector directly — the global
+ * exists only as the published legacy surface for extensions and hooks.
+ */
+export function getInjector(): IInjector {
+	return injector;
+}
+
 /**
  * @deprecated Global-singleton wiring for the legacy facade; new code receives
  * the container via inject(Injector) instead of a process-wide global.

test/compat/legacy-hooks.ts

@@ -2,7 +2,7 @@ import { assert } from "chai";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { Yok } from "../../lib/common/yok";
+import { Yok, getInjector, setGlobalInjector } from "../../lib/common/yok";
 import { HooksService } from "../../lib/common/services/hooks-service";
 import { hook } from "../../lib/common/helpers";
 import { IInjector } from "../../lib/common/definitions/yok";
@@ -301,15 +301,14 @@ describe("legacy hook contract", () => {
 			}
 		}
 
-		const globalAny = <any>global;
-		const previousInjector = globalAny.$injector;
-		globalAny.$injector = testInjector;
+		const previousInjector = getInjector();
+		setGlobalInjector(testInjector);
 		try {
 			const result = await new Subject().doWork();
 			assert.equal(result, "ok");
 			assert.isTrue(capture.ran);
 		} finally {
-			globalAny.$injector = previousInjector;
+			setGlobalInjector(previousInjector);
 		}
 	});
 
@@ -329,19 +328,18 @@ describe("legacy hook contract", () => {
 			}
 		}
 
-		const globalAny = <any>global;
-		const previousInjector = globalAny.$injector;
-		globalAny.$injector = {
+		const previousInjector = getInjector();
+		setGlobalInjector(<any>{
 			resolve: () => {
-				throw new Error("global injector must be the last resort");
+				throw new Error("the process-wide injector must be the last resort");
 			},
-		};
+		});
 		try {
 			const result = await new Subject().doWork();
 			assert.equal(result, "ok");
 			assert.isTrue(capture.ran);
 		} finally {
-			globalAny.$injector = previousInjector;
+			setGlobalInjector(previousInjector);
 		}
 	});
 });

test/deprecation.ts

@@ -1,5 +1,5 @@
 import { assert } from "chai";
-import { Yok } from "../lib/common/yok";
+import { Yok, getInjector, setGlobalInjector } from "../lib/common/yok";
 import {
 	reportDeprecation,
 	clearReportedDeprecations,
@@ -59,31 +59,29 @@ describe("deprecation tracer", () => {
 		);
 	});
 
-	it("falls back to the global injector's logger when none is passed", () => {
-		const globalAny = <any>global;
-		const previousInjector = globalAny.$injector;
+	it("falls back to the process-wide injector's logger when none is passed", () => {
+		const previousInjector = getInjector();
 		const freshInjector = new Yok();
 		const freshLogger = new LoggerStub();
 		freshInjector.register("logger", freshLogger);
-		globalAny.$injector = freshInjector;
+		setGlobalInjector(freshInjector);
 
 		try {
 			reportDeprecation({ api: "test.global-logger" });
 			assert.include(freshLogger.traceOutput, "test.global-logger");
 		} finally {
-			globalAny.$injector = previousInjector;
+			setGlobalInjector(previousInjector);
 		}
 	});
 
 	it("drops the report silently when no logger is resolvable", () => {
-		const globalAny = <any>global;
-		const previousInjector = globalAny.$injector;
-		globalAny.$injector = undefined;
+		const previousInjector = getInjector();
+		setGlobalInjector(new Yok());
 
 		try {
 			assert.doesNotThrow(() => reportDeprecation({ api: "test.no-logger" }));
 		} finally {
-			globalAny.$injector = previousInjector;
+			setGlobalInjector(previousInjector);
 		}
 	});
 });