@splitsoftware/openfeature-js-split-provider 1.0.6 → 1.1.0

package/src/__tests__/nodeSuites/provider.spec.js

@@ -1,109 +1,241 @@
-export default async function(assert) {
-
-  const shouldFailWithBadApiKeyTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalBooleanNullEmptyTest = () => {
-    assert.equal(2, 2);
-  };
-
-  const evalBooleanControlTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalBooleanTrueTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalBooleanOnTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalBooleanFalseTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalBooleanOffTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalBooleanErrorTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStringNullEmptyTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStringControlTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStringRegularTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalNumberNullEmptyTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalNumberControlTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalNumberRegularTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalNumberErrorTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStructureNullEmptyTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStructureControlTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStructureRegularTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStructureComplexTest = () => {
-    assert.equal(1, 1);
-  };
-
-  const evalStructureErrorTest = () => {
-    assert.equal(1, 1);
-  };
-
-  shouldFailWithBadApiKeyTest();
-
-  evalBooleanNullEmptyTest();
-  evalBooleanControlTest();
-  evalBooleanTrueTest();
-  evalBooleanOnTest();
-  evalBooleanFalseTest();
-  evalBooleanOffTest();
-  evalBooleanErrorTest();
-
-  evalStringNullEmptyTest();
-  evalStringControlTest();
-  evalStringRegularTest();
-
-  evalNumberNullEmptyTest();
-  evalNumberControlTest();
-  evalNumberRegularTest();
-  evalNumberErrorTest();
-
-  evalStructureNullEmptyTest();
-  evalStructureControlTest();
-  evalStructureRegularTest();
-  evalStructureComplexTest();
-  evalStructureErrorTest();
-
-  assert.end();
-}
+/* eslint-disable jest/no-conditional-expect */
+import { getLocalHostSplitClient, getSplitFactory } from '../testUtils';
+import { OpenFeatureSplitProvider } from '../../lib/js-split-provider';
+
+const cases = [
+  [
+    'provider tests mode: splitClient',
+    () => ({ splitClient: getLocalHostSplitClient()}),
+    
+  ],
+  [
+    'provider tests mode: splitFactory',
+    getSplitFactory
+  ],
+];
+
+describe.each(cases)('%s', (label, getOptions) => {
+
+  let provider;
+  let options;
+
+  beforeEach(() => {
+    options = getOptions();
+    provider = new OpenFeatureSplitProvider(options);
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks()
+    await provider.onClose();
+  });
+
+  test('evaluate Boolean null/empty test', async () => {
+    try {
+      await provider.resolveBooleanEvaluation('', false, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('flagKey must be a non-empty string');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate Boolean control test', async () => {
+    try {
+      await provider.resolveBooleanEvaluation('non-existent-feature', false, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Received the "control" value from Split.');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate Boolean true test', async () => {
+    const details = await provider.resolveBooleanEvaluation('my_feature', false, { targetingKey: 'key' });
+    expect(details.value).toBe(true);
+    expect(details.variant).toBe('on');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.flagMetadata).toEqual({ config: '{"desc" : "this applies only to ON treatment"}' });
+  });
+
+  test('evaluate Boolean on test', async () => {
+    const details = await provider.resolveBooleanEvaluation('my_feature', true, { targetingKey: 'key' });
+    expect(details.value).toBe(true);
+    expect(details.variant).toBe('on');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.flagMetadata).toEqual({ config: '{"desc" : "this applies only to ON treatment"}' });
+  });
+
+  test('evaluate Boolean false test', async () => {
+    const details = await provider.resolveBooleanEvaluation('some_other_feature', true, { targetingKey: 'user1' });
+    expect(details.value).toBe(false);
+    expect(details.variant).toBe('off');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.flagMetadata).toEqual({ config: '' });
+  });
+
+  test('evaluate Boolean off test', async () => {
+    const details = await provider.resolveBooleanEvaluation('some_other_feature', false, { targetingKey: 'user1' });
+    expect(details.value).toBe(false);
+    expect(details.variant).toBe('off');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.flagMetadata).toEqual({ config: '' });
+  });
+
+  test('evaluate Boolean error test', async () => {
+    try {
+      await provider.resolveBooleanEvaluation('int_feature', false, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Invalid boolean value for 32');
+      expect(e.code).toBe('PARSE_ERROR');
+    }
+  });
+
+  test('evaluate String null/empty test', async () => {
+    try {
+      await provider.resolveStringEvaluation('', 'default', { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('flagKey must be a non-empty string');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate String control test', async () => {
+    try {
+      await provider.resolveStringEvaluation('non-existent-feature', 'default', { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Received the "control" value from Split.');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate String regular test', async () => {
+    try {
+      await provider.resolveStringEvaluation('string_feature', 'default', { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Received the "control" value from Split.');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate String error test', async () => {
+    try {
+      await provider.resolveStringEvaluation('int_feature', 'default', { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Invalid string value for 32');
+      expect(e.code).toBe('PARSE_ERROR');
+    }
+  });
+
+  test('evaluate Number null/empty test', async () => {
+    try {
+      await provider.resolveNumberEvaluation('', 0, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('flagKey must be a non-empty string');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate Number control test', async () => {
+    try {
+      await provider.resolveNumberEvaluation('non-existent-feature', 0, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Received the "control" value from Split.');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate Number regular test', async () => {
+    const details = await provider.resolveNumberEvaluation('int_feature', 0, { targetingKey: 'user1' });
+    expect(details.value).toBe(32);
+    expect(details.variant).toBe('32');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.flagMetadata).toEqual({ config: '{"desc" : "this applies only to number treatment"}' });
+  });
+
+  test('evaluate Number error test', async () => {
+    try {
+      await provider.resolveNumberEvaluation('my_feature', 0, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Invalid numeric value off');
+      expect(e.code).toBe('PARSE_ERROR');
+    }
+  });
+
+  test('evaluate Structure null/empty test', async () => {
+    try {
+      await provider.resolveObjectEvaluation('', {}, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('flagKey must be a non-empty string');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate Structure control test', async () => {
+    try {
+      await provider.resolveObjectEvaluation('non-existent-feature', {}, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Received the "control" value from Split.');
+      expect(e.code).toBe('FLAG_NOT_FOUND');
+    }
+  });
+
+  test('evaluate Structure regular test', async () => {
+    const details = await provider.resolveObjectEvaluation('obj_feature', {}, { targetingKey: 'user1' });
+    expect(details.value).toEqual({ key: 'value' });
+    expect(details.variant).toBe('{"key": "value"}');
+    expect(details.reason).toBe('TARGETING_MATCH');
+    expect(details.flagMetadata).toEqual({ config: '{"desc" : "this applies only to obj treatment"}' });
+  });
+
+  test('evaluate Structure error test', async () => {
+    try {
+      await provider.resolveObjectEvaluation('int_feature', {}, { targetingKey: 'user1' });
+    } catch (e) {
+      expect(e.message).toBe('Error parsing 32 as JSON, ParseError: Flag value 32 had unexpected type number, expected "object"');
+      expect(e.code).toBe('PARSE_ERROR');
+    }
+  });
+
+  test('track: throws when missing eventName', async () => {
+    try {
+      await provider.track('', { targetingKey: 'u1', trafficType: 'user' }, {});
+    } catch (e) {
+      expect(e.message).toBe('Missing eventName, required to track');
+      expect(e.code).toBe('PARSE_ERROR');
+    }
+  });
+
+  test('track: throws when missing trafficType', async () => {
+    try {
+      await provider.track('evt', { targetingKey: 'u1' }, {});
+    } catch (e) {
+      expect(e.message).toBe('Missing trafficType variable, required to track');
+      expect(e.code).toBe('INVALID_CONTEXT');
+    }
+  });
+
+  test('track: throws when missing targetingKey', async () => {
+    try {
+      await provider.track('evt', { trafficType: 'user' }, {});
+    } catch (e) {
+      expect(e.message).toBe('Missing targetingKey, required to track');
+      expect(e.code).toBe('TARGETING_KEY_MISSING');
+    }
+  });
+
+  test('track: ok without details', async () => {
+    const trackSpy = jest.spyOn(options.splitClient ? options.splitClient : options.client(), 'track');
+    await provider.track('view', { targetingKey: 'u1', trafficType: 'user' }, null);
+    expect(trackSpy).toHaveBeenCalledTimes(1);
+    expect(trackSpy).toHaveBeenCalledWith('u1', 'user', 'view', undefined, {});
+  });
+
+  test('track: ok with details', async () => {
+    const trackSpy = jest.spyOn(options.splitClient ? options.splitClient : options.client(), 'track');
+    await provider.track(
+      'purchase',
+      { targetingKey: 'u1', trafficType: 'user' },
+      { value: 9.99, properties: { plan: 'pro', beta: true } }
+    );
+    expect(trackSpy).toHaveBeenCalledTimes(1);
+    expect(trackSpy).toHaveBeenCalledWith('u1', 'user', 'purchase', 9.99, { plan: 'pro', beta: true });
+  });
+});

package/src/__tests__/testUtils/eventSourceMock.js

@@ -32,7 +32,6 @@ export default class EventSource {
     this.url = url;
     this.withCredentials = eventSourceInitDict.withCredentials;
     this.readyState = 0;
-    // eslint-disable-next-line no-undef
     this.__emitter = new EventEmitter();
     this.__eventSourceInitDict = arguments[1];
     sources[url] = this;
@@ -82,4 +81,4 @@ export default class EventSource {
 
 EventSource.CONNECTING = 0;
 EventSource.OPEN = 1;
-EventSource.CLOSED = 2;
+EventSource.CLOSED = 2;

package/src/__tests__/testUtils/index.js

@@ -1,3 +1,5 @@
+import { SplitFactory } from '@splitsoftware/splitio';
+
 const DEFAULT_ERROR_MARGIN = 50; // 0.05 secs
 
 /**
@@ -67,3 +69,44 @@ export function url(settings, target) {
   }
   return `${settings.urls.sdk}${target}`;
 }
+
+const getRedisConfig = (redisPort) => ({
+    core: {
+      authorizationKey: 'SOME SDK KEY' // in consumer mode, SDK key is only used to track and log warning regarding duplicated SDK instances
+    },
+    mode: 'consumer',
+    storage: {
+      type: 'REDIS',
+      prefix: 'REDIS_NODE_UT',
+      options: {
+        url: `redis://localhost:${redisPort}/0`
+      }
+    },
+    sync: {
+      impressionsMode: 'DEBUG'
+    },
+    startup: {
+      readyTimeout: 36000 // 10hs
+    }
+  });
+
+const config = {
+    core: {
+      authorizationKey: 'localhost'
+    },
+    features: './split.yaml',
+  }
+/**
+ * get a Split client in localhost mode for testing purposes
+ */
+export function getLocalHostSplitClient() {
+  return SplitFactory(config).client();
+}
+
+export function getRedisSplitClient(redisPort) {
+  return SplitFactory(getRedisConfig(redisPort)).client();
+}
+
+export function getSplitFactory() {
+  return SplitFactory(config);
+}

package/src/lib/js-split-provider.ts

@@ -1,17 +1,22 @@
 import {
   EvaluationContext,
-  Provider,
-  ResolutionDetails,
-  ParseError,
   FlagNotFoundError,
+  InvalidContextError,
   JsonValue,
-  TargetingKeyMissingError,
+  OpenFeatureEventEmitter,
+  ParseError,
+  Provider,
+  ProviderEvents,
+  ResolutionDetails,
   StandardResolutionReasons,
-} from "@openfeature/js-sdk";
-import type SplitIO from "@splitsoftware/splitio/types/splitio";
+  TargetingKeyMissingError,
+  TrackingEventDetails
+} from '@openfeature/server-sdk';
+import { SplitFactory } from '@splitsoftware/splitio';
+import type SplitIO from '@splitsoftware/splitio/types/splitio';
 
-export interface SplitProviderOptions {
-  splitClient: SplitIO.IClient;
+type SplitProviderOptions = {
+  splitClient: SplitIO.IClient | SplitIO.IAsyncClient;
 }
 
 type Consumer = {
@@ -19,22 +24,52 @@ type Consumer = {
   attributes: SplitIO.Attributes;
 };
 
-const CONTROL_VALUE_ERROR_MESSAGE = "Received the 'control' value from Split.";
+const CONTROL_VALUE_ERROR_MESSAGE = 'Received the "control" value from Split.';
+const CONTROL_TREATMENT = 'control';
 
 export class OpenFeatureSplitProvider implements Provider {
   metadata = {
-    name: "split",
+    name: 'split',
   };
   private initialized: Promise<void>;
-  private client: SplitIO.IClient;
+  private client: SplitIO.IClient | SplitIO.IAsyncClient;
+
+  public readonly events = new OpenFeatureEventEmitter();
 
-  constructor(options: SplitProviderOptions) {
-    this.client = options.splitClient;
+  private getSplitClient(options: SplitProviderOptions | string | SplitIO.ISDK | SplitIO.IAsyncSDK) {
+    if (typeof(options) === 'string') {
+      const splitFactory = SplitFactory({core: { authorizationKey: options } });
+      return splitFactory.client();
+    } 
+
+    let splitClient;
+    try {
+      splitClient = (options as SplitIO.ISDK | SplitIO.IAsyncSDK).client();
+    } catch {
+      splitClient = (options as SplitProviderOptions).splitClient
+    }
+
+    return splitClient;
+  }
+  
+  constructor(options: SplitProviderOptions | string | SplitIO.ISDK | SplitIO.IAsyncSDK) {
+
+    this.client = this.getSplitClient(options);
+
+    this.client.on(this.client.Event.SDK_UPDATE, () => {
+      this.events.emit(ProviderEvents.ConfigurationChanged)
+    });
     this.initialized = new Promise((resolve) => {
-      this.client.on(this.client.Event.SDK_READY, () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if ((this.client as any).__getStatus().isReady) {
         console.log(`${this.metadata.name} provider initialized`);
         resolve();
-      });
+      } else {
+        this.client.on(this.client.Event.SDK_READY, () => {
+          console.log(`${this.metadata.name} provider initialized`);
+          resolve();
+        });
+      }
     });
   }
 
@@ -47,33 +82,17 @@ export class OpenFeatureSplitProvider implements Provider {
       flagKey,
       this.transformContext(context)
     );
+    const treatment = details.value.toLowerCase();
 
-    let value: boolean;
-    switch (details.value as unknown) {
-      case "on":
-        value = true;
-        break;
-      case "off":
-        value = false;
-        break;
-      case "true":
-        value = true;
-        break;
-      case "false":
-        value = false;
-        break;
-      case true:
-        value = true;
-        break;
-      case false:
-        value = false;
-        break;
-      case "control":
-        throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
-      default:
-        throw new ParseError(`Invalid boolean value for ${details.value}`);
+    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}`);
   }
 
   async resolveStringEvaluation(
@@ -85,9 +104,6 @@ export class OpenFeatureSplitProvider implements Provider {
       flagKey,
       this.transformContext(context)
     );
-    if (details.value === "control") {
-      throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
-    }
     return details;
   }
 
@@ -121,25 +137,77 @@ export class OpenFeatureSplitProvider implements Provider {
   ): Promise<ResolutionDetails<string>> {
     if (!consumer.key) {
       throw new TargetingKeyMissingError(
-        "The Split provider requires a targeting key."
+        'The Split provider requires a targeting key.'
       );
-    } else {
-      await this.initialized;
-      const value = this.client.getTreatment(
-        consumer.key,
-        flagKey,
-        consumer.attributes
+    }
+    if (flagKey == null || flagKey === '') {
+      throw new FlagNotFoundError(
+        'flagKey must be a non-empty string'
       );
-      const details: ResolutionDetails<string> = {
-        value: value,
-        variant: value,
-        reason: StandardResolutionReasons.TARGETING_MATCH,
-      };
-      return details;
     }
+
+    await this.initialized;
+    const { treatment: value, config }: SplitIO.TreatmentWithConfig = await this.client.getTreatmentWithConfig(
+      consumer.key,
+      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;
+  }
+
+  async track(
+    trackingEventName: string,
+    context: EvaluationContext,
+    details: TrackingEventDetails
+  ): Promise<void> {
+
+    // targetingKey is always required
+    const { targetingKey } = context;
+    if (targetingKey == null || targetingKey === '')
+      throw new TargetingKeyMissingError('Missing targetingKey, required to track');
+
+    // eventName is always required
+    if (trackingEventName == null || trackingEventName === '')
+      throw new ParseError('Missing eventName, required to track');
+
+    // trafficType is always required
+    const ttVal = context['trafficType'];
+    const trafficType =
+      ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
+        ? ttVal
+        : null;
+    if (trafficType == null || trafficType === '')
+      throw new InvalidContextError('Missing trafficType variable, required to track');
+
+    let value;
+    let properties: SplitIO.Properties = {};
+    if (details != null) {
+      if (details.value != null) {
+        value = details.value;
+      }
+      if (details.properties != null) {
+        properties = details.properties as SplitIO.Properties;
+      }
+    } 
+
+    this.client.track(targetingKey, trafficType, trackingEventName, value, properties);
+  }
+
+  async onClose?(): Promise<void> {
+    return this.client.destroy();
   }
 
-  //Transform the context into an object useful for the Split API, an key string with arbitrary Split "Attributes".
+  //Transform the context into an object useful for the Split API, an key string with arbitrary Split 'Attributes'.
   private transformContext(context: EvaluationContext): Consumer {
     const { targetingKey, ...attributes } = context;
     return {
@@ -169,7 +237,7 @@ export class OpenFeatureSplitProvider implements Provider {
     // we may want to allow the parsing to be customized.
     try {
       const value = JSON.parse(stringValue);
-      if (typeof value !== "object") {
+      if (typeof value !== 'object') {
         throw new ParseError(
           `Flag value ${stringValue} had unexpected type ${typeof value}, expected "object"`
         );

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/js-split-provider';