@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.0

package/src/utils/inputValidation/isOperational.ts

@@ -9,14 +9,14 @@ export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadines
   return false;
 }
 
-export function validateIfReadyFromCache(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
+export function validateIfReadyFromCache(log: ILogger, readinessManager: IReadinessManager, method: string) {
   if (readinessManager.isReadyFromCache()) return true;
 
-  log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? ` for feature flag ${featureFlagNameOrNames.toString()}` : '']);
+  log.warn(CLIENT_NOT_READY_FROM_CACHE, [method]);
   return false;
 }
 
 // Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
-export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
-  return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string) {
+  return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method);
 }

package/src/utils/inputValidation/target.ts

@@ -0,0 +1,21 @@
+import { isObject } from '../lang';
+import SplitIO from '../../../types/splitio';
+import { ILogger } from '../../logger/types';
+import { validateKey } from './key';
+import { validateAttributes } from './attributes';
+import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
+
+export function validateTarget(log: ILogger, maybeTarget: any, method: string): SplitIO.Target | false {
+  if (!isObject(maybeTarget)) {
+    log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'target']);
+    return false;
+  }
+
+  const key = validateKey(log, maybeTarget.key, method);
+  if (key === false) return false;
+
+  const attributes = validateAttributes(log, maybeTarget.attributes, method);
+  if (attributes === false) return false;
+
+  return { ...maybeTarget, key, attributes };
+}

package/src/utils/labels/index.ts

@@ -2,11 +2,11 @@ import { FALLBACK_PREFIX } from '../../evaluator/fallbackTreatmentsCalculator';
 
 export const SPLIT_KILLED = 'killed';
 export const NO_CONDITION_MATCH = 'default rule';
-export const SPLIT_NOT_FOUND = 'definition not found';
+export const DEFINITION_NOT_FOUND = 'definition not found';
 export const SDK_NOT_READY = 'not ready';
 export const EXCEPTION = 'exception';
 export const SPLIT_ARCHIVED = 'archived';
 export const NOT_IN_SPLIT = 'not in split';
 export const UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 export const PREREQUISITES_NOT_MET = 'prerequisites not met';
-export const FALLBACK_SPLIT_NOT_FOUND = FALLBACK_PREFIX + SPLIT_NOT_FOUND;
+export const FALLBACK_DEFINITION_NOT_FOUND = FALLBACK_PREFIX + DEFINITION_NOT_FOUND;

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,4 +1,4 @@
-import { validateSplits } from '../inputValidation/splits';
+import { validateDefinitions } from '../inputValidation/definitions';
 import { ISplitFiltersValidation } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
