Release v0.1.0

.eslintrc

@@ -67,7 +67,8 @@
       ],
       "rules": {
         "no-restricted-syntax": ["error", "ForOfStatement", "ForInStatement", "ArrayPattern"],
-        "compat/compat": ["error", "defaults, not ie < 10, not node < 6"]
+        "compat/compat": ["error", "defaults, not ie < 10, not node < 6"],
+        "no-throw-literal": "error"
       },
       "parserOptions": {
         "ecmaVersion": 2015,

.nvmrc

@@ -1 +1 @@
-v10.16
+v14

CHANGES.txt

@@ -1,4 +1,4 @@
-0.0.1-beta1 (February 5, 2021)
+0.1.0 (March 30, 2021)
  - Initial public release. It includes common modules to be consumed by the different Split implementations written in JavaScript. Based on the original JS SDK in the `javascript-client` repository.
  - It's designed with a modular approach, with the following goals in mind:
    - Dependents should be able to include the modules that are needed for, as an example, a storage.

jest.config.js

@@ -2,7 +2,7 @@ module.exports = {
   preset: 'ts-jest',
 
   // Test files are .js and .ts files inside of __tests__ folders and with a suffix of .test or .spec
-  testMatch: ['**/__tests__/**/?(*.)+(spec|test).[jt]s'],
+  testMatch: ['<rootDir>/src/**/__tests__/**/?(*.)+(spec|test).[jt]s'],
 
   // Included files for test coverage (npm run test:coverage)
   collectCoverageFrom: [

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "0.0.1-beta1",
+  "version": "0.1.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -24,7 +24,8 @@
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs --importHelpers",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc"
+    "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
+    "publish:stable": "npm run check && npm run test && npm run build && npm publish"
   },
   "repository": {
     "type": "git",
@@ -61,7 +62,7 @@
     "eslint-plugin-compat": "3.7.0",
     "fetch-mock": "^9.10.7",
     "ioredis": "4.18.0",
-    "jest": "^26.4.2",
+    "jest": "^26.6.3",
     "jest-localstorage-mock": "^2.4.3",
     "js-yaml": "^3.14.0",
     "lodash": "^4.17.20",

src/evaluator/Engine.ts

@@ -8,6 +8,7 @@ import { ISplit, MaybeThenable } from '../dtos/types';
 import { SplitIO } from '../types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluation, IEvaluationResult, IEvaluator, ISplitEvaluator } from './types';
+import { ILogger } from '../logger/types';
 
 function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
   return {
@@ -26,9 +27,9 @@ export default class Engine {
     }
   }
 
-  static parse(splitFlatStructure: ISplit, storage: IStorageSync | IStorageAsync) {
+  static parse(log: ILogger, splitFlatStructure: ISplit, storage: IStorageSync | IStorageAsync) {
     const conditions = splitFlatStructure.conditions;
-    const evaluator = parser(conditions, storage);
+    const evaluator = parser(log, conditions, storage);
 
     return new Engine(splitFlatStructure, evaluator);
   }

src/evaluator/__tests__/evaluate-feature.spec.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import { evaluateFeature } from '../index';
 import * as LabelsConstants from '../../utils/labels';
+import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 
 const splitsMock = {
   regular: '{"changeNumber":1487277320548,"trafficAllocationSeed":1667452163,"trafficAllocation":100,"trafficTypeName":"user","name":"always-on","seed":1684183541,"configurations":{},"status":"ACTIVE","killed":false,"defaultTreatment":"off","conditions":[{"conditionType":"ROLLOUT","matcherGroup":{"combiner":"AND","matchers":[{"keySelector":{"trafficType":"user","attribute":""},"matcherType":"ALL_KEYS","negate":false,"userDefinedSegmentMatcherData":{"segmentName":""},"unaryNumericMatcherData":{"dataType":"","value":0},"whitelistMatcherData":{"whitelist":null},"betweenMatcherData":{"dataType":"","start":0,"end":0}}]},"partitions":[{"treatment":"on","size":100},{"treatment":"off","size":0}],"label":"in segment all"}]}',
@@ -31,10 +32,11 @@ test('EVALUATOR / should return label exception, treatment control and config nu
     config: null
   };
   const evaluationPromise = evaluateFeature(
+    loggerMock,
     'fake-key',
     'throw_exception',
     null,
-    mockStorage
+    mockStorage,
   );
 
   // This validation is async because the only exception possible when retrieving a Split would happen with Async storages.
@@ -54,79 +56,88 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
   };
 
   const evaluationWithConfig = evaluateFeature(
+    loggerMock,
     'fake-key',
     'config',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationWithConfig).toEqual(expectedOutput); // If the split is retrieved successfully we should get the right evaluation result, label and config.
 
   const evaluationNotFound = evaluateFeature(
+    loggerMock,
     'fake-key',
     'not_existent_split',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationNotFound).toEqual(expectedOutputControl); // If the split is not retrieved successfully because it does not exist, we should get the right evaluation result, label and config.
 
   const evaluation = evaluateFeature(
+    loggerMock,
     'fake-key',
     'regular',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluation).toEqual({ ...expectedOutput, config: null }); // If the split is retrieved successfully we should get the right evaluation result, label and config. If Split has no config it should have config equal null.
 
   const evaluationKilled = evaluateFeature(
+    loggerMock,
     'fake-key',
     'killed',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationKilled).toEqual({ ...expectedOutput, treatment: 'off', config: null, label: LabelsConstants.SPLIT_KILLED });
   // If the split is retrieved but is killed, we should get the right evaluation result, label and config.
 
   const evaluationArchived = evaluateFeature(
+    loggerMock,
     'fake-key',
     'archived',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationArchived).toEqual({ ...expectedOutput, treatment: 'control', label: LabelsConstants.SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
 
   const evaluationtrafficAlocation1 = evaluateFeature(
+    loggerMock,
     'fake-key',
     'trafficAlocation1',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationtrafficAlocation1).toEqual({ ...expectedOutput, label: LabelsConstants.NOT_IN_SPLIT, config: null, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.
 
   const evaluationKilledWithConfig = evaluateFeature(
+    loggerMock,
     'fake-key',
     'killedWithConfig',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationKilledWithConfig).toEqual({ ...expectedOutput, treatment: 'off', label: LabelsConstants.SPLIT_KILLED });
   // If the split is retrieved but is killed, we should get the right evaluation result, label and config.
 
   const evaluationArchivedWithConfig = evaluateFeature(
+    loggerMock,
     'fake-key',
     'archivedWithConfig',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationArchivedWithConfig).toEqual({ ...expectedOutput, treatment: 'control', label: LabelsConstants.SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
 
   const evaluationtrafficAlocation1WithConfig = evaluateFeature(
+    loggerMock,
     'fake-key',
     'trafficAlocation1WithConfig',
     null,
-    mockStorage
+    mockStorage,
   );
   expect(evaluationtrafficAlocation1WithConfig).toEqual({ ...expectedOutput, label: LabelsConstants.NOT_IN_SPLIT, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.

src/evaluator/__tests__/evaluate-features.spec.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import { evaluateFeatures } from '../index';
 import * as LabelsConstants from '../../utils/labels';
+import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 
 const splitsMock = {
   regular: '{"changeNumber":1487277320548,"trafficAllocationSeed":1667452163,"trafficAllocation":100,"trafficTypeName":"user","name":"always-on","seed":1684183541,"configurations":{},"status":"ACTIVE","killed":false,"defaultTreatment":"off","conditions":[{"conditionType":"ROLLOUT","matcherGroup":{"combiner":"AND","matchers":[{"keySelector":{"trafficType":"user","attribute":""},"matcherType":"ALL_KEYS","negate":false,"userDefinedSegmentMatcherData":{"segmentName":""},"unaryNumericMatcherData":{"dataType":"","value":0},"whitelistMatcherData":{"whitelist":null},"betweenMatcherData":{"dataType":"","start":0,"end":0}}]},"partitions":[{"treatment":"on","size":100},{"treatment":"off","size":0}],"label":"in segment all"}]}',
@@ -43,10 +44,11 @@ test('EVALUATOR - Multiple evaluations at once  / should return label exception,
 
   // This validation is async because the only exception possible when retrieving a Split would happen with Async storages.
   const evaluation = await evaluateFeatures(
+    loggerMock,
     'fake-key',
     ['throw_exception'],
     null,
-    mockStorage
+    mockStorage,
   );
 
   expect(evaluation).toEqual(expectedOutput); // If there was an error on the `getSplits` we should get the results for exception.
@@ -66,10 +68,11 @@ test('EVALUATOR - Multiple evaluations at once / should return right labels, tre
   };
 
   const multipleEvaluationAtOnce = await evaluateFeatures(
+    loggerMock,
     'fake-key',
     ['config', 'not_existent_split', 'regular', 'killed', 'archived', 'trafficAlocation1', 'killedWithConfig', 'archivedWithConfig', 'trafficAlocation1WithConfig'],
     null,
-    mockStorage
+    mockStorage,
   );
   // assert evaluationWithConfig
   expect(multipleEvaluationAtOnce['config']).toEqual(expectedOutput['config']); // If the split is retrieved successfully we should get the right evaluation result, label and config.

src/evaluator/combiners/__tests__/and.spec.ts

@@ -1,15 +1,16 @@
 import andCombiner from '../and';
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
 
 test('COMBINER AND / should always return true', async function () {
 
-  let AND = andCombiner([() => true, () => true, () => true]);
+  let AND = andCombiner(loggerMock, [() => true, () => true, () => true]);
 
   expect(await AND('always true')).toBe(true); // should always return true
 });
 
 test('COMBINER AND / should always return false', async function () {
 
-  let AND = andCombiner([() => true, () => true, () => false]);
+  let AND = andCombiner(loggerMock, [() => true, () => true, () => false]);
 
   expect(await AND('always false')).toBe(false); // should always return false
 });

src/evaluator/combiners/__tests__/ifelseif.spec.ts

@@ -1,5 +1,6 @@
 // @ts-nocheck
 import ifElseIfCombinerFactory from '../ifelseif';
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
 
 test('IF ELSE IF COMBINER / should correctly propagate context parameters and predicates returns value', async function () {
   let inputKey = 'sample';
@@ -16,7 +17,7 @@ test('IF ELSE IF COMBINER / should correctly propagate context parameters and pr
   }
 
   let predicates = [evaluator];
-  let ifElseIfEvaluator = ifElseIfCombinerFactory(predicates);
+  let ifElseIfEvaluator = ifElseIfCombinerFactory(loggerMock, predicates);
 
   expect(await ifElseIfEvaluator(inputKey, inputSeed, inputAttributes) === evaluationResult).toBe(true);
   console.log(`evaluator should return ${evaluationResult}`);
@@ -35,7 +36,7 @@ test('IF ELSE IF COMBINER / should stop evaluating when one matcher return a tre
     }
   ];
 
-  let ifElseIfEvaluator = ifElseIfCombinerFactory(predicates);
+  let ifElseIfEvaluator = ifElseIfCombinerFactory(loggerMock, predicates);
 
   expect(await ifElseIfEvaluator()).toBe('exclude'); // exclude treatment found
 });
@@ -53,7 +54,7 @@ test('IF ELSE IF COMBINER / should return undefined if there is none matching ru
     }
   ];
 
-  const ifElseIfEvaluator = ifElseIfCombinerFactory(predicates);
+  const ifElseIfEvaluator = ifElseIfCombinerFactory(loggerMock, predicates);
 
   expect(await ifElseIfEvaluator() === undefined).toBe(true);
 });

src/evaluator/combiners/and.ts

@@ -1,19 +1,19 @@
 import { findIndex } from '../../utils/lang';
-import { logFactory } from '../../logger/sdkLogger';
-const log = logFactory('splitio-engine:combiner');
+import { ILogger } from '../../logger/types';
 import thenable from '../../utils/promise/thenable';
 import { MaybeThenable } from '../../dtos/types';
 import { IMatcher } from '../types';
+import { ENGINE_COMBINER_AND } from '../../logger/constants';
 
-function andResults(results: boolean[]): boolean {
-  // Array.prototype.every is supported by target environments
-  const hasMatchedAll = results.every(value => value);
+export default function andCombinerContext(log: ILogger, matchers: IMatcher[]) {
 
-  log.debug(`[andCombiner] evaluates to ${hasMatchedAll}`);
-  return hasMatchedAll;
-}
+  function andResults(results: boolean[]): boolean {
+    // Array.prototype.every is supported by target environments
+    const hasMatchedAll = results.every(value => value);
 
-export default function andCombinerContext(matchers: IMatcher[]) {
+    log.debug(ENGINE_COMBINER_AND, [hasMatchedAll]);
+    return hasMatchedAll;
+  }
 
   return function andCombiner(...params: any): MaybeThenable<boolean> {
     const matcherResults = matchers.map(matcher => matcher(...params));

src/evaluator/combiners/ifelseif.ts

@@ -1,39 +1,39 @@
 import { findIndex } from '../../utils/lang';
-import { logFactory } from '../../logger/sdkLogger';
-const log = logFactory('splitio-engine:combiner');
+import { ILogger } from '../../logger/types';
 import thenable from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
 import { CONTROL } from '../../utils/constants';
 import { SplitIO } from '../../types';
 import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
+import { ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ERROR_ENGINE_COMBINER_IFELSEIF } from '../../logger/constants';
 
-function unexpectedInputHandler() {
-  log.error('Invalid Split provided, no valid conditions found');
+export default function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator {
 
-  return {
-    treatment: CONTROL,
-    label: LabelsConstants.EXCEPTION
-  };
-}
+  function unexpectedInputHandler() {
+    log.error(ERROR_ENGINE_COMBINER_IFELSEIF);
 
-function computeTreatment(predicateResults: Array<IEvaluation | undefined>) {
-  const len = predicateResults.length;
+    return {
+      treatment: CONTROL,
+      label: LabelsConstants.EXCEPTION
+    };
+  }
 
-  for (let i = 0; i < len; i++) {
-    const evaluation = predicateResults[i];
+  function computeTreatment(predicateResults: Array<IEvaluation | undefined>) {
+    const len = predicateResults.length;
 
-    if (evaluation !== undefined) {
-      log.debug(`Treatment found: ${evaluation.treatment}`);
+    for (let i = 0; i < len; i++) {
+      const evaluation = predicateResults[i];
 
-      return evaluation;
-    }
-  }
+      if (evaluation !== undefined) {
+        log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
 
-  log.debug('All predicates evaluated, no treatment found.');
-  return undefined;
-}
+        return evaluation;
+      }
+    }
 
-export default function ifElseIfCombinerContext(predicates: IEvaluator[]): IEvaluator {
+    log.debug(ENGINE_COMBINER_IFELSEIF_NO_TREATMENT);
+    return undefined;
+  }
 
   function ifElseIfCombiner(key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
     // In Async environments we are going to have async predicates. There is none way to know

src/evaluator/condition/__tests__/engineUtils.spec.ts

@@ -1,5 +1,6 @@
 import * as engineUtils from '../engineUtils';
 import Treatments from '../../treatments';
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
 
 const treatmentsMock = Treatments.parse([{
   treatment: 'on',
@@ -15,7 +16,7 @@ test('ENGINE / should always evaluate to "off"', () => {
 
   let startTime = Date.now();
 
-  expect(engineUtils.getTreatment(bucketingKey, seed, treatmentsMock) === 'off').toBe(true); // treatment should be 'off'
+  expect(engineUtils.getTreatment(loggerMock, bucketingKey, seed, treatmentsMock) === 'off').toBe(true); // treatment should be 'off'
 
 
   let endTime = Date.now();
@@ -29,7 +30,7 @@ test('ENGINE / should always evaluate to "on"', () => {
 
   let startTime = Date.now();
 
-  expect(engineUtils.getTreatment(bucketingKey, seed, treatmentsMock) === 'on').toBe(true); // treatment should be 'on'
+  expect(engineUtils.getTreatment(loggerMock, bucketingKey, seed, treatmentsMock) === 'on').toBe(true); // treatment should be 'on'
 
   let endTime = Date.now();