is not Injectable decorator required in providers? - nestjs

Question

I'm studying NestJS with a sample app.
https://github.com/nestjs/nest/tree/master/sample/12-graphql-schema-first
However, what I am curious about is that even if the service does not have an injectable decorator, it can be registered as a provider of the module, and the constructor of other providers can use the registered provider without the injectable decorator.
Actually, I removed the injectable decorator from src/cats/cats.service.ts in the example above. But it works fine.
Even without the Injectable decorator, the same object was passed to the provider's constructor.
Why is the injectable decorator necessary?

Answer 1

injectable is to allow injecting providers in that class. If you don't have anything to inject, you don't need that decorator. But I'd suggest you to always use it.
For detailed info on this topic, read this: https://github.com/nestjs/docs.nestjs.com/pull/2481

Answer 2

The answer here is: "it depends".
If a provider has no injected dependencies, then technically, no you don't need the #Injectable() decorator. What that decorator is doing under the hood is forcing Typescript to emit constructor parameter metadata. Nest will read that metadata at runtime to know what is injected into the provider. This PR goes into more depth on the #Injectable() decorator itself
If we have the following classes
#Injectable()
export class Foo {
constructor(private readonly foo: string) {}
}
#Injectable()
export class Bar {
constructor(private readonly bar: string) {}
}
#Injectable()
export class FooBar {
constructor(private readonly foo: Foo, private readonly bar: Bar) {}
}
Then we get a compiled output like this
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
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 };
The __metadata('design:paramtypes', []) is what Nest eventually reads, and matches to the DI container injection tokens