feat: update options for RequireFlagsEnabled decorator to include context and allow for flags to change the default value for flag evaluation. move getClientForEvaluation method to utils file

kaushalkapasi · kaushalkapasi · commit 6ec4788b5452 · 2025-03-26T11:53:22.000-04:00
Signed-off-by: Kaushal Kapasi &lt;kaushal.kapasi@taplytics.com&gt;
diff --git a/packages/nest/src/feature.decorator.ts b/packages/nest/src/feature.decorator.ts
@@ -1,16 +1,10 @@
 import { createParamDecorator, Inject } from '@nestjs/common';
-import type {
-  EvaluationContext,
-  EvaluationDetails,
-  FlagValue,
-  JsonValue} from '@openfeature/server-sdk';
-import {
-  OpenFeature,
-  Client,
-} from '@openfeature/server-sdk';
+import type { EvaluationContext, EvaluationDetails, FlagValue, JsonValue } from '@openfeature/server-sdk';
+import { OpenFeature, Client } from '@openfeature/server-sdk';
 import { getOpenFeatureClientToken } from './open-feature.module';
 import type { Observable } from 'rxjs';
 import { from } from 'rxjs';
+import { getClientForEvaluation } from './utils';
 
 /**
  * Options for injecting an OpenFeature client into a constructor.
@@ -56,16 +50,6 @@ interface FeatureProps<T extends FlagValue> {
   context?: EvaluationContext;
 }
 
-/**
- * Returns a domain scoped or the default OpenFeature client with the given context.
- * @param {string} domain The domain of the OpenFeature client.
- * @param {EvaluationContext} context The evaluation context of the client.
- * @returns {Client} The OpenFeature client.
- */
-function getClientForEvaluation(domain?: string, context?: EvaluationContext) {
-  return domain ? OpenFeature.getClient(domain, context) : OpenFeature.getClient(context);
-}
-
 /**
  * Route handler parameter decorator.
  *
diff --git a/packages/nest/src/require-flags-enabled.decorator.ts b/packages/nest/src/require-flags-enabled.decorator.ts
@@ -1,21 +1,28 @@
 import type { CallHandler, ExecutionContext, HttpException, NestInterceptor } from '@nestjs/common';
 import { applyDecorators, mixin, NotFoundException, UseInterceptors } from '@nestjs/common';
-import type { Client } from '@openfeature/server-sdk';
-import { OpenFeature } from '@openfeature/server-sdk';
+import { getClientForEvaluation } from './utils';
+import type { EvaluationContext } from '@openfeature/server-sdk';
+
+type RequiredFlag = {
+  flagKey: string;
+  defaultValue?: boolean;
+};
 
 /**
- * Options for injecting a feature flag into a route handler.
+ * Options for using one or more Boolean feature flags to control access to a Controller or Route.
  */
 interface RequireFlagsEnabledProps {
   /**
-   * The key of the feature flag.
+   * The key and default value of the feature flag.
    * @see {@link Client#getBooleanValue}
    */
-  flagKeys: string[];
+  flags: RequiredFlag[];
+
   /**
    * The exception to throw if any of the required feature flags are not enabled.
    * Defaults to a 404 Not Found exception.
    * @see {@link HttpException}
+   * @default new NotFoundException(`Cannot ${req.method} ${req.url}`)
    */
   exception?: HttpException;
 
@@ -24,15 +31,12 @@ interface RequireFlagsEnabledProps {
    * @see {@link OpenFeature#getClient}
    */
   domain?: string;
-}
 
-/**
- * Returns a domain scoped or the default OpenFeature client with the given context.
- * @param {string} domain The domain of the OpenFeature client.
- * @returns {Client} The OpenFeature client.
- */
-function getClientForEvaluation(domain?: string) {
-  return domain ? OpenFeature.getClient(domain) : OpenFeature.getClient();
+  /**
+   * Global {@link EvaluationContext} for OpenFeature.
+   * @see {@link OpenFeature#setContext}
+   */
+  context?: EvaluationContext;
 }
 
 /**
@@ -43,9 +47,15 @@ function getClientForEvaluation(domain?: string) {
  * For example:
  * ```typescript
  * @RequireFlagsEnabled({
- *   flagKeys: ['flagName', 'flagName2'],  // Required, an array of Boolean feature flag keys
- *   exception: new ForbiddenException(),  // Optional, defaults to a 404 Not Found exception
- *   domain: 'my-domain',                  // Optional, defaults to the default OpenFeature client
+ *   flags: [                               // Required, an array of Boolean flags to check, with optional default values (defaults to false)
+ *     { flagKey: 'flagName' },
+ *     { flagKey: 'flagName2', defaultValue: true },
+ *   ],
+ *   exception: new ForbiddenException(),   // Optional, defaults to a 404 Not Found Exception
+ *   domain: 'my-domain',                   // Optional, defaults to the default OpenFeature Client
+ *   context: {                             // Optional, defaults to the global OpenFeature Context
+ *     targetingKey: 'user-id',
+ *   },
  * })
  * @Get('/')
  * public async handleGetRequest()
@@ -62,10 +72,10 @@ const FlagsEnabledInterceptor = (props: RequireFlagsEnabledProps) => {
 
     async intercept(context: ExecutionContext, next: CallHandler) {
       const req = context.switchToHttp().getRequest();
-      const client = getClientForEvaluation(props.domain);
+      const client = getClientForEvaluation(props.domain, props.context);
 
-      for (const flagKey of props.flagKeys) {
-        const endpointAccessible = await client.getBooleanValue(flagKey, false);
+      for (const flag of props.flags) {
+        const endpointAccessible = await client.getBooleanValue(flag.flagKey, flag.defaultValue ?? false);
 
         if (!endpointAccessible) {
           throw props.exception || new NotFoundException(`Cannot ${req.method} ${req.url}`);
diff --git a/packages/nest/src/utils.ts b/packages/nest/src/utils.ts
@@ -0,0 +1,12 @@
+import type { Client, EvaluationContext } from '@openfeature/server-sdk';
+import { OpenFeature } from '@openfeature/server-sdk';
+
+/**
+ * Returns a domain scoped or the default OpenFeature client with the given context.
+ * @param {string} domain The domain of the OpenFeature client.
+ * @param {EvaluationContext} context The evaluation context of the client.
+ * @returns {Client} The OpenFeature client.
+ */
+export function getClientForEvaluation(domain?: string, context?: EvaluationContext) {
+  return domain ? OpenFeature.getClient(domain, context) : OpenFeature.getClient(context);
+}
diff --git a/packages/nest/test/fixtures.ts b/packages/nest/test/fixtures.ts
@@ -23,6 +23,11 @@ export const defaultProvider = new InMemoryProvider({
     variants: { default: { client: 'default' } },
     disabled: false,
   },
+  testBooleanFlag2: {
+    defaultVariant: 'default',
+    variants: { default: false, enabled: true },
+    disabled: false,
+  },
 });
 
 export const providers = {
diff --git a/packages/nest/test/open-feature-sdk.spec.ts b/packages/nest/test/open-feature-sdk.spec.ts
@@ -147,10 +147,26 @@ describe('OpenFeature SDK', () => {
           });
           await supertest(app.getHttpServer()).get('/flags-enabled-custom-exception').expect(403);
         });