@@ -49,7 +49,7 @@ function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.Sp
  */
 function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values: string[], maxLength: number) {
   // validate and remove invalid and duplicated values
-  let result = validateSplits(log, values, LOG_PREFIX_SETTINGS, `${type} filter`, `${type} filter value`);
+  let result = validateDefinitions(log, values, LOG_PREFIX_SETTINGS, `${type} filter`, `${type} filter value`);
 
   if (result) {
 
@@ -181,7 +181,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
 }
 
 export function validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] | false {
-  const sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
+  const sets = validateDefinitions(log, flagSets, method, 'flag sets', 'flag set');
   let toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
   if (flagSetsInConfig.length > 0) {
     toReturn = toReturn.filter(flagSet => {

package/types/splitio.d.ts

@@ -73,10 +73,12 @@ interface ISharedSettings {
        * const factory = SplitFactory({
        *   ...
        *   sync: {
-       *     getHeaderOverrides: (context) => {
-       *       return {
-       *         'Authorization': context.headers['Authorization'] + ', other-value',
-       *         'custom-header': 'custom-value'
+       *     requestOptions: {
+       *       getHeaderOverrides: (context) => {
+       *         return {
+       *           'Authorization': context.headers['Authorization'] + ', other-value',
+       *           'custom-header': 'custom-value'
+       *         };
        *       };
        *     }
        *   }
@@ -509,7 +511,7 @@ declare namespace SplitIO {
   /**
    * Metadata type for SDK update events.
    */
-  type SdkUpdateMetadataType = 'FLAGS_UPDATE' | 'SEGMENTS_UPDATE';
+  type SdkUpdateMetadataType = 'CONFIGS_UPDATE' | 'FLAGS_UPDATE' | 'SEGMENTS_UPDATE';
 
   /**
    * Metadata for the ready events emitted when the SDK is ready to evaluate feature flags.
@@ -1590,10 +1592,12 @@ declare namespace SplitIO {
          * const factory = SplitFactory({
          *   ...
          *   sync: {
-         *     getHeaderOverrides: (context) => {
-         *       return {
-         *         'Authorization': context.headers['Authorization'] + ', other-value',
-         *         'custom-header': 'custom-value'
+         *     requestOptions: {
+         *       getHeaderOverrides: (context) => {
+         *         return {
+         *           'Authorization': context.headers['Authorization'] + ', other-value',
+         *           'custom-header': 'custom-value'
+         *         };
          *       };
          *     }
          *   }
@@ -2284,4 +2288,193 @@ declare namespace SplitIO {
      */
     split(featureFlagName: string): SplitViewAsync;
   }
+
+  /**
+   * Fallback configuration objects returned by the `client.getConfig` method when the SDK is not ready or the provided config name is not found.
+   */
+  type FallbackConfigs = {
+    /**
+     * Fallback config for all config names.
+     */
+    global?: Config;
+    /**
+     * Fallback configs for specific config names. It takes precedence over the global fallback config.
+     */
+    byName?: {
+      [configName: string]: Config;
+    };
+  }
+
+  /**
+   * Configs SDK settings.
+   */
+  interface ConfigsClientSettings {
+    /**
+     * Your SDK key.
+     *
+     * @see {@link https://developer.harness.io/docs/feature-management-experimentation/management-and-administration/account-settings/api-keys/}
+     */
+    authorizationKey: string;
+    /**
+     * Configs definitions refresh rate for polling, in seconds.
+     *
+     * @defaultValue `60`
+     */
+    configsRefreshRate?: number;
+    /**
+     * Logging level.
+     *
+     * @defaultValue `'NONE'`
+     */
+    logLevel?: LogLevel;
+    /**
+     * Time in seconds until SDK ready timeout is emitted.
+     *
+     * @defaultValue `10`
+     */
+    timeout?: number;
+    /**
+     * Custom endpoints to replace the default ones used by the SDK.
+     */
+    urls?: {
+      /**
+       * String property to override the base URL where the SDK will get rollout plan related data, like feature flags and segments definitions.
+       *
+       * @defaultValue `'https://appconfig.split.io/api'`
+       */
+      sdk?: string;
+      /**
+       * String property to override the base URL where the SDK will post event-related information like impressions.
+       *
+       * @defaultValue `'https://events.split.io/api'`
+       */
+      events?: string;
+    };
+    /**
+     * Fallback configuration objects returned by the `client.getConfig` method when the SDK is not ready or the provided config name is not found.
+     */
+    fallbackConfigs?: FallbackConfigs;
+    /**
+     * Custom options object for HTTP(S) requests.
+     * If provided, this object is merged with the options object passed by the SDK for EventSource and Fetch calls.
+     */
+    requestOptions?: {
+      /**
+       * Custom function called before each request, allowing you to add or update headers in SDK HTTP requests.
+       * Some headers, such as `SplitSDKVersion`, are required by the SDK and cannot be overridden.
+       * To pass multiple headers with the same name, combine their values into a single line, separated by commas. Example: `{ 'Authorization': 'value1, value2' }`
+       * Or provide keys with different cases since headers are case-insensitive. Example: `{ 'authorization': 'value1', 'Authorization': 'value2' }`
+       *
+       * @defaultValue `undefined`
+       *
+       * @param context - The context for the request, which contains the `headers` property object representing the current headers in the request.
+       * @returns An object representing a set of headers to be merged with the current headers.
+       *
+       * @example
+       * ```
+       * const client = ConfigsClient({
+       *   ...
+       *   requestOptions: {
+       *     getHeaderOverrides: (context) => {
+       *       return {
+       *         'Authorization': context.headers['Authorization'] + ', other-value',
+       *         'custom-header': 'custom-value'
+       *       };
+       *     }
+       *   }
+       * });
+       * ```
+       */
+      getHeaderOverrides?: (context: { headers: Record<string, string>; }) => Record<string, string>;
+      /**
+       * Custom Node.js HTTP(S) Agent used by the SDK for HTTP(S) requests.
+       *
+       * You can use it, for example, for certificate pinning or setting a network proxy:
+       *
+       * ```
+       * const { HttpsProxyAgent } = require('https-proxy-agent');
+       *
+       * const proxyAgent = new HttpsProxyAgent(process.env.HTTPS_PROXY || 'http://10.10.1.10:1080');
+       *
+       * const client = ConfigsClient({
+       *   ...
+       *   requestOptions: {
+       *     agent: proxyAgent
+       *   }
+       * })
+       * ```
+       *
+       * @see {@link https://nodejs.org/api/https.html#class-httpsagent}
+       *
+       * @defaultValue `undefined`
+       */
+      agent?: RequestOptions['agent'];
+    };
+  }
+
+  /**
+   * Target for a config evaluation.
+   */
+  interface Target {
+    /**
+     * The key of the target.
+     */
+    key: SplitKey;
+    /**
+     * The attributes of the target.
+     *
+     * @defaultValue `undefined`
+     */
+    attributes?: Attributes;
+  }
+
+  type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+  type JsonArray = JsonValue[];
+  type JsonObject = { [key: string]: JsonValue; };
+
+  /**
+   * Config object returned by getConfig.
+   */
+  type Config = {
+    /**
+     * The name of the variant.
+     */
+    variant: string;
+    /**
+     * The config value, a raw JSON object.
+     */
+    value: JsonObject;
+  }
+
+  /**
+   * Configs SDK client interface.
+   */
+  interface ConfigsClient extends IStatusInterface {
+    /**
+     * Destroys the client.
+     *
+     * @returns A promise that resolves once all clients are destroyed.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Gets the config object for a given config name and optional target. If no target is provided, the default variant of the config is returned.
+     *
+     * @param configName - The name of the config we want to get.
+     * @param target - The target of the config evaluation.
+     * @param options - An object of type EvaluationOptions for advanced evaluation options.
+     * @returns The config object.
+     */
+    getConfig(configName: string, target?: Target, options?: EvaluationOptions): Config;
+    /**
+     * Tracks an event to be fed to the results product on Harness FME user interface.
+     *
+     * @param trafficKey - The key that identifies the entity related to this event.
+     * @param trafficType - The traffic type of the entity related to this event. See {@link https://developer.harness.io/docs/feature-management-experimentation/management-and-administration/fme-settings/traffic-types/}
+     * @param eventType - The event type corresponding to this event.
+     * @param value - The value of this event.
+     * @param properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns Whether the event was added to the queue successfully or not.
+     */
+    track(trafficKey: SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): boolean;
+  }
 }

package/cjs/sync/polling/syncTasks/splitsSyncTask.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitsSyncTaskFactory = void 0;
-var syncTask_1 = require("../../syncTask");
-var splitChangesFetcher_1 = require("../fetchers/splitChangesFetcher");
-var splitChangesUpdater_1 = require("../updaters/splitChangesUpdater");
-/**
- * Creates a sync task that periodically executes a `splitChangesUpdater` task
- */
-function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges, settings, storage), storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
-}
-exports.splitsSyncTaskFactory = splitsSyncTaskFactory;

package/cjs/utils/inputValidation/splits.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplits = void 0;
-var constants_1 = require("../../logger/constants");
-var lang_1 = require("../lang");
-var split_1 = require("./split");
-function validateSplits(log, maybeSplits, method, listName, item) {
-    if (listName === void 0) { listName = 'feature flag names'; }
-    if (item === void 0) { item = 'feature flag name'; }
-    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-        var validatedArray_1 = [];
-        // Remove invalid values
-        maybeSplits.forEach(function (maybeSplit) {
-            var splitName = (0, split_1.validateSplit)(log, maybeSplit, method, item);
-            if (splitName)
-                validatedArray_1.push(splitName);
-        });
-        // Strip off duplicated values if we have valid split names then return
-        if (validatedArray_1.length)
-            return (0, lang_1.uniq)(validatedArray_1);
-    }
-    log.error(constants_1.ERROR_EMPTY_ARRAY, [method, listName]);
-    return false;
-}
-exports.validateSplits = validateSplits;

package/esm/sync/polling/syncTasks/splitsSyncTask.js

@@ -1,9 +0,0 @@
-import { syncTaskFactory } from '../../syncTask';
-import { splitChangesFetcherFactory } from '../fetchers/splitChangesFetcher';
-import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
-/**
- * Creates a sync task that periodically executes a `splitChangesUpdater` task
- */
-export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges, settings, storage), storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
-}

package/esm/utils/inputValidation/splitExistence.js

@@ -1,15 +0,0 @@
-import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
-import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
-/**
- * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
- */
-export function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
-    if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
-        if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
-            log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
-            return false;
-        }
-    }
-    return true;
-}

