Merge pull request #6 from splitio/fme-9857

[FME-9857] Add evaluation with details

Author: ZamoraEmmanuel

src/__tests__/integration/e2e.test.js

@@ -103,6 +103,7 @@ describe('OpenFeature Split Provider - E2E Integration Tests', () => {
       expect(details.flagKey).toBe('my_feature');
       expect(details.reason).toBe('TARGETING_MATCH');
       expect(details.variant).toBe('on');
+      expect(details.flagMetadata.config).toBe('{"desc": "this is a test"}')
     });
   });
 
@@ -162,6 +163,7 @@ describe('OpenFeature Split Provider - E2E Integration Tests', () => {
       expect(details.flagKey).toBe('my_feature');
       expect(details.variant).toBe('on');
       expect(details.reason).toBe('TARGETING_MATCH');
+      expect(details.flagMetadata.config).toBe('{"desc": "this is a test"}')
     });
   });
 });

src/__tests__/integration/mock.test.js

@@ -23,12 +23,12 @@ describe('OpenFeature Split Provider - Mock Integration Tests', () => {
       __getStatus: () => ({isReady: true}),
 
       // Mock treatment evaluation methods
-      getTreatment: jest.fn((splitName) => {
-        if (splitName === 'my_feature') return 'on';
-        if (splitName === 'some_other_feature') return 'off';
-        if (splitName === 'int_feature') return '32';
-        if (splitName === 'obj_feature') return '{"key": "value"}';
-        return 'control';
+      getTreatmentWithConfig: jest.fn((splitName) => {
+        if (splitName === 'my_feature') return { treatment: 'on', config: '{"desc": "this is a test"}' };
+        if (splitName === 'some_other_feature') return { treatment: 'off' };
+        if (splitName === 'int_feature') return { treatment: '32' };
+        if (splitName === 'obj_feature') return { treatment: '{"key": "value"}' };
+        return { treatment: 'control' };
       }),
 
       // Mock for cleanup
@@ -53,7 +53,7 @@ describe('OpenFeature Split Provider - Mock Integration Tests', () => {
   test('boolean evaluation should work', async () => {
     const result = await client.getBooleanValue('my_feature', false);
     expect(result).toBe(true);
-    expect(mockSplitClient.getTreatment).toHaveBeenCalledWith('my_feature', {});
+    expect(mockSplitClient.getTreatmentWithConfig).toHaveBeenCalledWith('my_feature', {});
   });
 
   test('boolean evaluation should handle off value', async () => {
@@ -81,6 +81,7 @@ describe('OpenFeature Split Provider - Mock Integration Tests', () => {
     expect(details.value).toBe(true);
     expect(details.variant).toBe('on');
     expect(details.flagKey).toBe('my_feature');
+    expect(details.flagMetadata.config).toBe('{"desc": "this is a test"}')
     expect(details.reason).toBe('TARGETING_MATCH');
   });
 

src/__tests__/integration/working.test.js

@@ -48,6 +48,14 @@ describe('OpenFeature Split Provider - Working Integration Test', () => {
     expect(result).toBe(true);
   });
 
+  test('boolean treatment details evaluations', async () => {
+    
+    // Test the boolean value evaluation
+    const result = await client.getBooleanDetails('my_feature', false);
+    expect(result.value).toBe(true);
+    expect(result.flagMetadata.config).toBe('{"desc": "this is a test"}')
+  });
+
   // Add a test for string treatment
   test('string treatment evaluations', async () => {
     const result = await client.getStringValue('some_other_feature', 'default');

src/__tests__/provider-unit.test.js

@@ -24,15 +24,15 @@ describe('OpenFeatureSplitProvider Unit Tests', () => {
       Event: { SDK_READY: 'SDK_READY' },
 
       // Mock the treatments
-      getTreatment: jest.fn((flagKey, _attributes) => {
+      getTreatmentWithConfig: jest.fn((flagKey, _attributes) => {
         // Return specific values for our test cases
-        if (flagKey === 'boolean-flag') return 'on';
-        if (flagKey === 'boolean-flag-off') return 'off';
-        if (flagKey === 'string-flag') return 'a-string-treatment';
-        if (flagKey === 'number-flag') return '42';
-        if (flagKey === 'object-flag') return '{"key":"value","nested":{"inner":"data"}}';
-        if (flagKey === 'non-existent') return 'control';
-        return 'control';
+        if (flagKey === 'boolean-flag') return { treatment: 'on', config: '{"desc": "this is a test"}' };
+        if (flagKey === 'boolean-flag-off') return { treatment: 'off', config: {} };
+        if (flagKey === 'string-flag') return { treatment: 'a-string-treatment', config: {} };
+        if (flagKey === 'number-flag') return { treatment: '42', config: {} };
+        if (flagKey === 'object-flag') return { treatment: '{"key":"value","nested":{"inner":"data"}}', config: {} };
+        if (flagKey === 'non-existent') return { treatment: 'control', config: {} };
+        return { treatment: 'control', config: {} };
       }),
 
       // Clean up
@@ -55,7 +55,8 @@ describe('OpenFeatureSplitProvider Unit Tests', () => {
 
     expect(result.value).toBe(true);
     expect(result.variant).toBe('on');
-    expect(mockSplitClient.getTreatment).toHaveBeenCalledWith(
+    expect(result.flagMetadata.config).toBe('{"desc": "this is a test"}')
+    expect(mockSplitClient.getTreatmentWithConfig).toHaveBeenCalledWith(
       'boolean-flag',
       {}
     );
@@ -131,15 +132,4 @@ describe('OpenFeatureSplitProvider Unit Tests', () => {
     }).toThrow(/targeting key/i);
   });
 
-  test('should include metadata in evaluation result', () => {
-    const result = provider.resolveStringEvaluation(
-      'string-flag',
-      'default', // default value
-      { targetingKey: 'user-key' },
-      console // logger
-    );
-    
-    expect(result.flagKey).toBe('string-flag');
-    expect(result.reason).toBe('TARGETING_MATCH');
-  });
 });

src/lib/js-split-provider.ts

@@ -11,7 +11,6 @@ import {
   StandardResolutionReasons,
   Logger,
   ProviderEvents,
-  OpenFeature,
   OpenFeatureEventEmitter,
 } from "@openfeature/web-sdk";
 import type SplitIO from "@splitsoftware/splitio/types/splitio";
@@ -22,6 +21,7 @@ type Consumer = {
 };
 
 const CONTROL_VALUE_ERROR_MESSAGE = "Received the 'control' value from Split.";
+const CONTROL_TREATMENT = 'control';
 
 export class OpenFeatureSplitProvider implements Provider {
   metadata = {
@@ -41,130 +41,117 @@ export class OpenFeatureSplitProvider implements Provider {
       this.events.emit(ProviderEvents.Ready)
     };
 
-    // If client is ready, resolve immediately
-    if (this.isClientReady()) {
+    const onSdkTimedOut = () => {
+      console.log(`${this.metadata.name} provider couldn't initialize`);
+      this.events.emit(ProviderEvents.Error);
+    };
+
+    const clientStatus = (this.client as any).__getStatus();
+    if (clientStatus.isReady) {
       onSdkReady();
-    } else {
-      this.client.on(this.client.Event.SDK_READY, onSdkReady);
+      return;
+    } 
+    if (clientStatus.hasTimedout || clientStatus.isTimedOut) {
+      onSdkTimedOut();
+      return;
     }
-  }
-
-  // Safe method to check if client is ready
-  private isClientReady(): boolean {
-    return (this.client as any).__getStatus().isReady;
+    this.client.on(this.client.Event.SDK_READY, onSdkReady);
+    this.client.on(this.client.Event.SDK_READY_TIMED_OUT, onSdkTimedOut);
   }
 
   resolveBooleanEvaluation(
     flagKey: string,
-    defaultValue: boolean,
+    _: boolean,
     context: EvaluationContext,
     _logger: Logger
   ): ResolutionDetails<boolean> {
     const details = this.evaluateTreatment(
       flagKey,
       this.transformContext(context),
-      defaultValue.toString()
     );
 
-    let value: boolean;
-    switch (details.value as unknown) {
-      case "on":
-      case "true":
-      case true:
-        value = true;
-        break;
-      case "off":
-      case "false":
-      case false:
-        value = false;
-        break;
-      case "control":
-        throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
-      default:
-        throw new ParseError(`Invalid boolean value for ${details.value}`);
+    const treatment = details.value.toLowerCase();
+
+    if ( treatment === 'on' || treatment === 'true' ) {
+      return { ...details, value: true };
     }
-    return { ...details, value };
+
+    if ( treatment === 'off' || treatment === 'false' ) {
+      return { ...details, value: false };
+    }
+
+    throw new ParseError(`Invalid boolean value for ${treatment}`);
   }
 
   resolveStringEvaluation(
     flagKey: string,
-    defaultValue: string,
+    _: string,
     context: EvaluationContext,
     _logger: Logger
   ): ResolutionDetails<string> {
     const details = this.evaluateTreatment(
       flagKey,
       this.transformContext(context),
-      defaultValue
     );
-    if (details.value === "control") {
-      throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
-    }
     return details;
   }
 
   resolveNumberEvaluation(
     flagKey: string,
-    defaultValue: number,
+    _: number,
     context: EvaluationContext,
     _logger: Logger
   ): ResolutionDetails<number> {
     const details = this.evaluateTreatment(
       flagKey,
       this.transformContext(context),
-      defaultValue.toString()
     );
     return { ...details, value: this.parseValidNumber(details.value) };
   }
 
   resolveObjectEvaluation<U extends JsonValue>(
     flagKey: string,
-    defaultValue: U,
+    _: U,
     context: EvaluationContext,
     _logger: Logger
   ): ResolutionDetails<U> {
     const details = this.evaluateTreatment(
       flagKey,
-      this.transformContext(context),
-      JSON.stringify(defaultValue)
+      this.transformContext(context)
     );
     return { ...details, value: this.parseValidJsonObject(details.value) };
   }
 
   private evaluateTreatment(
     flagKey: string,
-    consumer: Consumer,
-    defaultValue: string
+    consumer: Consumer
   ): ResolutionDetails<string> {
     if (!consumer.key) {
       throw new TargetingKeyMissingError(
-        "The Split provider requires a targeting key."
+        'The Split provider requires a targeting key.'
       );
-    } else {
-      // The SDK should be ready by now, but if not, return default value
-      // Use our isClientReady helper to safely check
-      if (!this.isClientReady()) {
-        return {
-          value: defaultValue,
-          variant: defaultValue,
-          reason: StandardResolutionReasons.DEFAULT
-        };
-      }
-      const value = this.client.getTreatment(
-        flagKey,
-        consumer.attributes
+    }
+    if (flagKey == null || flagKey === '') {
+      throw new FlagNotFoundError(
+        'flagKey must be a non-empty string'
       );
-      // Create resolution details and add flagKey as additional property for tests
-      const details: ResolutionDetails<string> = {
-        value: value,
-        variant: value,
-        reason: StandardResolutionReasons.TARGETING_MATCH,
-      };
-      
-      // Add flagKey for OpenFeature v1 compatibility, using assertion to avoid TypeScript errors
-      (details as any).flagKey = flagKey;
-      return details;
     }
+    const { treatment: value, config }: SplitIO.TreatmentWithConfig = this.client.getTreatmentWithConfig(
+      flagKey,
+      consumer.attributes
+    );
+
+    if (value === CONTROL_TREATMENT) {
+      throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
+    }
+    const flagMetadata = { config: config ? config : '' };
+    const details: ResolutionDetails<string> = {
+      value: value,
+      variant: value,
+      flagMetadata: flagMetadata,
+      reason: StandardResolutionReasons.TARGETING_MATCH,
+    };
+    return details;
   }
 
   //Transform the context into an object useful for the Split API, an key string with arbitrary Split "Attributes".