@splitsoftware/openfeature-js-split-provider 1.0.7 → 1.2.0

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

@@ -1,44 +1,67 @@
 import {
   EvaluationContext,
-  Provider,
-  ResolutionDetails,
-  ParseError,
   FlagNotFoundError,
   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 = {
-  key: string | undefined;
+  targetingKey: string | undefined;
+  trafficType: string;
   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;
-
-  constructor(options: SplitProviderOptions) {
-    this.client = options.splitClient;
-    this.initialized = new Promise((resolve) => {
-      this.client.on(this.client.Event.SDK_READY, () => {
-        console.log(`${this.metadata.name} provider initialized`);
-        resolve();
-      });
-    });
+
+  private client: SplitIO.IClient | SplitIO.IAsyncClient;
+  private trafficType: string;
+  public readonly events = new OpenFeatureEventEmitter();
+
+  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) {
+    // Asume 'user' as default traffic type'
+    this.trafficType = 'user';
+    this.client = this.getSplitClient(options);
+    this.client.on(this.client.Event.SDK_UPDATE, () => {
+      this.events.emit(ProviderEvents.ConfigurationChanged);
+    }); 
   }
 
-  async resolveBooleanEvaluation(
+  public async resolveBooleanEvaluation(
     flagKey: string,
     _: boolean,
     context: EvaluationContext
@@ -47,36 +70,20 @@ export class OpenFeatureSplitProvider implements Provider {
       flagKey,
       this.transformContext(context)
     );
+    const treatment = details.value.toLowerCase();
+
+    if ( treatment === 'on' || treatment === 'true' ) {
+      return { ...details, value: true };
+    }
 
-    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 === 'off' || treatment === 'false' ) {
+      return { ...details, value: false };
     }
-    return { ...details, value };
+
+    throw new ParseError(`Invalid boolean value for ${treatment}`);
   }
 
-  async resolveStringEvaluation(
+  public async resolveStringEvaluation(
     flagKey: string,
     _: string,
     context: EvaluationContext
@@ -85,13 +92,10 @@ export class OpenFeatureSplitProvider implements Provider {
       flagKey,
       this.transformContext(context)
     );
-    if (details.value === "control") {
-      throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
-    }
     return details;
   }
 
-  async resolveNumberEvaluation(
+  public async resolveNumberEvaluation(
     flagKey: string,
     _: number,
     context: EvaluationContext
@@ -103,7 +107,7 @@ export class OpenFeatureSplitProvider implements Provider {
     return { ...details, value: this.parseValidNumber(details.value) };
   }
 
-  async resolveObjectEvaluation<U extends JsonValue>(
+  public async resolveObjectEvaluation<U extends JsonValue>(
     flagKey: string,
     _: U,
     context: EvaluationContext
@@ -119,31 +123,82 @@ export class OpenFeatureSplitProvider implements Provider {
     flagKey: string,
     consumer: Consumer
   ): Promise<ResolutionDetails<string>> {
-    if (!consumer.key) {
+    if (!consumer.targetingKey) {
       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 new Promise((resolve, reject) => {
+      this.readinessHandler(resolve, reject);
+    });
+    
+    const { treatment: value, config }: SplitIO.TreatmentWithConfig = await this.client.getTreatmentWithConfig(
+      consumer.targetingKey,
+      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> {
+
+    // eventName is always required
+    if (trackingEventName == null || trackingEventName === '')
+      throw new ParseError('Missing eventName, required to track');
+
+    // targetingKey is always required
+    const { targetingKey, trafficType } = this.transformContext(context);
+    if (targetingKey == null || targetingKey === '')
+      throw new TargetingKeyMissingError('Missing targetingKey, 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);
   }
 
-  //Transform the context into an object useful for the Split API, an key string with arbitrary Split "Attributes".
+  public 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'.
   private transformContext(context: EvaluationContext): Consumer {
-    const { targetingKey, ...attributes } = context;
+    const { targetingKey, trafficType: ttVal, ...attributes } = context;
+    const trafficType =
+      ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
+        ? ttVal
+        : this.trafficType; 
     return {
-      key: targetingKey,
+      targetingKey,
+      trafficType,
       // Stringify context objects include date.
       attributes: JSON.parse(JSON.stringify(attributes)),
     };
@@ -169,7 +224,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"`
         );
@@ -179,4 +234,19 @@ export class OpenFeatureSplitProvider implements Provider {
       throw new ParseError(`Error parsing ${stringValue} as JSON, ${err}`);
     }
   }
-}
+
+  private async readinessHandler(onSdkReady: (params?: unknown) => void, onSdkTimedOut: () => void): Promise<void> {
+
+    const clientStatus = this.client.getStatus();
+    if (clientStatus.isReady) {
+      onSdkReady();
+    } else {
+      if (clientStatus.hasTimedout) {
+        onSdkTimedOut();
+      } else {
+        this.client.on(this.client.Event.SDK_READY_TIMED_OUT, onSdkTimedOut);
+      }
+      this.client.on(this.client.Event.SDK_READY, onSdkReady);
+    }
+  }
+}

package/types/index.d.ts

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

package/types/lib/js-split-provider.d.ts

@@ -0,0 +1,27 @@
+import { EvaluationContext, JsonValue, OpenFeatureEventEmitter, Provider, ResolutionDetails, TrackingEventDetails } from '@openfeature/server-sdk';
+import type SplitIO from '@splitsoftware/splitio/types/splitio';
+type SplitProviderOptions = {
+    splitClient: SplitIO.IClient | SplitIO.IAsyncClient;
+};
+export declare class OpenFeatureSplitProvider implements Provider {
+    metadata: {
+        name: string;
+    };
+    private client;
+    private trafficType;
+    readonly events: OpenFeatureEventEmitter;
+    private getSplitClient;
+    constructor(options: SplitProviderOptions | string | SplitIO.ISDK | SplitIO.IAsyncSDK);
+    resolveBooleanEvaluation(flagKey: string, _: boolean, context: EvaluationContext): Promise<ResolutionDetails<boolean>>;
+    resolveStringEvaluation(flagKey: string, _: string, context: EvaluationContext): Promise<ResolutionDetails<string>>;
+    resolveNumberEvaluation(flagKey: string, _: number, context: EvaluationContext): Promise<ResolutionDetails<number>>;
+    resolveObjectEvaluation<U extends JsonValue>(flagKey: string, _: U, context: EvaluationContext): Promise<ResolutionDetails<U>>;
+    private evaluateTreatment;
+    track(trackingEventName: string, context: EvaluationContext, details: TrackingEventDetails): Promise<void>;
+    onClose?(): Promise<void>;
+    private transformContext;
+    private parseValidNumber;
+    private parseValidJsonObject;
+    private readinessHandler;
+}
+export {};

package/src/__tests__/node.spec.js

@@ -1,7 +0,0 @@
-import tape from 'tape-catch';
-
-import clientSuite from './nodeSuites/client.spec.js';
-
-tape('## OpenFeature JavaScript Split Provider - tests', async function (assert) {
-  assert.test('Client Tests', clientSuite);
-});