feat(core): support injection token values to config provider (#3277)

Author: griest024

libs/core/src/injection-tokens/config.factory.spec.ts

@@ -1,3 +1,5 @@
+import { InjectionToken } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
 import { faker } from '@faker-js/faker/locale/en_US';
 
 import { DaffConfigInjectionToken } from '@daffodil/core';
@@ -11,13 +13,16 @@ interface Config {
 
 describe('@daffodil/core | createConfigInjectionToken', () => {
   let name: string;
-  let value: number;
+  let value: Partial<Config>;
   let defaultConfig: Config;
 
   let result: DaffConfigInjectionToken<Config>;
 
   beforeEach(() => {
     name = faker.random.word();
+    value = {
+      field: faker.random.word(),
+    };
     defaultConfig = {
       field: faker.random.word(),
       other: faker.random.word(),
@@ -29,13 +34,39 @@ describe('@daffodil/core | createConfigInjectionToken', () => {
     expect(result.token.toString()).toContain(name);
   });
 
-  it('should return a provider that spreads in passed values with the default', () => {
-    const val = faker.random.word();
-    const res = result.provider({
-      field: val,
+  describe('when the provided value is an injection token', () => {
+    let token: InjectionToken<Partial<Config>>;
+    let defaultToken: InjectionToken<Config>;
+
+    beforeEach(() => {
+      token = new InjectionToken('test');
+      defaultToken = new InjectionToken('default');
+      TestBed.configureTestingModule({
+        providers: [
+          {
+            provide: token,
+            useValue: value,
+          },
+          {
+            provide: defaultToken,
+            useValue: defaultConfig,
+          },
+        ],
+      });
     });
+
+    it('should return a provider that spreads in passed values with the default', () => {
+      const res = result.provider(token);
+      expect(res.provide).toEqual(result.token);
+      expect(TestBed.runInInjectionContext<Config>(<any>res.useFactory).field).toEqual(value.field);
+      expect(TestBed.runInInjectionContext<Config>(<any>res.useFactory).other).toEqual(defaultConfig.other);
+    });
+  });
+
+  it('should return a provider that spreads in passed values with the default', () => {
+    const res = result.provider(value);
     expect(res.provide).toEqual(result.token);
-    expect(res.useValue.field).toEqual(val);
-    expect(res.useValue.other).toEqual(defaultConfig.other);
+    expect(TestBed.runInInjectionContext<Config>(<any>res.useFactory).field).toEqual(value.field);
+    expect(TestBed.runInInjectionContext<Config>(<any>res.useFactory).other).toEqual(defaultConfig.other);
   });
 });

libs/core/src/injection-tokens/config.factory.ts

@@ -1,4 +1,7 @@
-import { InjectionToken } from '@angular/core';
+import {
+  inject,
+  InjectionToken,
+} from '@angular/core';
 
 import { DaffConfigInjectionToken } from './config.type';
 import {
@@ -12,23 +15,23 @@ import {
  * See {@link DaffConfigInjectionToken}.
  */
 export const createConfigInjectionToken = <T = unknown>(
-  defaultConfig: T,
+  defaultConfig: T | InjectionToken<T>,
   desc: TokenDesc<T>,
   options?: Partial<TokenOptions<T>>,
 ): DaffConfigInjectionToken<T> => {
   const token = new InjectionToken<T>(
     desc,
     {
-      factory: () => defaultConfig,
+      factory: () => defaultConfig instanceof InjectionToken ? inject(defaultConfig) : defaultConfig,
       ...options,
     },
   );
-  const provider = <R extends T = T>(config: Partial<R>) => ({
+  const provider = <R extends T = T>(config: Partial<R> | InjectionToken<Partial<R>>) => ({
     provide: token,
-    useValue: {
-      ...defaultConfig,
-      ...config,
-    },
+    useFactory: () => ({
+      ...(defaultConfig instanceof InjectionToken ? inject(defaultConfig) : defaultConfig),
+      ...(config instanceof InjectionToken ? inject(config) : config),
+    }),
   });
 
   return {

libs/core/src/injection-tokens/config.type.ts

@@ -1,6 +1,6 @@
 import {
   InjectionToken,
-  ValueProvider,
+  FactoryProvider,
 } from '@angular/core';
 
 /**
@@ -17,6 +17,7 @@ export interface DaffConfigInjectionToken<T = unknown> {
    * A helper function to provide a value to the token.
    * It will shallow merge the passed config with the default config
    * with the passed config keys taking precedence.
+   * An injection token containing a config may also be passed.
    */
-  provider: <R extends T = T>(config: Partial<R>) => ValueProvider;
+  provider: <R extends T = T>(config: Partial<R> | InjectionToken<Partial<R>>) => FactoryProvider;
 }