fixup: review feedback sdk update

Signed-off-by: Todd Baert <[email protected]>

Author: toddbaert

libs/providers/ofrep-web/src/lib/ofrep-web-provider.spec.ts

@@ -4,7 +4,7 @@ import TestLogger from '../../test/test-logger';
 import { server } from '../../../../shared/ofrep-core/src/test/mock-service-worker';
 import { ClientProviderEvents, ClientProviderStatus, OpenFeature } from '@openfeature/web-sdk';
 // eslint-disable-next-line @nx/enforce-module-boundaries
-import { TEST_FLAG_METADATA, TEST_FLAG_SET_METADATA } from 'libs/shared/ofrep-core/src/test/test-constants';
+import { TEST_FLAG_METADATA, TEST_FLAG_SET_METADATA } from '../../../../shared/ofrep-core/src/test/test-constants';
 
 describe('OFREPWebProvider', () => {
   beforeAll(() => server.listen());
@@ -190,9 +190,7 @@ describe('OFREPWebProvider', () => {
       flagKey,
       value: false,
       errorCode: 'PARSE_ERROR',
-      // TODO: there's a bug in the web SDK which calls `instantiateErrorByErrorCode` without a message, so our message is lost :(
-      // errorMessage: 'Flag or flag configuration could not be parsed',
-      errorMessage: '',
+      errorMessage: 'Flag or flag configuration could not be parsed',
       reason: 'ERROR',
       flagMetadata: {},
     });

libs/providers/ofrep-web/src/lib/ofrep-web-provider.ts

@@ -29,15 +29,15 @@ import { FlagCache, MetadataCache } from './model/in-memory-cache';
 import { OFREPWebProviderOptions } from './model/ofrep-web-provider-options';
 import { isResolutionError } from './model/resolution-error';
 
-const ERROR_TO_MESSAGE: { [key in ErrorCode]: string } = {
+const ErrorMessageMap: { [key in ErrorCode]: string } = {
   [ErrorCode.FLAG_NOT_FOUND]: 'Flag was not found',
   [ErrorCode.GENERAL]: 'General error',
   [ErrorCode.INVALID_CONTEXT]: 'Context is invalid or could be parsed',
   [ErrorCode.PARSE_ERROR]: 'Flag or flag configuration could not be parsed',
   [ErrorCode.PROVIDER_FATAL]: 'Provider is in a fatal error state',
   [ErrorCode.PROVIDER_NOT_READY]: 'Provider is not yet ready',
   [ErrorCode.TARGETING_KEY_MISSING]: 'Targeting key is missing',
-  [ErrorCode.TYPE_MISMATCH]: 'Flag is not of expect type',
+  [ErrorCode.TYPE_MISMATCH]: 'Flag is not of expected type',
 };
 
 export class OFREPWebProvider implements Provider {
@@ -203,22 +203,23 @@ export class OFREPWebProvider implements Provider {
       const bulkSuccessResp = response.value;
       const newCache: FlagCache = {};
 
-      if ('flags' in bulkSuccessResp && typeof bulkSuccessResp.flags === 'object') {
-        bulkSuccessResp.flags?.forEach((evalResp: EvaluationResponse) => {
+      if ('flags' in bulkSuccessResp && Array.isArray(bulkSuccessResp.flags)) {
+        bulkSuccessResp.flags.forEach((evalResp: EvaluationResponse) => {
           if (isEvaluationFailureResponse(evalResp)) {
             newCache[evalResp.key] = {
+              reason: StandardResolutionReasons.ERROR,
+              flagMetadata: evalResp.metadata,
               errorCode: evalResp.errorCode,
               errorDetails: evalResp.errorDetails,
-              reason: StandardResolutionReasons.ERROR,
             };
           }
 
           if (isEvaluationSuccessResponse(evalResp) && evalResp.key) {
             newCache[evalResp.key] = {
               value: evalResp.value,
-              flagMetadata: evalResp.metadata,
-              reason: evalResp.reason,
               variant: evalResp.variant,
+              reason: evalResp.reason,
+              flagMetadata: evalResp.metadata,
             };
           }
         });
@@ -281,27 +282,27 @@ export class OFREPWebProvider implements Provider {
       return {
         value: defaultValue,
         flagMetadata: this._flagSetMetadataCache,
-        reason: 'ERROR',
+        reason: StandardResolutionReasons.ERROR,
         errorCode: ErrorCode.FLAG_NOT_FOUND,
-        errorMessage: ERROR_TO_MESSAGE[ErrorCode.FLAG_NOT_FOUND],
+        errorMessage: ErrorMessageMap[ErrorCode.FLAG_NOT_FOUND],
       };
     }
 
     if (isResolutionError(resolved)) {
       return {
         ...resolved,
         value: defaultValue,
-        errorMessage: ERROR_TO_MESSAGE[resolved.errorCode],
+        errorMessage: ErrorMessageMap[resolved.errorCode],
       };
     }
 
     if (typeof resolved.value !== type) {
       return {
         value: defaultValue,
         flagMetadata: this._flagSetMetadataCache,
-        reason: 'ERROR',
+        reason: StandardResolutionReasons.ERROR,
         errorCode: ErrorCode.TYPE_MISMATCH,
-        errorMessage: ERROR_TO_MESSAGE[ErrorCode.TYPE_MISMATCH],
+        errorMessage: ErrorMessageMap[ErrorCode.TYPE_MISMATCH],
       };
     }
 

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

@@ -7,7 +7,7 @@ import {
 } from '@openfeature/ofrep-core';
 import { ErrorCode, GeneralError, TypeMismatchError } from '@openfeature/server-sdk';
 // eslint-disable-next-line @nx/enforce-module-boundaries
-import { TEST_FLAG_METADATA } from 'libs/shared/ofrep-core/src/test/test-constants';
+import { TEST_FLAG_METADATA } from '../../../../shared/ofrep-core/src/test/test-constants';
 // eslint-disable-next-line @nx/enforce-module-boundaries
 import { server } from '../../../../shared/ofrep-core/src/test/mock-service-worker';
 
@@ -130,8 +130,10 @@ describe('OFREPProvider should', () => {
     expect(flag.flagMetadata).toEqual(TEST_FLAG_METADATA);
   });
 
-  it('throw TypeMismatchError if response type is different rom requested one', async () => {
-    await expect(provider.resolveNumberEvaluation('my-flag', 42, {})).rejects.toThrow(TypeMismatchError);
+  it('return TypeMismatchError if response type is different rom requested one', async () => {
+    const flag = await provider.resolveNumberEvaluation('my-flag', 42, {});
+    expect(flag.errorCode).toEqual(ErrorCode.TYPE_MISMATCH);
+    expect(flag.flagMetadata).toEqual(TEST_FLAG_METADATA);
   });
 
   it('send auth header from headerFactory', async () => {

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

@@ -8,12 +8,13 @@ import {
   toResolutionDetails,
 } from '@openfeature/ofrep-core';
 import {
+  ErrorCode,
   EvaluationContext,
   GeneralError,
   JsonValue,
   Provider,
   ResolutionDetails,
-  TypeMismatchError,
+  StandardResolutionReasons,
 } from '@openfeature/server-sdk';
 
 export type OFREPProviderOptions = OFREPProviderBaseOptions;
@@ -103,7 +104,13 @@ export class OFREPProvider implements Provider {
     }
 
     if (typeof result.value.value !== typeof defaultValue) {
-      throw new TypeMismatchError(`Expected flag type ${typeof defaultValue} but got ${typeof result.value.value}`);
+      return {
+        value: defaultValue,
+        reason: StandardResolutionReasons.ERROR,
+        flagMetadata: result.value.metadata,
+        errorCode: ErrorCode.TYPE_MISMATCH,
+        errorMessage: 'Flag is not of expected type',
+      };
     }
 
     return toResolutionDetails(result.value);

libs/shared/ofrep-core/src/lib/api/ofrep-api.ts

@@ -1,4 +1,4 @@
-import { FlagMetadata, ResolutionDetails } from '@openfeature/core';
+import { ErrorCode, FlagMetadata, ResolutionDetails, StandardResolutionReasons } from '@openfeature/core';
 import {
   EvaluationFlagValue,
   EvaluationRequest,
@@ -163,12 +163,13 @@ export function handleEvaluationError<T>(
   callback?.(resultOrError);
 
   if ('value' in resultOrError) {
-    const code = resultOrError.value.errorCode;
+    const code = resultOrError.value.errorCode || ErrorCode.GENERAL;
     const message = resultOrError.value.errorCode;
     const metadata = resultOrError.value.metadata;
 
     const resolution: ResolutionDetails<T> = {
       value: defaultValue,
+      reason: StandardResolutionReasons.ERROR,
       flagMetadata: metadata,
       errorCode: code,
       errorMessage: message,

libs/shared/ofrep-core/src/lib/model/evaluation.ts

@@ -7,14 +7,6 @@ export interface EvaluationRequest {
   context?: EvaluationContext;
 }
 
-// export enum EvaluationSuccessReason {
-//   Static = 'STATIC',
-//   TargetingMatch = 'TARGETING_MATCH',
-//   Split = 'SPLIT',
-//   Disabled = 'DISABLED',
-//   Unknown = 'UNKNOWN',
-// }
-
 export type EvaluationFlagValue = FlagValue;
 
 export interface MetadataResponse {

package-lock.json

@@ -53,8 +53,8 @@
     "@nx/web": "20.3.1",
     "@nx/workspace": "20.3.1",
     "@openfeature/core": "^1.6.0",
-    "@openfeature/server-sdk": "^1.17.0",
-    "@openfeature/web-sdk": "^1.4.0",
+    "@openfeature/server-sdk": "^1.17.1",
+    "@openfeature/web-sdk": "^1.4.1",
     "@opentelemetry/sdk-metrics": "^1.15.0",
     "@swc-node/register": "~1.10.0",
     "@swc/cli": "~0.6.0",