package/esm/utils/inputValidation/splits.js

@@ -1,21 +0,0 @@
-import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
-import { uniq } from '../lang';
-import { validateSplit } from './split';
-export function validateSplits(log, maybeSplits, method, listName, item) {
-    if (listName === void 0) { listName = 'feature flag names'; }
-    if (item === void 0) { item = 'feature flag name'; }
-    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-        var validatedArray_1 = [];
-        // Remove invalid values
-        maybeSplits.forEach(function (maybeSplit) {
-            var splitName = validateSplit(log, maybeSplit, method, item);
-            if (splitName)
-                validatedArray_1.push(splitName);
-        });
-        // Strip off duplicated values if we have valid split names then return
-        if (validatedArray_1.length)
-            return uniq(validatedArray_1);
-    }
-    log.error(ERROR_EMPTY_ARRAY, [method, listName]);
-    return false;
-}

package/src/utils/inputValidation/split.ts

@@ -1,27 +0,0 @@
-import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { isString } from '../lang';
-
-// include BOM and nbsp
-const TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
-
-export function validateSplit(log: ILogger, maybeSplit: any, method: string, item = 'feature flag name'): string | false {
-  if (maybeSplit == undefined) { // eslint-disable-line eqeqeq
-    log.error(ERROR_NULL, [method, item]);
-  } else if (!isString(maybeSplit)) {
-    log.error(ERROR_INVALID, [method, item]);
-  } else {
-    if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
-      log.warn(WARN_TRIMMING, [method, item, maybeSplit]);
-      maybeSplit = maybeSplit.trim();
-    }
-
-    if (maybeSplit.length > 0) {
-      return maybeSplit;
-    } else {
-      log.error(ERROR_EMPTY, [method, item]);
-    }
-  }
-
-  return false;
-}

package/src/utils/inputValidation/splitExistence.ts

@@ -1,19 +0,0 @@
-import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
-import { IReadinessManager } from '../../readiness/types';
-import { ILogger } from '../../logger/types';
-import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
-
-/**
- * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
- */
-export function validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
-  if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
-    if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
-      log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/utils/inputValidation/splits.ts

@@ -1,21 +0,0 @@
-import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { uniq } from '../lang';
-import { validateSplit } from './split';
-
-export function validateSplits(log: ILogger, maybeSplits: any, method: string, listName = 'feature flag names', item = 'feature flag name'): string[] | false {
-  if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-    let validatedArray: string[] = [];
-    // Remove invalid values
-    maybeSplits.forEach(maybeSplit => {
-      const splitName = validateSplit(log, maybeSplit, method, item);
-      if (splitName) validatedArray.push(splitName);
-    });
-
-    // Strip off duplicated values if we have valid split names then return
-    if (validatedArray.length) return uniq(validatedArray);
-  }
-
-  log.error(ERROR_EMPTY_ARRAY, [method, listName]);
-  return false;
-}