feat: nestjs async factory

Signed-off-by: imranismail <hey@imranismail.dev>

Author: imranismail

package-lock.json

@@ -1,13 +1,6 @@
+import type { DynamicModule, Provider as NestProvider } from '@nestjs/common';
+import { Module, ExecutionContext, ConfigurableModuleBuilder } from '@nestjs/common';
 import type {
-  DynamicModule,
-  FactoryProvider as NestFactoryProvider,
-  ValueProvider,
-  ClassProvider,
-  Provider as NestProvider,
-} from '@nestjs/common';
-import { Module, ExecutionContext } from '@nestjs/common';
-import type {
-  Client,
   Hook,
   Provider,
   EvaluationContext,
@@ -22,69 +15,121 @@ import { APP_INTERCEPTOR } from '@nestjs/core';
 import { EvaluationContextInterceptor } from './evaluation-context-interceptor';
 import { ShutdownService } from './shutdown.service';
 
+export const OPEN_FEATURE_INIT_TOKEN = 'OPEN_FEATURE_INIT';
+
+export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } =
+  new ConfigurableModuleBuilder<OpenFeatureModuleOptions>()
+    .setClassMethodName('forRoot')
+    .setExtras<OpenFeatureModuleExtras>(
+      { isGlobal: true, useGlobalInterceptor: true, domains: [] },
+      (definition, extras) => ({
+        ...definition,
+        global: extras.isGlobal,
+      }),
+    )
+    .build();
+
 /**
  * OpenFeatureModule is a NestJS wrapper for OpenFeature Server-SDK.
  */
 @Module({})
