feat: Convert bucketer module to ts (#650)

* Move DecisionResponse to shared_types

* Upgrade murmurhash to v2.0.0 for TS support

* Convert module

* clean up

* Return to old murmurhash version

* set noImplicitAny to false in tsconfig to avoid compiler error

* Create type definitions for murmurhash

Author: yavorona

packages/optimizely-sdk/lib/core/bucketer/index.tests.js

@@ -18,7 +18,7 @@ import { assert, expect } from 'chai';
 import { cloneDeep } from 'lodash';
 import { sprintf } from '@optimizely/js-sdk-utils';
 
-import bucketer from './';
+import * as bucketer from './';
 import {
   ERROR_MESSAGES,
   LOG_MESSAGES,

packages/optimizely-sdk/lib/core/bucketer/index.js renamed to packages/optimizely-sdk/lib/core/bucketer/index.ts

@@ -19,18 +19,48 @@
  */
 import { sprintf } from '@optimizely/js-sdk-utils';
 import murmurhash from 'murmurhash';
+import { LogHandler } from '@optimizely/js-sdk-logging';
+import {
+  DecisionResponse,
+  Experiment,
+  Variation
+} from '../../shared_types';
 
 import {
   ERROR_MESSAGES,
   LOG_LEVEL,
   LOG_MESSAGES,
 } from '../../utils/enums';
 
-var HASH_SEED = 1;
-var MAX_HASH_VALUE = Math.pow(2, 32);
-var MAX_TRAFFIC_VALUE = 10000;
-var MODULE_NAME = 'BUCKETER';
-var RANDOM_POLICY = 'random';
+const HASH_SEED = 1;
+const MAX_HASH_VALUE = Math.pow(2, 32);
+const MAX_TRAFFIC_VALUE = 10000;
+const MODULE_NAME = 'BUCKETER';
+const RANDOM_POLICY = 'random';
+
+interface TrafficAllocation {
+  entityId: string;
+  endOfRange: number;
+}
+
+interface Group {
+  id: string;
+  policy: string;
+  trafficAllocation: TrafficAllocation[];
+}
+
+interface BucketerParams {
+  experimentId: string;
+  experimentKey: string;
+  userId: string;
+  trafficAllocationConfig: TrafficAllocation[];
+  experimentKeyMap: { [key: string]: Experiment };
+  groupIdMap: { [key: string]: Group };
+  variationIdMap: { [id: string]: Variation } ;
+  varationIdMapKey: string;
+  logger: LogHandler;
+  bucketingId: string;
+}
 
 /**
  * Determines ID of variation to be shown for the given input params
@@ -48,18 +78,18 @@ var RANDOM_POLICY = 'random';
  * @return {Object}             DecisionResponse                         DecisionResponse containing variation ID that user has been bucketed into,
  *                                                                       null if user is not bucketed into any experiment and the decide reasons.
  */
-export var bucket = function(bucketerParams) {
-  var decideReasons = [];
+export const bucket = function(bucketerParams: BucketerParams):  DecisionResponse<string | null> {
+  const decideReasons: string[] = [];
   // Check if user is in a random group; if so, check if user is bucketed into a specific experiment
-  var experiment = bucketerParams.experimentKeyMap[bucketerParams.experimentKey];
-  var groupId = experiment['groupId'];
+  const experiment = bucketerParams.experimentKeyMap[bucketerParams.experimentKey];
+  const groupId = experiment['groupId'];
   if (groupId) {
-    var group = bucketerParams.groupIdMap[groupId];
+    const group = bucketerParams.groupIdMap[groupId];
     if (!group) {
       throw new Error(sprintf(ERROR_MESSAGES.INVALID_GROUP_ID, MODULE_NAME, groupId));
     }
     if (group.policy === RANDOM_POLICY) {
-      var bucketedExperimentId = this.bucketUserIntoExperiment(
+      const bucketedExperimentId = bucketUserIntoExperiment(
         group,
         bucketerParams.bucketingId,
         bucketerParams.userId,
@@ -68,7 +98,7 @@ export var bucket = function(bucketerParams) {
 
       // Return if user is not bucketed into any experiment
       if (bucketedExperimentId === null) {
-        var notbucketedInAnyExperimentLogMessage = sprintf(
+        const notbucketedInAnyExperimentLogMessage = sprintf(
           LOG_MESSAGES.USER_NOT_IN_ANY_EXPERIMENT,
           MODULE_NAME,
           bucketerParams.userId,
@@ -84,7 +114,7 @@ export var bucket = function(bucketerParams) {
 
       // Return if user is bucketed into a different experiment than the one specified
       if (bucketedExperimentId !== bucketerParams.experimentId) {
-        var notBucketedIntoExperimentOfGroupLogMessage = sprintf(
+        const notBucketedIntoExperimentOfGroupLogMessage = sprintf(
           LOG_MESSAGES.USER_NOT_BUCKETED_INTO_EXPERIMENT_IN_GROUP,
           MODULE_NAME,
           bucketerParams.userId,
@@ -100,7 +130,7 @@ export var bucket = function(bucketerParams) {
       }
 
       // Continue bucketing if user is bucketed into specified experiment
-      var bucketedIntoExperimentOfGroupLogMessage = sprintf(
+      const bucketedIntoExperimentOfGroupLogMessage = sprintf(
         LOG_MESSAGES.USER_BUCKETED_INTO_EXPERIMENT_IN_GROUP,
         MODULE_NAME,
         bucketerParams.userId,
@@ -111,10 +141,10 @@ export var bucket = function(bucketerParams) {
       decideReasons.push(bucketedIntoExperimentOfGroupLogMessage);
     }
   }
-  var bucketingId = sprintf('%s%s', bucketerParams.bucketingId, bucketerParams.experimentId);
-  var bucketValue = this._generateBucketValue(bucketingId);
+  const bucketingId = sprintf('%s%s', bucketerParams.bucketingId, bucketerParams.experimentId);
+  const bucketValue = _generateBucketValue(bucketingId);
 
-  var bucketedUserLogMessage = sprintf(
+  const bucketedUserLogMessage = sprintf(
     LOG_MESSAGES.USER_ASSIGNED_TO_EXPERIMENT_BUCKET,
     MODULE_NAME,
     bucketValue,
@@ -123,18 +153,19 @@ export var bucket = function(bucketerParams) {
   bucketerParams.logger.log(LOG_LEVEL.DEBUG, bucketedUserLogMessage);
   decideReasons.push(bucketedUserLogMessage);
 
-  var entityId = this._findBucket(bucketValue, bucketerParams.trafficAllocationConfig);
-
-  if (!bucketerParams.variationIdMap.hasOwnProperty(entityId)) {
-    if (entityId) {
-      var invalidVariationIdLogMessage = sprintf(LOG_MESSAGES.INVALID_VARIATION_ID, MODULE_NAME);
-      bucketerParams.logger.log(LOG_LEVEL.WARNING, invalidVariationIdLogMessage);
-      decideReasons.push(invalidVariationIdLogMessage);
+  const entityId = _findBucket(bucketValue, bucketerParams.trafficAllocationConfig);
+  if (entityId !== null) {
+    if (!bucketerParams.variationIdMap[entityId]) {
+      if (entityId) {
+        const invalidVariationIdLogMessage = sprintf(LOG_MESSAGES.INVALID_VARIATION_ID, MODULE_NAME);
+        bucketerParams.logger.log(LOG_LEVEL.WARNING, invalidVariationIdLogMessage);
+        decideReasons.push(invalidVariationIdLogMessage);
+      }
+      return {
+        result: null,
+        reasons: decideReasons,
+      };
     }
-    return {
-      result: null,
-      reasons: decideReasons,
-    };
   }
 
   return {
@@ -145,54 +176,63 @@ export var bucket = function(bucketerParams) {
 
 /**
  * Returns bucketed experiment ID to compare against experiment user is being called into
- * @param {Object} group        Group that experiment is in
- * @param {string} bucketingId  Bucketing ID
- * @param {string} userId       ID of user to be bucketed into experiment
- * @param {Object} logger       Logger implementation
- * @return {string|null} ID of experiment if user is bucketed into experiment within the group, null otherwise
+ * @param  {Group}       group        Group that experiment is in
+ * @param  {string}      bucketingId  Bucketing ID
+ * @param  {string}      userId       ID of user to be bucketed into experiment
+ * @param  {LogHandler}  logger       Logger implementation
+ * @return {string|null}              ID of experiment if user is bucketed into experiment within the group, null otherwise
  */
-export var bucketUserIntoExperiment = function(group, bucketingId, userId, logger) {
-  var bucketingKey = sprintf('%s%s', bucketingId, group.id);
-  var bucketValue = this._generateBucketValue(bucketingKey);
+export const bucketUserIntoExperiment = function(
+  group: Group,
+  bucketingId: string,
+  userId: string,
+  logger: LogHandler
+  ): string | null {
+  const bucketingKey = sprintf('%s%s', bucketingId, group.id);
+  const bucketValue = _generateBucketValue(bucketingKey);
   logger.log(
     LOG_LEVEL.DEBUG,
     sprintf(LOG_MESSAGES.USER_ASSIGNED_TO_EXPERIMENT_BUCKET, MODULE_NAME, bucketValue, userId)
   );
-  var trafficAllocationConfig = group.trafficAllocation;
-  var bucketedExperimentId = this._findBucket(bucketValue, trafficAllocationConfig);
+  const trafficAllocationConfig = group.trafficAllocation;
+  const bucketedExperimentId = _findBucket(bucketValue, trafficAllocationConfig);
   return bucketedExperimentId;
 };
 
 /**
  * Returns entity ID associated with bucket value
- * @param  {string}   bucketValue
- * @param  {Object[]} trafficAllocationConfig
- * @param  {number}   trafficAllocationConfig[].endOfRange
- * @param  {number}   trafficAllocationConfig[].entityId
- * @return {string|null}   Entity ID for bucketing if bucket value is within traffic allocation boundaries, null otherwise
+ * @param  {number}                bucketValue
+ * @param  {TrafficAllocation[]}   trafficAllocationConfig
+ * @param  {number}                trafficAllocationConfig[].endOfRange
+ * @param  {string}                trafficAllocationConfig[].entityId
+ * @return {string|null}           Entity ID for bucketing if bucket value is within traffic allocation boundaries, null otherwise
  */
-export var _findBucket = function(bucketValue, trafficAllocationConfig) {
-  for (var i = 0; i < trafficAllocationConfig.length; i++) {
+export const _findBucket = function(
+  bucketValue: number,
+  trafficAllocationConfig: TrafficAllocation[]
+  ): string | null {
+  for (let i = 0; i < trafficAllocationConfig.length; i++) {
     if (bucketValue < trafficAllocationConfig[i].endOfRange) {
       return trafficAllocationConfig[i].entityId;
     }
   }
+
   return null;
 };
 
 /**
  * Helper function to generate bucket value in half-closed interval [0, MAX_TRAFFIC_VALUE)
- * @param  {string} bucketingKey String value for bucketing
- * @return {string} the generated bucket value
- * @throws If bucketing value is not a valid string
+ * @param  {string}               bucketingKey          String value for bucketing
+ * @return {number}               The generated bucket value
+ * @throws                        If bucketing value is not a valid string
  */
-export var _generateBucketValue = function(bucketingKey) {
+export const _generateBucketValue = function(bucketingKey: string): number {
   try {
     // NOTE: the mmh library already does cast the hash value as an unsigned 32bit int
     // https://github.com/perezd/node-murmurhash/blob/master/murmurhash.js#L115
-    var hashValue = murmurhash.v3(bucketingKey, HASH_SEED);
-    var ratio = hashValue / MAX_HASH_VALUE;
-    return parseInt(ratio * MAX_TRAFFIC_VALUE, 10);
+    const hashValue = murmurhash.v3(bucketingKey, HASH_SEED);
+    const ratio = hashValue / MAX_HASH_VALUE;
+    return Math.floor(ratio * MAX_TRAFFIC_VALUE);
   } catch (ex) {
     throw new Error(sprintf(ERROR_MESSAGES.INVALID_BUCKETING_ID, MODULE_NAME, bucketingKey, ex.message));
   }
@@ -201,6 +241,4 @@ export var _generateBucketValue = function(bucketingKey) {
 export default {
   bucket: bucket,
   bucketUserIntoExperiment: bucketUserIntoExperiment,
-  _findBucket: _findBucket,
-  _generateBucketValue: _generateBucketValue,
 };

packages/optimizely-sdk/lib/core/decision_service/index.d.ts

@@ -20,14 +20,10 @@ import {
   UserProfileService,
   FeatureFlag,
   Experiment,
-  Variation
+  Variation,
+  DecisionResponse
 } from '../../shared_types';
 
-interface DecisionResponse<T> {
-  readonly result: T;
-  readonly reasons: string[];
-}
-
 /**
  * Creates an instance of the DecisionService.
  * @param  {Options}          options        Configuration options

packages/optimizely-sdk/lib/shared_types.ts

@@ -15,6 +15,11 @@
  */
 import { ErrorHandler, LogHandler, LogLevel } from "@optimizely/js-sdk-logging";
 
+export interface DecisionResponse<T> {
+  readonly result: T;
+  readonly reasons: string[];
+}
+
 export type UserAttributes = {
   // TODO[OASIS-6649]: Don't use any type
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
@@ -95,7 +100,8 @@ export interface Experiment {
   id: string;
   key: string;
   variations: Variation[];
-  variationKeyMap: { [key: string]: Variation }
+  variationKeyMap: { [key: string]: Variation };
+  groupId?: string;
 }
 
 export interface FeatureVariable {

packages/optimizely-sdk/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
+    "types": ["./typings"],
     "allowJs": true,
     "declaration": false,
     "module": "esnext",

packages/optimizely-sdk/typings/index.d.ts

@@ -0,0 +1,10 @@
+declare module 'murmurhash' {
+  /**
+   * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011)
+   *
+   * @param key - ASCII only
+   * @param seed - (optional) positive integer
+   * @returns 32-bit positive integer hash
+   */
+  function v3(key: string | Uint8Array, seed?: number): number;
+}