fix(core): prevent injector hang when design:paramtypes is missing

Youmoo · claude · Youmoo · commit 368691c35fa2 · 2026-04-03T14:10:52.000+08:00
When `emitDecoratorMetadata` is unavailable (e.g. esbuild), `@Inject()`
decorators create a sparse array via `SELF_DECLARED_DEPS_METADATA`.
`Array.prototype.map` skips sparse holes, so the `Barrier` in
`resolveConstructorParams` never receives enough signals and hangs
indefinitely.

Use `Array.from()` in `reflectConstructorParams` to convert sparse
arrays into dense arrays with explicit `undefined` values, ensuring
`map` iterates every index and the Barrier resolves correctly.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/packages/core/injector/injector.ts b/packages/core/injector/injector.ts
@@ -444,7 +444,7 @@ export class Injector {
     const selfParams = this.reflectSelfParams<T>(type);
 
     selfParams.forEach(({ index, param }) => (paramtypes[index] = param));
-    return paramtypes;
+    return Array.from(paramtypes);
   }
 
   public reflectOptionalParams<T>(type: Type<T>): any[] {
diff --git a/packages/core/test/injector/injector.spec.ts b/packages/core/test/injector/injector.spec.ts
@@ -744,6 +744,53 @@ describe('Injector', () => {
         { id: 2 },
       );
     });
+
+    it('should not hang when a parameter is missing @Inject and design:paramtypes is absent', async function () {
+      this.timeout(500);
+
+      @Injectable()
+      class CatService {}
+
+      @Injectable()
+      class DogService {}
+
+      @Injectable()
+      class ZooService {
+        constructor(
+          @Inject(CatService) cat: CatService,
+          dog: DogService, // no @Inject — becomes a sparse array hole without design:paramtypes
+          @Inject(CatService) cat2: CatService,
+        ) {}
+      }
+
+      // Simulate missing emitDecoratorMetadata (esbuild).
+      // @Inject writes to SELF_DECLARED_DEPS_METADATA at indices 0 and 2,
+      // so without design:paramtypes the paramtypes array is sparse: [CatService, <hole>, CatService].
+      // Before the fix, Array.map skipped the hole, so the Barrier never reached its
+      // target count and resolveConstructorParams hung forever.
+      Reflect.deleteMetadata('design:paramtypes', ZooService);
+
+      // Register CatService in the module so indices 0 and 2 resolve successfully
+      // and reach signalAndWait() — this is required to reproduce the hang.
+      const container = new NestContainer();
+      const { moduleRef } = (await container.addModule(
+        class TestModule {},
+        [],
+      ))!;
+      moduleRef.addProvider({
+        provide: CatService,
+        useClass: CatService,
+      });
+
+      const wrapper = new InstanceWrapper({ metatype: ZooService });
+
+      const result = await injector
+        .resolveConstructorParams(wrapper, moduleRef, undefined, () => {})
+        .then(() => 'resolved')
+        .catch(() => 'rejected');
+
+      expect(result).to.be.eq('rejected');
+    });
   });
 
   describe('resolveProperties', () => {
@@ -761,6 +808,37 @@ describe('Injector', () => {
     });
   });
 
+  describe('reflectConstructorParams', () => {
+    it('should not produce sparse arrays when design:paramtypes is missing', () => {
+      @Injectable()
+      class CatService {}
+
+      @Injectable()
+      class DogService {}
+
+      @Injectable()
+      class ZooService {
+        constructor(
+          @Inject(CatService) cat: CatService,
+          dog: DogService, // no @Inject
+          @Inject(CatService) cat2: CatService,
+        ) {}
+      }
+
+      // Simulate missing emitDecoratorMetadata (esbuild)
+      Reflect.deleteMetadata('design:paramtypes', ZooService);
+
+      const injector = new Injector();
+      const params = injector.reflectConstructorParams(ZooService);
+
+      // Should be a dense array — no holes
+      expect(Object.keys(params)).to.deep.eq(['0', '1', '2']);
+      // Index 1 should be explicit undefined, not a hole
+      expect(1 in params).to.be.true;
+      expect(params[1]).to.be.undefined;
+    });
+  });
+
   describe('getClassDependencies', () => {
     it('should return an array that consists of deps and optional dep ids', async () => {
       class FixtureDep1 {}

Original file line number	Diff line number	Diff line change
`@@ -444,7 +444,7 @@ export class Injector {`
`444`	`444`	`const selfParams = this.reflectSelfParams<T>(type);`
`445`	`445`
`446`	`446`	`selfParams.forEach(({ index, param }) => (paramtypes[index] = param));`
`447`		`- return paramtypes;`
	`447`	`+ return Array.from(paramtypes);`
`448`	`448`	`}`
`449`	`449`
`450`	`450`	`public reflectOptionalParams<T>(type: Type<T>): any[] {`