-export class OpenFeatureModule {
-  static forRoot({ useGlobalInterceptor = true, ...options }: OpenFeatureModuleOptions): DynamicModule {
-    OpenFeature.setTransactionContextPropagator(new AsyncLocalStorageTransactionContextPropagator());
+export class OpenFeatureModule extends ConfigurableModuleClass {
+  static forRoot(options: typeof OPTIONS_TYPE): DynamicModule {
+    const baseDynamicModule = super.forRoot(options);
+    return this.buildModule(baseDynamicModule, options);
+  }
 
-    if (options.logger) {
-      OpenFeature.setLogger(options.logger);
-    }
+  static forRootAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {
+    const baseDynamicModule = super.forRootAsync(options);
+    return this.buildModule(baseDynamicModule, options);
+  }
 
-    if (options.hooks) {
-      OpenFeature.addHooks(...options.hooks);
-    }
+  private static buildModule(
+    baseDynamicModule: DynamicModule,
+    options: typeof ASYNC_OPTIONS_TYPE | typeof OPTIONS_TYPE,
+  ): DynamicModule {
+    const { useGlobalInterceptor, domains } = options;
 
-    options.handlers?.forEach(([event, handler]) => {
-      OpenFeature.addHandler(event, handler);
-    });
+    const providers: NestProvider[] = [
+      ...(baseDynamicModule.providers || []),
+      ShutdownService,
+      // Initialize OpenFeature when options become available,
+      {
+        provide: OPEN_FEATURE_INIT_TOKEN,
+        inject: [MODULE_OPTIONS_TOKEN],
+        useFactory: async (options: OpenFeatureModuleOptions) => {
+          OpenFeature.setTransactionContextPropagator(new AsyncLocalStorageTransactionContextPropagator());
+
+          if (options.logger) {
+            OpenFeature.setLogger(options.logger);
+          }
+
+          if (options.hooks) {
+            OpenFeature.addHooks(...options.hooks);
+          }
+
+          options.handlers?.forEach(([event, handler]) => {
+            OpenFeature.addHandler(event, handler);
+          });
 
-    const clientValueProviders: NestFactoryProvider<Client>[] = [
+          if (options.defaultProvider) {
+            await OpenFeature.setProviderAndWait(options.defaultProvider);
+          }
+
+          if (options.providers) {
+            await Promise.all(
+              Object.entries(options.providers).map(([domain, provider]) =>
+                OpenFeature.setProviderAndWait(domain, provider),
+              ),
+            );
+          }
+
+          return options;
+        },
+      },
+      // Default client
       {
         provide: getOpenFeatureClientToken(),
+        inject: [OPEN_FEATURE_INIT_TOKEN],
         useFactory: () => OpenFeature.getClient(),
       },
+      // Context factory
+      {
+        provide: ContextFactoryToken,
+        inject: [OPEN_FEATURE_INIT_TOKEN],
+        useFactory: (options: OpenFeatureModuleOptions) => options.contextFactory,
+      },
     ];
 
-    if (options?.defaultProvider) {
-      OpenFeature.setProvider(options.defaultProvider);
-    }
+    // Domain-scoped clients from extras
+    const domainClientTokens = domains?.map((domain: string) => {
+      const token = getOpenFeatureClientToken(domain);
 
-    if (options?.providers) {
-      Object.entries(options.providers).forEach(([domain, provider]) => {
-        OpenFeature.setProvider(domain, provider);
-        clientValueProviders.push({
-          provide: getOpenFeatureClientToken(domain),
-          useFactory: () => OpenFeature.getClient(domain),
-        });
+      providers.push({
+        provide: token,
+        useFactory: () => OpenFeature.getClient(domain),
+        inject: [OPEN_FEATURE_INIT_TOKEN],
       });
-    }
-
-    const nestProviders: NestProvider[] = [ShutdownService];
-    nestProviders.push(...clientValueProviders);
 
-    const contextFactoryProvider: ValueProvider = {
-      provide: ContextFactoryToken,
-      useValue: options?.contextFactory,
-    };
-    nestProviders.push(contextFactoryProvider);
+      return token;
+    });
 
     if (useGlobalInterceptor) {
-      const interceptorProvider: ClassProvider = {
+      providers.push({
         provide: APP_INTERCEPTOR,
         useClass: EvaluationContextInterceptor,
-      };
-      nestProviders.push(interceptorProvider);
+      });
     }
 
     return {
-      global: true,
-      module: OpenFeatureModule,
-      providers: nestProviders,
-      exports: [...clientValueProviders, ContextFactoryToken],
+      ...baseDynamicModule,
+      providers,
+      exports: [
+        ...(baseDynamicModule.exports || []),
+        getOpenFeatureClientToken(),
+        ContextFactoryToken,
+        ...(domainClientTokens || []),
+      ],
     };
   }
 }
@@ -132,6 +177,12 @@ export interface OpenFeatureModuleOptions {
    * @see {@link AsyncLocalStorageTransactionContextPropagator}
    */
   contextFactory?: ContextFactory;
+}
+
+/**
+ * Extra options available at module definition time
+ */
+export interface OpenFeatureModuleExtras {
   /**
    * If set to false, the global {@link EvaluationContextInterceptor} is disabled.
    * This means that automatic propagation of the  {@link EvaluationContext} created by the {@link this#contextFactory} is not working.
@@ -145,6 +196,16 @@ export interface OpenFeatureModuleOptions {
    * @default true
    */
   useGlobalInterceptor?: boolean;
+  /**
+   * Whether the module should be global.
+   * @default true
+   */
+  isGlobal?: boolean;
+  /**
+   * Domains for which to create domain-scoped OpenFeature clients.
+   * Each domain will get its own injectable client token via {@link getOpenFeatureClientToken}.
+   */
+  domains?: string[];
 }
 
 /**

packages/nest/src/open-feature.module.ts

@@ -81,5 +81,6 @@ export const getOpenFeatureDefaultTestModule = () => {
     contextFactory: exampleContextFactory,
     defaultProvider,
     providers,
+    domains: ['domainScopedClient'],
   });
 };

packages/nest/test/fixtures.ts

@@ -192,6 +192,7 @@ describe('OpenFeature SDK', () => {
             defaultProvider,
             providers,
             useGlobalInterceptor: false,
+            domains: ['domainScopedClient'],
           }),
         ],
         providers: [OpenFeatureTestService],

packages/nest/test/open-feature-sdk.spec.ts

@@ -91,4 +91,63 @@ describe('OpenFeatureModule', () => {
       await moduleWithoutProvidersRef.close();
     });
   });
+
+  describe('forRootAsync', () => {
+    let moduleRef: TestingModule;
+
+    beforeAll(async () => {
+      moduleRef = await Test.createTestingModule({
+        imports: [
+          OpenFeatureModule.forRootAsync({
+            useFactory: () => ({
+              defaultProvider: new (require('@openfeature/server-sdk').InMemoryProvider)({
+                testAsyncFlag: {
+                  defaultVariant: 'default',
+                  variants: { default: 'async-value' },
+                  disabled: false,
+                },
+              }),
+            }),
+          }),
+        ],
+      }).compile();
+    });
+
+    afterAll(async () => {
+      await moduleRef.close();
+    });
+
+    it('should configure module with async options', async () => {
+      const client = moduleRef.get<Client>(getOpenFeatureClientToken());
+      expect(client).toBeDefined();
+      expect(await client.getStringValue('testAsyncFlag', '')).toEqual('async-value');
+    });
+  });
+
+  describe('logger', () => {
+    const mockLogger = {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    };
+    const setLoggerSpy = jest.spyOn(OpenFeature, 'setLogger');
+
+    afterEach(() => {
+      setLoggerSpy.mockClear();
+    });
+
+    afterAll(() => {
+      setLoggerSpy.mockRestore();
+    });
+
+    it('should set the logger on OpenFeature during module initialization', async () => {
+      const moduleRef = await Test.createTestingModule({
+        imports: [OpenFeatureModule.forRoot({ logger: mockLogger })],
+      }).compile();
+
+      expect(setLoggerSpy).toHaveBeenCalledWith(mockLogger);
+      await moduleRef.close();
+    });
+  });
 });