How does NestJS know which class to inject in what order?

[stiff river]

E.g.

@Controller()
export class AppController {
  constructor(
    private readonly appService: AppService,
    private readonly playerService: PlayerService
  ) {}
}

The type is only specified as a TypeScript type which goes away at runtime, is there some custom compilation/additional parsing of typescript going on? Or something I'm missing?

I saw the javascript starter using @Dependencies to specify the types of deps, so I'm assuming there's a form of custom compilation/parsing typescript going on

[manic pond]

Under the hood, nestjs uses reflection metadata to handle the dependency injection.
I learned it by watching this video
https://www.youtube.com/watch?v=jo-1EUxMmxc

[stiff river]

Yeah I understand how the decorator part works, but you have no knowledge of which type to inject in what order because that's not a thing in JavaScript, hence the need for the @Dependencies decorator. But in TypeScript you have compile time only type annotations which nestjs seems to somehow figure out either by parsing your source files or having a custom compilation step to extract that type

[feral bluff]

This has to do with how class decorators expose the design:paramtypes metadata for the constructor which includes both the type and the index of each parameter in the constructor. Next time you compile your NestJS project, open up a controller or service .js file and look towards the bottom for the metadata

[stiff river]

that's what emitDecoratorMetadata does?

[feral bluff]

Yes

[stiff river]

I see now, TIL thank you :)

[feral bluff]

I've got a PR for the docs that starts to go into depth on this: https://github.com/nestjs/docs.nestjs.com/pull/2481

This is the generally interesting part here:

let Foo = class Foo {
    constructor(foo) {
        this.foo = foo;
    }
};
Foo = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [String])
], Foo);
export { Foo };
let Bar = class Bar {
    constructor(bar) {
        this.bar = bar;
    }
};
Bar = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [String])
], Bar);
export { Bar };
let FooBar = class FooBar {
    constructor(foo, bar) {
        this.foo = foo;
        this.bar = bar;
    }
};
FooBar = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [Foo, Bar])
], FooBar);
export { FooBar };

[exotic loom]

Thank you for the doc! I made a test project and found two questions:

1. @Injectable() is not required to generate __metadata()
2. It seems the injection order is defined by providers property in module decorator rather than order of array in __metadata()
   https://stackblitz.com/edit/nestjs-typescript-starter-q19guh