first match strategy will ignore thrown flag not found errors

Signed-off-by: Adam Wootton <[email protected]>

Author: ajwootto

libs/providers/multi-provider/src/lib/multi-provider.spec.ts

@@ -3,6 +3,7 @@ import {
   DefaultLogger,
   ErrorCode,
   EvaluationContext,
+  FlagNotFoundError,
   FlagValue,
   FlagValueType,
   Hook,
@@ -11,8 +12,8 @@ import {
   OpenFeatureEventEmitter,
   Provider,
   ServerProviderEvents,
+  ProviderMetadata,
 } from '@openfeature/server-sdk';
-import { ProviderMetadata } from '@openfeature/core';
 import { FirstMatchStrategy } from './strategies/FirstMatchStrategy';
 import { FirstSuccessfulStrategy } from './strategies/FirstSuccessfulStrategy';
 import { ComparisonStrategy } from './strategies/ComparisonStrategy';
@@ -542,6 +543,34 @@ describe('MultiProvider', () => {
           expect(provider2.resolveBooleanEvaluation).toHaveBeenCalled();
           expect(provider3.resolveBooleanEvaluation).not.toHaveBeenCalled();
         });
+
+        it('skips providers that throw flag not found until it gets a result, skipping any provider after', async () => {
+          const provider1 = new TestProvider();
+          const provider2 = new TestProvider();
+          const provider3 = new TestProvider();
+          provider1.resolveBooleanEvaluation.mockRejectedValue(new FlagNotFoundError('flag not found'));
+          provider2.resolveBooleanEvaluation.mockResolvedValue({
+            value: true,
+          });
+          const multiProvider = new MultiProvider(
+            [
+              {
+                provider: provider1,
+              },
+              {
+                provider: provider2,
+              },
+              {
+                provider: provider3,
+              },
+            ],
+            new FirstMatchStrategy(),
+          );
+          const result = await callEvaluation(multiProvider, {}, logger);
+          expect(result).toEqual({ value: true });
+          expect(provider2.resolveBooleanEvaluation).toHaveBeenCalled();
+          expect(provider3.resolveBooleanEvaluation).not.toHaveBeenCalled();
+        });
       });
 
       describe('first successful strategy', () => {

libs/providers/multi-provider/src/lib/multi-provider.ts

@@ -192,7 +192,6 @@ export class MultiProvider implements Provider {
     hookHints: HookHints,
     context: EvaluationContext,
   ): Promise<[shouldEvaluateNext: boolean, ProviderResolutionResult<T> | null]> {
-    let thrownError: unknown;
     let evaluationResult: ResolutionDetails<T> | undefined = undefined;
     const provider = providerEntry.provider;
     const strategyContext = {
@@ -222,12 +221,11 @@ export class MultiProvider implements Provider {
         provider: provider,
         providerName: providerEntry.name,
       };
-      thrownError = error;
     }
 
     return [
       this.evaluationStrategy.runMode === 'sequential'
-        ? this.evaluationStrategy.shouldEvaluateNextProvider(strategyContext, context, evaluationResult, thrownError)
+        ? this.evaluationStrategy.shouldEvaluateNextProvider(strategyContext, context, resolution)
         : true,
       resolution,
     ];

libs/providers/multi-provider/src/lib/strategies/BaseEvaluationStrategy.ts

@@ -3,6 +3,7 @@ import {
   EvaluationContext,
   FlagValue,
   FlagValueType,
+  OpenFeatureError,
   Provider,
   ProviderStatus,
   ResolutionDetails,
@@ -66,8 +67,7 @@ export abstract class BaseEvaluationStrategy {
   shouldEvaluateNextProvider<T extends FlagValue>(
     strategyContext: StrategyPerProviderContext,
     context: EvaluationContext,
-    details?: ResolutionDetails<T>,
-    thrownError?: unknown,
+    result: ProviderResolutionResult<T>,
   ): boolean {
     return true;
   }
@@ -86,6 +86,12 @@ export abstract class BaseEvaluationStrategy {
     return 'thrownError' in resolution || !!resolution.details.errorCode;
   }
 
+  protected hasErrorWithCode(resolution: ProviderResolutionResult<FlagValue>, code: ErrorCode): boolean {
+    return 'thrownError' in resolution
+      ? (resolution.thrownError as OpenFeatureError)?.code === code
+      : resolution.details.errorCode === code;
+  }
+
   protected collectProviderErrors<T extends FlagValue>(resolutions: ProviderResolutionResult<T>[]): FinalResult<T> {
     const errors: FinalResult<FlagValue>['errors'] = [];
     for (const resolution of resolutions) {

libs/providers/multi-provider/src/lib/strategies/FirstMatchStrategy.ts

@@ -4,7 +4,7 @@ import {
   ProviderResolutionResult,
   StrategyPerProviderContext,
 } from './BaseEvaluationStrategy';
-import { ErrorCode, EvaluationContext, FlagValue, ResolutionDetails } from '@openfeature/server-sdk';
+import { ErrorCode, EvaluationContext, FlagValue, OpenFeatureError, ResolutionDetails } from '@openfeature/server-sdk';
 
 /**
  * Return the first result that did not indicate "flag not found".
@@ -14,13 +14,12 @@ export class FirstMatchStrategy extends BaseEvaluationStrategy {
   override shouldEvaluateNextProvider<T extends FlagValue>(
     strategyContext: StrategyPerProviderContext,
     context: EvaluationContext,
-    details?: ResolutionDetails<T>,
-    thrownError?: unknown,
+    result: ProviderResolutionResult<T>,
   ): boolean {
-    if (details?.errorCode === ErrorCode.FLAG_NOT_FOUND) {
+    if (this.hasErrorWithCode(result, ErrorCode.FLAG_NOT_FOUND)) {
       return true;
     }
-    if (details?.errorCode) {
+    if (this.hasError(result)) {
       return false;
     }
     return false;

libs/providers/multi-provider/src/lib/strategies/FirstSuccessfulStrategy.ts

@@ -15,11 +15,10 @@ export class FirstSuccessfulStrategy extends BaseEvaluationStrategy {
   override shouldEvaluateNextProvider<T extends FlagValue>(
     strategyContext: StrategyPerProviderContext,
     context: EvaluationContext,
-    details?: ResolutionDetails<T>,
-    thrownError?: unknown,
+    result: ProviderResolutionResult<T>,
   ): boolean {
     // evaluate next only if there was an error
-    return !!(thrownError || details?.errorCode);
+    return this.hasError(result);
   }
 
   override determineFinalResult<T extends FlagValue>(