+
+        it('should throw a custom exception if the flag is disabled with context', async () => {
+          jest.spyOn(defaultProvider, 'resolveBooleanEvaluation').mockResolvedValueOnce({
+            value: false,
+            reason: 'DISABLED',
+          });
+          await supertest(app.getHttpServer())
+            .get('/flags-enabled-custom-exception-with-context')
+            .set('x-user-id', '123')
+            .expect(403);
+        });
       });
 
       describe('OpenFeatureControllerRequireFlagsEnabled', () => {
         it('should allow access to the RequireFlagsEnabled controller', async () => {
+          // Only mock the first flag evaluation for Flag with key `testBooleanFlag2`, the second flag evaluation will use the default variation for flag with key `testBooleanFlag`
+          jest.spyOn(defaultProvider, 'resolveBooleanEvaluation').mockResolvedValueOnce({
+            value: true,
+            reason: 'TARGETING_MATCH',
+          });
           await supertest(app.getHttpServer()).get('/require-flags-enabled').expect(200).expect('Hello, world!');
         });
 
diff --git a/packages/nest/test/test-app.ts b/packages/nest/test/test-app.ts
@@ -93,21 +93,33 @@ export class OpenFeatureController {
   }
 
   @RequireFlagsEnabled({
-    flagKeys: ['testBooleanFlag'],
+    flags: [{ flagKey: 'testBooleanFlag' }],
   })
   @Get('/flags-enabled')
   public async handleGuardedBooleanRequest() {
     return 'Get Boolean Flag Success!';
   }
 
   @RequireFlagsEnabled({
-    flagKeys: ['testBooleanFlag'],
+    flags: [{ flagKey: 'testBooleanFlag' }],
     exception: new ForbiddenException(),
   })
   @Get('/flags-enabled-custom-exception')
   public async handleBooleanRequestWithCustomException() {
     return 'Get Boolean Flag Success!';
   }
+
+  @RequireFlagsEnabled({
+    flags: [{ flagKey: 'testBooleanFlag' }],
+    exception: new ForbiddenException(),
+    context: {
+      targetingKey: 'user-id',
+    },
+  })
+  @Get('/flags-enabled-custom-exception-with-context')
+  public async handleBooleanRequestWithCustomExceptionAndContext() {
+    return 'Get Boolean Flag Success!';
+  }
 }
 
 @Controller()
@@ -127,7 +139,7 @@ export class OpenFeatureContextScopedController {
   }
 
   @RequireFlagsEnabled({
-    flagKeys: ['testBooleanFlag'],
+    flags: [{ flagKey: 'testBooleanFlag' }],
     domain: 'domainScopedClient',
   })
   @Get('/controller-context/flags-enabled')
@@ -138,7 +150,7 @@ export class OpenFeatureContextScopedController {
 
 @Controller('require-flags-enabled')
 @RequireFlagsEnabled({
-  flagKeys: ['testBooleanFlag'],
+  flags: [{ flagKey: 'testBooleanFlag2', defaultValue: true }, { flagKey: 'testBooleanFlag' }],
   exception: new ForbiddenException(),
 })
 export class OpenFeatureRequireFlagsEnabledController {
