From 1da899f2c09ec0cc0c8a527f5f15720ce8ad9dd9 Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:15:09 -0300 Subject: [PATCH 01/15] feat(core): add provider-classifier ensure isClassProvider works as expected --- .../injector/helpers/provider-classifier.ts | 5 +++ .../helpers/provider-classifier.spec.ts | 39 +++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 packages/core/injector/helpers/provider-classifier.ts create mode 100644 packages/core/test/injector/helpers/provider-classifier.spec.ts diff --git a/packages/core/injector/helpers/provider-classifier.ts b/packages/core/injector/helpers/provider-classifier.ts new file mode 100644 index 00000000000..ae26e6866f5 --- /dev/null +++ b/packages/core/injector/helpers/provider-classifier.ts @@ -0,0 +1,5 @@ +import { ClassProvider, Provider } from '@nestjs/common'; + +export function isClassProvider(provider: Provider): boolean { + return Boolean((provider as ClassProvider)?.useClass); +} diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts new file mode 100644 index 00000000000..0c105bd40f4 --- /dev/null +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -0,0 +1,39 @@ +import { ClassProvider } from '@nestjs/common'; +import { expect } from 'chai'; +import { isClassProvider } from '../../../injector/helpers/provider-classifier'; + +describe('provider classifier', () => { + describe('isClassProvider', () => { + it('should return true if useClass is present', () => { + const classProvider: ClassProvider = { + useClass: class TestClass {}, + provide: 'token', + }; + + expect(isClassProvider(classProvider)).to.be.true; + }); + + it('should return false if useClass is undefined', () => { + const classProvider: ClassProvider = { + useClass: undefined, + provide: 'token', + }; + + expect(isClassProvider(classProvider)).to.be.false; + }); + + it('should return false if useClass is not present', () => { + const classProvider = { + provide: 'token', + }; + + expect(isClassProvider(classProvider as ClassProvider)).to.be.false; + }); + + it('should return false if provider is undefined', () => { + const classProvider = undefined; + + expect(isClassProvider(classProvider as ClassProvider)).to.be.false; + }); + }); +}); From ad154067e0221c32f1b5e1bba2eb8f42ba995622 Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:18:55 -0300 Subject: [PATCH 02/15] feat(core): add provider classifier method ensure isValueProvider returns true when useValue is defined --- .../injector/helpers/provider-classifier.ts | 6 +++++- .../helpers/provider-classifier.spec.ts | 18 ++++++++++++++++-- 2 files changed, 21 insertions(+), 3 deletions(-) diff --git a/packages/core/injector/helpers/provider-classifier.ts b/packages/core/injector/helpers/provider-classifier.ts index ae26e6866f5..572b2957d24 100644 --- a/packages/core/injector/helpers/provider-classifier.ts +++ b/packages/core/injector/helpers/provider-classifier.ts @@ -1,5 +1,9 @@ -import { ClassProvider, Provider } from '@nestjs/common'; +import { ClassProvider, Provider, ValueProvider } from '@nestjs/common'; export function isClassProvider(provider: Provider): boolean { return Boolean((provider as ClassProvider)?.useClass); } + +export function isValueProvider(provider: Provider): boolean { + return Boolean((provider as ValueProvider).useValue); +} diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index 0c105bd40f4..3836f137e2e 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -1,6 +1,9 @@ -import { ClassProvider } from '@nestjs/common'; +import { ClassProvider, ValueProvider } from '@nestjs/common'; import { expect } from 'chai'; -import { isClassProvider } from '../../../injector/helpers/provider-classifier'; +import { + isClassProvider, + isValueProvider, +} from '../../../injector/helpers/provider-classifier'; describe('provider classifier', () => { describe('isClassProvider', () => { @@ -36,4 +39,15 @@ describe('provider classifier', () => { expect(isClassProvider(classProvider as ClassProvider)).to.be.false; }); }); + + describe('isValueProvider', () => { + it('should return true if useValue is not undefined', () => { + const valueProvider: ValueProvider = { + useValue: 'value', + provide: 'token', + }; + + expect(isValueProvider(valueProvider)).to.be.true; + }); + }); }); From 6b9ed77cdaf4f4d1817391e265c26aa5499236a1 Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:19:59 -0300 Subject: [PATCH 03/15] test(core): add provider classifier test ensure useValue returns false for undefined values --- .../test/injector/helpers/provider-classifier.spec.ts | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index 3836f137e2e..8760c826357 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -49,5 +49,14 @@ describe('provider classifier', () => { expect(isValueProvider(valueProvider)).to.be.true; }); + + it('should return false if useValue is undefined', () => { + const valueProvider: ValueProvider = { + useValue: undefined, + provide: 'token', + }; + + expect(isValueProvider(valueProvider)).to.be.false; + }); }); }); From 7b759d52e6d9e4ce4a56c000a7085e3aaea9475f Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:21:06 -0300 Subject: [PATCH 04/15] test(core): add provider classifier test ensure isValueProvider returns false when useValue is not present --- .../test/injector/helpers/provider-classifier.spec.ts | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index 8760c826357..41326210d85 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -58,5 +58,13 @@ describe('provider classifier', () => { expect(isValueProvider(valueProvider)).to.be.false; }); + + it('should return false if useValue is not present', () => { + const valueProvider = { + provide: 'token', + }; + + expect(isValueProvider(valueProvider as ValueProvider)).to.be.false; + }); }); }); From 57cd765bb1502b2514fb6887824b97ecbc2f5d0c Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:22:58 -0300 Subject: [PATCH 05/15] feat(core): finish is value provider ensure isValueProvider returns false when given provider is undefined --- packages/core/injector/helpers/provider-classifier.ts | 2 +- .../core/test/injector/helpers/provider-classifier.spec.ts | 6 ++++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/packages/core/injector/helpers/provider-classifier.ts b/packages/core/injector/helpers/provider-classifier.ts index 572b2957d24..94aea40a37a 100644 --- a/packages/core/injector/helpers/provider-classifier.ts +++ b/packages/core/injector/helpers/provider-classifier.ts @@ -5,5 +5,5 @@ export function isClassProvider(provider: Provider): boolean { } export function isValueProvider(provider: Provider): boolean { - return Boolean((provider as ValueProvider).useValue); + return Boolean((provider as ValueProvider)?.useValue); } diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index 41326210d85..adb1cd5a612 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -66,5 +66,11 @@ describe('provider classifier', () => { expect(isValueProvider(valueProvider as ValueProvider)).to.be.false; }); + + it('should return false if provider is undefined', () => { + const valueProvider = undefined; + + expect(isValueProvider(valueProvider as ValueProvider)).to.be.false; + }); }); }); From d1ec1e2640ab80998985054fdaf758fe2765656d Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:29:16 -0300 Subject: [PATCH 06/15] feat(core): add method to verify factory provider ensure isFactoryProvider returns true when useFactory is present --- .../core/injector/helpers/provider-classifier.ts | 11 ++++++++++- .../injector/helpers/provider-classifier.spec.ts | 14 +++++++++++++- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/packages/core/injector/helpers/provider-classifier.ts b/packages/core/injector/helpers/provider-classifier.ts index 94aea40a37a..820cc6fb139 100644 --- a/packages/core/injector/helpers/provider-classifier.ts +++ b/packages/core/injector/helpers/provider-classifier.ts @@ -1,4 +1,9 @@ -import { ClassProvider, Provider, ValueProvider } from '@nestjs/common'; +import { + ClassProvider, + FactoryProvider, + Provider, + ValueProvider, +} from '@nestjs/common'; export function isClassProvider(provider: Provider): boolean { return Boolean((provider as ClassProvider)?.useClass); @@ -7,3 +12,7 @@ export function isClassProvider(provider: Provider): boolean { export function isValueProvider(provider: Provider): boolean { return Boolean((provider as ValueProvider)?.useValue); } + +export function isFactoryProvider(provider: Provider): boolean { + return Boolean((provider as FactoryProvider).useFactory); +} diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index adb1cd5a612..5b6e2ca6af6 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -1,7 +1,8 @@ -import { ClassProvider, ValueProvider } from '@nestjs/common'; +import { ClassProvider, FactoryProvider, ValueProvider } from '@nestjs/common'; import { expect } from 'chai'; import { isClassProvider, + isFactoryProvider, isValueProvider, } from '../../../injector/helpers/provider-classifier'; @@ -73,4 +74,15 @@ describe('provider classifier', () => { expect(isValueProvider(valueProvider as ValueProvider)).to.be.false; }); }); + + describe('isFactoryProvider', () => { + it('should return true if useFactory is present', () => { + const factoryProvider: FactoryProvider = { + provide: 'token', + useFactory: () => {}, + }; + + expect(isFactoryProvider(factoryProvider)).to.be.true; + }); + }); }); From a052e0cac27f4fb3bc526e2b840da27a4b63dc53 Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:32:46 -0300 Subject: [PATCH 07/15] test(core): add provider classifier test case ensure isFactoryProvider returns false when useFactory is not present --- .../test/injector/helpers/provider-classifier.spec.ts | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index 5b6e2ca6af6..ea4ad88bb29 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -84,5 +84,13 @@ describe('provider classifier', () => { expect(isFactoryProvider(factoryProvider)).to.be.true; }); + + it('should return false if useFactory is not present', () => { + const factoryProvider = { + provide: 'token', + }; + + expect(isFactoryProvider(factoryProvider as FactoryProvider)).to.be.false; + }); }); }); From 75b45775bf538db28dc1d775643ad93fcc05a39c Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:33:31 -0300 Subject: [PATCH 08/15] test(core): add provider classifier test case ensure isFactoryProvider returns false when useFactory is undefined --- .../test/injector/helpers/provider-classifier.spec.ts | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index ea4ad88bb29..e3d9bab915e 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -92,5 +92,14 @@ describe('provider classifier', () => { expect(isFactoryProvider(factoryProvider as FactoryProvider)).to.be.false; }); + + it('should return false if useFactory is undefined', () => { + const factoryProvider: FactoryProvider = { + provide: 'token', + useFactory: undefined, + }; + + expect(isFactoryProvider(factoryProvider as FactoryProvider)).to.be.false; + }); }); }); From aa2ee95f546065eeed2b7b412cfe338f44c314f5 Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:39:05 -0300 Subject: [PATCH 09/15] feat(core): add falsy values handling ensure isValueProvider returns true for falsy values --- .../injector/helpers/provider-classifier.ts | 4 ++- .../helpers/provider-classifier.spec.ts | 27 +++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/packages/core/injector/helpers/provider-classifier.ts b/packages/core/injector/helpers/provider-classifier.ts index 820cc6fb139..ab8264dbbd6 100644 --- a/packages/core/injector/helpers/provider-classifier.ts +++ b/packages/core/injector/helpers/provider-classifier.ts @@ -4,13 +4,15 @@ import { Provider, ValueProvider, } from '@nestjs/common'; +import { isUndefined } from '@nestjs/common/utils/shared.utils'; export function isClassProvider(provider: Provider): boolean { return Boolean((provider as ClassProvider)?.useClass); } export function isValueProvider(provider: Provider): boolean { - return Boolean((provider as ValueProvider)?.useValue); + const providerValue = (provider as ValueProvider)?.useValue; + return !isUndefined(providerValue); } export function isFactoryProvider(provider: Provider): boolean { diff --git a/packages/core/test/injector/helpers/provider-classifier.spec.ts b/packages/core/test/injector/helpers/provider-classifier.spec.ts index e3d9bab915e..091600bfbd8 100644 --- a/packages/core/test/injector/helpers/provider-classifier.spec.ts +++ b/packages/core/test/injector/helpers/provider-classifier.spec.ts @@ -51,6 +51,33 @@ describe('provider classifier', () => { expect(isValueProvider(valueProvider)).to.be.true; }); + it('should return true if useValue is "false"', () => { + const valueProvider: ValueProvider = { + useValue: false, + provide: 'token', + }; + + expect(isValueProvider(valueProvider)).to.be.true; + }); + + it('should return true if useValue is "null"', () => { + const valueProvider: ValueProvider = { + useValue: null, + provide: 'token', + }; + + expect(isValueProvider(valueProvider)).to.be.true; + }); + + it('should return true if useValue is an empty string', () => { + const valueProvider: ValueProvider = { + useValue: null, + provide: '', + }; + + expect(isValueProvider(valueProvider)).to.be.true; + }); + it('should return false if useValue is undefined', () => { const valueProvider: ValueProvider = { useValue: undefined, From 62f1fa3a7970ed5b1547ef656ab9d94ed389ac20 Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:42:35 -0300 Subject: [PATCH 10/15] refactor(core): use provider classifier refactor instance-wrapper to use provider classifier methods --- packages/core/injector/instance-wrapper.ts | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/packages/core/injector/instance-wrapper.ts b/packages/core/injector/instance-wrapper.ts index 2357ac1988c..7fb59a6ad24 100644 --- a/packages/core/injector/instance-wrapper.ts +++ b/packages/core/injector/instance-wrapper.ts @@ -13,6 +13,11 @@ import { } from '@nestjs/common/utils/shared.utils'; import { iterate } from 'iterare'; import { STATIC_CONTEXT } from './constants'; +import { + isClassProvider, + isFactoryProvider, + isValueProvider, +} from './helpers/provider-classifier'; import { InstanceToken, Module } from './module'; export const INSTANCE_METADATA_SYMBOL = Symbol.for('instance_metadata:cache'); @@ -384,7 +389,7 @@ export class InstanceWrapper { } public mergeWith(provider: Provider) { - if (!isUndefined((provider as ValueProvider).useValue)) { + if (isValueProvider(provider)) { this.metatype = null; this.inject = null; this.scope = Scope.DEFAULT; @@ -394,10 +399,10 @@ export class InstanceWrapper { isResolved: true, isPending: false, }); - } else if ((provider as ClassProvider).useClass) { + } else if (isClassProvider(provider)) { this.inject = null; this.metatype = (provider as ClassProvider).useClass; - } else if ((provider as FactoryProvider).useFactory) { + } else if (isFactoryProvider(provider)) { this.metatype = (provider as FactoryProvider).useFactory; this.inject = (provider as FactoryProvider).inject || []; } From 2a7fc84470ccdf64bb4879440c70524be217f4bb Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:54:21 -0300 Subject: [PATCH 11/15] test(core): add instance wrapper test ensure mergeWith handles ValueProviders --- .../core/test/injector/instance-wrapper.spec.ts | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/packages/core/test/injector/instance-wrapper.spec.ts b/packages/core/test/injector/instance-wrapper.spec.ts index 6b0e1734cdf..88bcb489735 100644 --- a/packages/core/test/injector/instance-wrapper.spec.ts +++ b/packages/core/test/injector/instance-wrapper.spec.ts @@ -434,4 +434,20 @@ describe('InstanceWrapper', () => { }); }); }); + + describe('mergeWith', () => { + describe('when provider is a ValueProvider', () => { + it('should provide the given value in the STATIC_CONTEXT', () => { + const wrapper = new InstanceWrapper(); + wrapper.mergeWith({ + useValue: 'value', + provide: 'token', + }); + + expect( + wrapper.getInstanceByContextId(STATIC_CONTEXT).instance, + ).to.be.equal('value'); + }); + }); + }); }); From 7696f43a075e8db6e7c26e479b63978e453103ab Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 16:56:33 -0300 Subject: [PATCH 12/15] test(core): add instance wrapper test ensure mergeWith handles ClassProviders --- .../core/test/injector/instance-wrapper.spec.ts | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/packages/core/test/injector/instance-wrapper.spec.ts b/packages/core/test/injector/instance-wrapper.spec.ts index 88bcb489735..512900460e6 100644 --- a/packages/core/test/injector/instance-wrapper.spec.ts +++ b/packages/core/test/injector/instance-wrapper.spec.ts @@ -449,5 +449,18 @@ describe('InstanceWrapper', () => { ).to.be.equal('value'); }); }); + + describe('when provider is a ClassProvider', () => { + it('should alter the instance wrapper metatype with the given class', () => { + const wrapper = new InstanceWrapper(); + + wrapper.mergeWith({ + useClass: TestClass, + provide: 'token', + }); + + expect(wrapper.metatype).to.be.eql(TestClass); + }); + }); }); }); From b0d735d90bb31dc014b5bf15b902768cf75ebfa5 Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 17:01:02 -0300 Subject: [PATCH 13/15] test(core): add instance wrapper test ensure mergeWith handles FactoryProviders with injected dependencies --- .../test/injector/instance-wrapper.spec.ts | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/packages/core/test/injector/instance-wrapper.spec.ts b/packages/core/test/injector/instance-wrapper.spec.ts index 512900460e6..6b5dd2d97e4 100644 --- a/packages/core/test/injector/instance-wrapper.spec.ts +++ b/packages/core/test/injector/instance-wrapper.spec.ts @@ -462,5 +462,25 @@ describe('InstanceWrapper', () => { expect(wrapper.metatype).to.be.eql(TestClass); }); }); + + describe('when provider is a FactoryProvider', () => { + describe('and it has injected dependencies', () => { + it('should alter the instance wrapper metatype and inject attributes with the given values', () => { + const wrapper = new InstanceWrapper(); + + const factory = (_dependency1, _dependency2) => {}; + const injectedDependencies = ['dependency1', 'dependency2']; + + wrapper.mergeWith({ + provide: 'token', + useFactory: factory, + inject: injectedDependencies, + }); + + expect(wrapper.metatype).to.be.eql(factory); + expect(wrapper.inject).to.be.eq(injectedDependencies); + }); + }); + }); }); }); From a2f4b342e228c6cbf59e1097a2b0299a8c9d190e Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Mon, 11 Jul 2022 17:02:48 -0300 Subject: [PATCH 14/15] test(core): add instance wrapper test ensure mergeWith handles FactoryProviders with no depencies --- .../core/test/injector/instance-wrapper.spec.ts | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/packages/core/test/injector/instance-wrapper.spec.ts b/packages/core/test/injector/instance-wrapper.spec.ts index 6b5dd2d97e4..d5ab67c15bc 100644 --- a/packages/core/test/injector/instance-wrapper.spec.ts +++ b/packages/core/test/injector/instance-wrapper.spec.ts @@ -468,7 +468,7 @@ describe('InstanceWrapper', () => { it('should alter the instance wrapper metatype and inject attributes with the given values', () => { const wrapper = new InstanceWrapper(); - const factory = (_dependency1, _dependency2) => {}; + const factory = (_dependency1: any, _dependency2: any) => {}; const injectedDependencies = ['dependency1', 'dependency2']; wrapper.mergeWith({ @@ -481,6 +481,21 @@ describe('InstanceWrapper', () => { expect(wrapper.inject).to.be.eq(injectedDependencies); }); }); + + describe('and it has no injected dependencies', () => { + it('should alter the instance wrapper metatype with the given values', () => { + const wrapper = new InstanceWrapper(); + const factory = (_dependency1: any, _dependency2: any) => {}; + + wrapper.mergeWith({ + provide: 'token', + useFactory: factory, + }); + + expect(wrapper.metatype).to.be.eql(factory); + expect(wrapper.inject).to.be.eql([]); + }); + }); }); }); }); From 4c16d2010c7172164a3be333c635c6f47dec933a Mon Sep 17 00:00:00 2001 From: Thiago Martins Date: Tue, 12 Jul 2022 10:03:40 -0300 Subject: [PATCH 15/15] refactor(core): remove providers type assertions change provider classifier functions to work as type guards --- .../core/injector/helpers/provider-classifier.ts | 14 ++++++++++---- packages/core/injector/instance-wrapper.ts | 9 +++++---- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/packages/core/injector/helpers/provider-classifier.ts b/packages/core/injector/helpers/provider-classifier.ts index ab8264dbbd6..b883a4ea83b 100644 --- a/packages/core/injector/helpers/provider-classifier.ts +++ b/packages/core/injector/helpers/provider-classifier.ts @@ -6,15 +6,21 @@ import { } from '@nestjs/common'; import { isUndefined } from '@nestjs/common/utils/shared.utils'; -export function isClassProvider(provider: Provider): boolean { - return Boolean((provider as ClassProvider)?.useClass); +export function isClassProvider( + provider: Provider, +): provider is ClassProvider { + return Boolean((provider as ClassProvider)?.useClass); } -export function isValueProvider(provider: Provider): boolean { +export function isValueProvider( + provider: Provider, +): provider is ValueProvider { const providerValue = (provider as ValueProvider)?.useValue; return !isUndefined(providerValue); } -export function isFactoryProvider(provider: Provider): boolean { +export function isFactoryProvider( + provider: Provider, +): provider is FactoryProvider { return Boolean((provider as FactoryProvider).useFactory); } diff --git a/packages/core/injector/instance-wrapper.ts b/packages/core/injector/instance-wrapper.ts index 7fb59a6ad24..773a9b4f50b 100644 --- a/packages/core/injector/instance-wrapper.ts +++ b/packages/core/injector/instance-wrapper.ts @@ -392,19 +392,20 @@ export class InstanceWrapper { if (isValueProvider(provider)) { this.metatype = null; this.inject = null; + this.scope = Scope.DEFAULT; this.setInstanceByContextId(STATIC_CONTEXT, { - instance: (provider as ValueProvider).useValue, + instance: provider.useValue, isResolved: true, isPending: false, }); } else if (isClassProvider(provider)) { this.inject = null; - this.metatype = (provider as ClassProvider).useClass; + this.metatype = provider.useClass; } else if (isFactoryProvider(provider)) { - this.metatype = (provider as FactoryProvider).useFactory; - this.inject = (provider as FactoryProvider).inject || []; + this.metatype = provider.useFactory; + this.inject = provider.inject || []; } }