diff --git a/lib/client_factory.ts b/lib/client_factory.ts index 898df5575..187334cc4 100644 --- a/lib/client_factory.ts +++ b/lib/client_factory.ts @@ -24,11 +24,18 @@ import { extractConfigManager } from "./project_config/config_manager_factory"; import { extractEventProcessor } from "./event_processor/event_processor_factory"; import { extractOdpManager } from "./odp/odp_manager_factory"; import { extractVuidManager } from "./vuid/vuid_manager_factory"; - -import { CLIENT_VERSION, JAVASCRIPT_CLIENT_ENGINE } from "./utils/enums"; +import { RequestHandler } from "./utils/http_request_handler/http"; +import { CLIENT_VERSION, DEFAULT_CMAB_CACHE_SIZE, DEFAULT_CMAB_CACHE_TIMEOUT, JAVASCRIPT_CLIENT_ENGINE } from "./utils/enums"; import Optimizely from "./optimizely"; +import { DefaultCmabClient } from "./core/decision_service/cmab/cmab_client"; +import { CmabCacheValue, DefaultCmabService } from "./core/decision_service/cmab/cmab_service"; +import { InMemoryLruCache } from "./utils/cache/in_memory_lru_cache"; + +export type OptimizelyFactoryConfig = Config & { + requestHandler: RequestHandler; +} -export const getOptimizelyInstance = (config: Config): Client | null => { +export const getOptimizelyInstance = (config: OptimizelyFactoryConfig): Client | null => { let logger: Maybe; try { @@ -43,6 +50,7 @@ export const getOptimizelyInstance = (config: Config): Client | null => { userProfileService, defaultDecideOptions, disposable, + requestHandler, } = config; const errorNotifier = config.errorNotifier ? extractErrorNotifier(config.errorNotifier) : undefined; @@ -52,7 +60,17 @@ export const getOptimizelyInstance = (config: Config): Client | null => { const odpManager = config.odpManager ? extractOdpManager(config.odpManager) : undefined; const vuidManager = config.vuidManager ? extractVuidManager(config.vuidManager) : undefined; + const cmabClient = new DefaultCmabClient({ + requestHandler, + }); + + const cmabService = new DefaultCmabService({ + cmabClient, + cmabCache: new InMemoryLruCache(DEFAULT_CMAB_CACHE_SIZE, DEFAULT_CMAB_CACHE_TIMEOUT), + }); + const optimizelyOptions = { + cmabService, clientEngine: clientEngine || JAVASCRIPT_CLIENT_ENGINE, clientVersion: clientVersion || CLIENT_VERSION, jsonSchemaValidator, diff --git a/lib/core/bucketer/index.ts b/lib/core/bucketer/index.ts index b2455b95a..686f49abd 100644 --- a/lib/core/bucketer/index.ts +++ b/lib/core/bucketer/index.ts @@ -27,6 +27,7 @@ import { import { INVALID_GROUP_ID } from 'error_message'; import { OptimizelyError } from '../../error/optimizly_error'; import { generateBucketValue } from './bucket_value_generator'; +import { DecisionReason } from '../decision_service'; export const USER_NOT_IN_ANY_EXPERIMENT = 'User %s is not in any experiment of group %s.'; export const USER_NOT_BUCKETED_INTO_EXPERIMENT_IN_GROUP = 'User %s is not in experiment %s of group %s.'; @@ -52,7 +53,7 @@ const RANDOM_POLICY = 'random'; * null if user is not bucketed into any experiment and the decide reasons. */ export const bucket = function(bucketerParams: BucketerParams): DecisionResponse { - const decideReasons: (string | number)[][] = []; + const decideReasons: DecisionReason[] = []; // Check if user is in a random group; if so, check if user is bucketed into a specific experiment const experiment = bucketerParams.experimentIdMap[bucketerParams.experimentId]; const groupId = experiment['groupId']; diff --git a/lib/core/decision_service/cmab/cmab_service.spec.ts b/lib/core/decision_service/cmab/cmab_service.spec.ts index 2e571932d..dce84f6e1 100644 --- a/lib/core/decision_service/cmab/cmab_service.spec.ts +++ b/lib/core/decision_service/cmab/cmab_service.spec.ts @@ -68,7 +68,7 @@ describe('DefaultCmabService', () => { }); const ruleId = '1234'; - const variation = await cmabService.getDecision(projectConfig, userContext, ruleId, []); + const variation = await cmabService.getDecision(projectConfig, userContext, ruleId, {}); expect(variation.variationId).toEqual('123'); expect(uuidValidate(variation.cmabUuid)).toBe(true); @@ -101,8 +101,8 @@ describe('DefaultCmabService', () => { gender: 'male' }); - await cmabService.getDecision(projectConfig, userContext, '1234', []); - await cmabService.getDecision(projectConfig, userContext, '5678', []); + await cmabService.getDecision(projectConfig, userContext, '1234', {}); + await cmabService.getDecision(projectConfig, userContext, '5678', {}); expect(mockCmabClient.fetchDecision).toHaveBeenCalledTimes(2); expect(mockCmabClient.fetchDecision.mock.calls[0][2]).toEqual({ @@ -136,7 +136,7 @@ describe('DefaultCmabService', () => { gender: 'male' }); - const variation11 = await cmabService.getDecision(projectConfig, userContext11, '1234', []); + const variation11 = await cmabService.getDecision(projectConfig, userContext11, '1234', {}); const userContext12 = mockUserContext('user123', { country: 'US', @@ -145,7 +145,7 @@ describe('DefaultCmabService', () => { gender: 'female' }); - const variation12 = await cmabService.getDecision(projectConfig, userContext12, '1234', []); + const variation12 = await cmabService.getDecision(projectConfig, userContext12, '1234', {}); expect(variation11.variationId).toEqual('123'); expect(variation12.variationId).toEqual('123'); expect(variation11.cmabUuid).toEqual(variation12.cmabUuid); @@ -157,14 +157,14 @@ describe('DefaultCmabService', () => { age: '30', }); - const variation21 = await cmabService.getDecision(projectConfig, userContext21, '5678', []); + const variation21 = await cmabService.getDecision(projectConfig, userContext21, '5678', {}); const userContext22 = mockUserContext('user456', { country: 'BD', age: '35', }); - const variation22 = await cmabService.getDecision(projectConfig, userContext22, '5678', []); + const variation22 = await cmabService.getDecision(projectConfig, userContext22, '5678', {}); expect(variation21.variationId).toEqual('456'); expect(variation22.variationId).toEqual('456'); expect(variation21.cmabUuid).toEqual(variation22.cmabUuid); @@ -192,7 +192,7 @@ describe('DefaultCmabService', () => { gender: 'male' }); - const variation11 = await cmabService.getDecision(projectConfig, userContext11, '1234', []); + const variation11 = await cmabService.getDecision(projectConfig, userContext11, '1234', {}); const userContext12 = mockUserContext('user123', { gender: 'female', @@ -201,7 +201,7 @@ describe('DefaultCmabService', () => { age: '25', }); - const variation12 = await cmabService.getDecision(projectConfig, userContext12, '1234', []); + const variation12 = await cmabService.getDecision(projectConfig, userContext12, '1234', {}); expect(variation11.variationId).toEqual('123'); expect(variation12.variationId).toEqual('123'); expect(variation11.cmabUuid).toEqual(variation12.cmabUuid); @@ -227,9 +227,9 @@ describe('DefaultCmabService', () => { age: '25', }); - const variation1 = await cmabService.getDecision(projectConfig, userContext, '1234', []); + const variation1 = await cmabService.getDecision(projectConfig, userContext, '1234', {}); - const variation2 = await cmabService.getDecision(projectConfig, userContext, '5678', []); + const variation2 = await cmabService.getDecision(projectConfig, userContext, '5678', {}); expect(variation1.variationId).toEqual('123'); expect(variation2.variationId).toEqual('456'); @@ -260,9 +260,9 @@ describe('DefaultCmabService', () => { age: '25', }); - const variation1 = await cmabService.getDecision(projectConfig, userContext1, '1234', []); + const variation1 = await cmabService.getDecision(projectConfig, userContext1, '1234', {}); - const variation2 = await cmabService.getDecision(projectConfig, userContext2, '1234', []); + const variation2 = await cmabService.getDecision(projectConfig, userContext2, '1234', {}); expect(variation1.variationId).toEqual('123'); expect(variation2.variationId).toEqual('456'); expect(variation1.cmabUuid).not.toEqual(variation2.cmabUuid); @@ -289,7 +289,7 @@ describe('DefaultCmabService', () => { gender: 'male' }); - const variation1 = await cmabService.getDecision(projectConfig, userContext1, '1234', []); + const variation1 = await cmabService.getDecision(projectConfig, userContext1, '1234', {}); const userContext2 = mockUserContext('user123', { country: 'US', @@ -298,7 +298,7 @@ describe('DefaultCmabService', () => { gender: 'male' }); - const variation2 = await cmabService.getDecision(projectConfig, userContext2, '1234', []); + const variation2 = await cmabService.getDecision(projectConfig, userContext2, '1234', {}); expect(variation1.variationId).toEqual('123'); expect(variation2.variationId).toEqual('456'); expect(variation1.cmabUuid).not.toEqual(variation2.cmabUuid); @@ -325,13 +325,13 @@ describe('DefaultCmabService', () => { gender: 'male' }); - const variation1 = await cmabService.getDecision(projectConfig, userContext, '1234', []); + const variation1 = await cmabService.getDecision(projectConfig, userContext, '1234', {}); - const variation2 = await cmabService.getDecision(projectConfig, userContext, '1234', [ - OptimizelyDecideOption.IGNORE_CMAB_CACHE, - ]); + const variation2 = await cmabService.getDecision(projectConfig, userContext, '1234', { + [OptimizelyDecideOption.IGNORE_CMAB_CACHE]: true, + }); - const variation3 = await cmabService.getDecision(projectConfig, userContext, '1234', []); + const variation3 = await cmabService.getDecision(projectConfig, userContext, '1234', {}); expect(variation1.variationId).toEqual('123'); expect(variation2.variationId).toEqual('456'); @@ -367,18 +367,19 @@ describe('DefaultCmabService', () => { age: '50' }); - const variation1 = await cmabService.getDecision(projectConfig, userContext1, '1234', []); + const variation1 = await cmabService.getDecision(projectConfig, userContext1, '1234', {}); expect(variation1.variationId).toEqual('123'); - const variation2 = await cmabService.getDecision(projectConfig, userContext2, '1234', []); + const variation2 = await cmabService.getDecision(projectConfig, userContext2, '1234', {}); expect(variation2.variationId).toEqual('456'); - const variation3 = await cmabService.getDecision(projectConfig, userContext1, '1234', [ - OptimizelyDecideOption.RESET_CMAB_CACHE, - ]); + const variation3 = await cmabService.getDecision(projectConfig, userContext1, '1234', { + [OptimizelyDecideOption.RESET_CMAB_CACHE]: true, + }); + expect(variation3.variationId).toEqual('789'); - const variation4 = await cmabService.getDecision(projectConfig, userContext2, '1234', []); + const variation4 = await cmabService.getDecision(projectConfig, userContext2, '1234', {}); expect(variation4.variationId).toEqual('101112'); }); @@ -401,13 +402,13 @@ describe('DefaultCmabService', () => { gender: 'male' }); - const variation1 = await cmabService.getDecision(projectConfig, userContext, '1234', []); + const variation1 = await cmabService.getDecision(projectConfig, userContext, '1234', {}); - const variation2 = await cmabService.getDecision(projectConfig, userContext, '1234', [ - OptimizelyDecideOption.INVALIDATE_USER_CMAB_CACHE, - ]); + const variation2 = await cmabService.getDecision(projectConfig, userContext, '1234', { + [OptimizelyDecideOption.INVALIDATE_USER_CMAB_CACHE]: true, + }); - const variation3 = await cmabService.getDecision(projectConfig, userContext, '1234', []); + const variation3 = await cmabService.getDecision(projectConfig, userContext, '1234', {}); expect(variation1.variationId).toEqual('123'); expect(variation2.variationId).toEqual('456'); diff --git a/lib/core/decision_service/cmab/cmab_service.ts b/lib/core/decision_service/cmab/cmab_service.ts index 2eaffd4fd..b4f958fbf 100644 --- a/lib/core/decision_service/cmab/cmab_service.ts +++ b/lib/core/decision_service/cmab/cmab_service.ts @@ -15,14 +15,14 @@ */ import { LoggerFacade } from "../../../logging/logger"; -import OptimizelyUserContext from "../../../optimizely_user_context" +import { IOptimizelyUserContext } from "../../../optimizely_user_context"; import { ProjectConfig } from "../../../project_config/project_config" import { OptimizelyDecideOption, UserAttributes } from "../../../shared_types" import { Cache } from "../../../utils/cache/cache"; import { CmabClient } from "./cmab_client"; import { v4 as uuidV4 } from 'uuid'; import murmurhash from "murmurhash"; -import { a } from "vitest/dist/chunks/suite.CcK46U-P"; +import { DecideOptionsMap } from ".."; export type CmabDecision = { variationId: string, @@ -32,16 +32,16 @@ export type CmabDecision = { export interface CmabService { /** * Get variation id for the user - * @param {OptimizelyUserContext} userContext + * @param {IOptimizelyUserContext} userContext * @param {string} ruleId * @param {OptimizelyDecideOption[]} options * @return {Promise} */ getDecision( projectConfig: ProjectConfig, - userContext: OptimizelyUserContext, + userContext: IOptimizelyUserContext, ruleId: string, - options: OptimizelyDecideOption[] + options: DecideOptionsMap, ): Promise } @@ -70,23 +70,23 @@ export class DefaultCmabService implements CmabService { async getDecision( projectConfig: ProjectConfig, - userContext: OptimizelyUserContext, + userContext: IOptimizelyUserContext, ruleId: string, - options: OptimizelyDecideOption[] + options: DecideOptionsMap, ): Promise { const filteredAttributes = this.filterAttributes(projectConfig, userContext, ruleId); - if (options.includes(OptimizelyDecideOption.IGNORE_CMAB_CACHE)) { + if (options[OptimizelyDecideOption.IGNORE_CMAB_CACHE]) { return this.fetchDecision(ruleId, userContext.getUserId(), filteredAttributes); } - if (options.includes(OptimizelyDecideOption.RESET_CMAB_CACHE)) { + if (options[OptimizelyDecideOption.RESET_CMAB_CACHE]) { this.cmabCache.clear(); } const cacheKey = this.getCacheKey(userContext.getUserId(), ruleId); - if (options.includes(OptimizelyDecideOption.INVALIDATE_USER_CMAB_CACHE)) { + if (options[OptimizelyDecideOption.INVALIDATE_USER_CMAB_CACHE]) { this.cmabCache.remove(cacheKey); } @@ -125,7 +125,7 @@ export class DefaultCmabService implements CmabService { private filterAttributes( projectConfig: ProjectConfig, - userContext: OptimizelyUserContext, + userContext: IOptimizelyUserContext, ruleId: string ): UserAttributes { const filteredAttributes: UserAttributes = {}; diff --git a/lib/core/decision_service/index.spec.ts b/lib/core/decision_service/index.spec.ts index cbfbaf7be..f3459ef0e 100644 --- a/lib/core/decision_service/index.spec.ts +++ b/lib/core/decision_service/index.spec.ts @@ -14,15 +14,16 @@ * limitations under the License. */ import { describe, it, expect, vi, MockInstance, beforeEach } from 'vitest'; -import { DecisionService } from '.'; +import { CMAB_FETCH_FAILED, DecisionService } from '.'; import { getMockLogger } from '../../tests/mock/mock_logger'; import OptimizelyUserContext from '../../optimizely_user_context'; import { bucket } from '../bucketer'; import { getTestProjectConfig, getTestProjectConfigWithFeatures } from '../../tests/test_data'; import { createProjectConfig, ProjectConfig } from '../../project_config/project_config'; -import { BucketerParams, Experiment, UserProfile } from '../../shared_types'; +import { BucketerParams, Experiment, OptimizelyDecideOption, UserProfile } from '../../shared_types'; import { CONTROL_ATTRIBUTES, DECISION_SOURCES } from '../../utils/enums'; import { getDecisionTestDatafile } from '../../tests/decision_test_datafile'; +import { Value } from '../../utils/promise/operation_value'; import { USER_HAS_NO_FORCED_VARIATION, @@ -49,15 +50,20 @@ import { } from '../decision_service/index'; import { BUCKETING_ID_NOT_STRING, USER_PROFILE_LOOKUP_ERROR, USER_PROFILE_SAVE_ERROR } from 'error_message'; -import exp from 'constants'; type MockLogger = ReturnType; +type MockFnType = ReturnType; + type MockUserProfileService = { - lookup: ReturnType; - save: ReturnType; + lookup: MockFnType; + save: MockFnType; }; +type MockCmabService = { + getDecision: MockFnType; +} + type DecisionServiceInstanceOpt = { logger?: boolean; userProfileService?: boolean; @@ -66,6 +72,7 @@ type DecisionServiceInstanceOpt = { type DecisionServiceInstance = { logger?: MockLogger; userProfileService?: MockUserProfileService; + cmabService: MockCmabService; decisionService: DecisionService; } @@ -76,16 +83,22 @@ const getDecisionService = (opt: DecisionServiceInstanceOpt = {}): DecisionServi save: vi.fn(), } : undefined; + const cmabService = { + getDecision: vi.fn(), + }; + const decisionService = new DecisionService({ logger, userProfileService, UNSTABLE_conditionEvaluators: {}, + cmabService, }); return { logger, userProfileService, decisionService, + cmabService, }; }; @@ -764,7 +777,7 @@ describe('DecisionService', () => { }); }); - describe('getVariationForFeature', () => { + describe('getVariationForFeature - sync', () => { beforeEach(() => { mockBucket.mockReset(); }); @@ -774,22 +787,23 @@ describe('DecisionService', () => { const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') .mockImplementation(( + op, config, experiment: any, user, - shouldIgnoreUPS, - userProfileTracker + decideOptions, + userProfileTracker: any, ) => { if (experiment.key === 'exp_2') { - return { - result: 'variation_2', + return Value.of('sync', { + result: { variationKey: 'variation_2' }, reasons: [], - }; + }); } - return { - result: null, + return Value.of('sync', { + result: {}, reasons: [], - } + }); }); const config = createProjectConfig(getDecisionTestDatafile()); @@ -813,9 +827,9 @@ describe('DecisionService', () => { expect(resolveVariationSpy).toHaveBeenCalledTimes(2); expect(resolveVariationSpy).toHaveBeenNthCalledWith(1, - config, config.experimentKeyMap['exp_1'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_1'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(2, - config, config.experimentKeyMap['exp_2'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_2'], user, expect.anything(), expect.anything()); }); it('should return the variation forced for an experiment in the userContext if available', () => { @@ -823,22 +837,23 @@ describe('DecisionService', () => { const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') .mockImplementation(( + op, config, experiment: any, user, - shouldIgnoreUPS, - userProfileTracker + decideOptions, + userProfileTracker: any, ) => { if (experiment.key === 'exp_2') { - return { - result: 'variation_2', + return Value.of('sync', { + result: { varationKey: 'variation_2' }, reasons: [], - }; + }); } - return { - result: null, + return Value.of('sync', { + result: {}, reasons: [], - } + }); }); const config = createProjectConfig(getDecisionTestDatafile()); @@ -871,10 +886,11 @@ describe('DecisionService', () => { const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') .mockImplementation(( + op, config, experiment: any, user, - shouldIgnoreUPS, + decideOptions, userProfileTracker: any, ) => { if (experiment.key === 'exp_2') { @@ -885,15 +901,15 @@ describe('DecisionService', () => { }; userProfileTracker.isProfileUpdated = true; - return { - result: 'variation_2', + return Value.of('sync', { + result: { variationKey: 'variation_2' }, reasons: [], - }; + }); } - return { - result: null, + return Value.of('sync', { + result: {}, reasons: [], - } + }); }); const config = createProjectConfig(getDecisionTestDatafile()); @@ -958,10 +974,10 @@ describe('DecisionService', () => { const { decisionService } = getDecisionService(); const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') - .mockReturnValue({ - result: null, + .mockReturnValue(Value.of('sync', { + result: {}, reasons: [], - }); + })); const config = createProjectConfig(getDecisionTestDatafile()); @@ -998,11 +1014,11 @@ describe('DecisionService', () => { expect(resolveVariationSpy).toHaveBeenCalledTimes(3); expect(resolveVariationSpy).toHaveBeenNthCalledWith(1, - config, config.experimentKeyMap['exp_1'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_1'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(2, - config, config.experimentKeyMap['exp_2'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_2'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(3, - config, config.experimentKeyMap['exp_3'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_3'], user, expect.anything(), expect.anything()); expect(mockBucket).toHaveBeenCalledTimes(1); verifyBucketCall(0, config, config.experimentIdMap['3002'], user); @@ -1012,10 +1028,10 @@ describe('DecisionService', () => { const { decisionService } = getDecisionService(); const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') - .mockReturnValue({ - result: null, + .mockReturnValue(Value.of('sync', { + result: {}, reasons: [], - }); + })); const config = createProjectConfig(getDecisionTestDatafile()); @@ -1053,11 +1069,11 @@ describe('DecisionService', () => { expect(resolveVariationSpy).toHaveBeenCalledTimes(3); expect(resolveVariationSpy).toHaveBeenNthCalledWith(1, - config, config.experimentKeyMap['exp_1'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_1'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(2, - config, config.experimentKeyMap['exp_2'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_2'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(3, - config, config.experimentKeyMap['exp_3'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_3'], user, expect.anything(), expect.anything()); expect(mockBucket).toHaveBeenCalledTimes(1); verifyBucketCall(0, config, config.experimentIdMap['3002'], user, true); @@ -1068,10 +1084,10 @@ describe('DecisionService', () => { const { decisionService } = getDecisionService(); const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') - .mockReturnValue({ - result: null, + .mockReturnValue(Value.of('sync', { + result: {}, reasons: [], - }); + })); const config = createProjectConfig(getDecisionTestDatafile()); @@ -1108,11 +1124,11 @@ describe('DecisionService', () => { expect(resolveVariationSpy).toHaveBeenCalledTimes(3); expect(resolveVariationSpy).toHaveBeenNthCalledWith(1, - config, config.experimentKeyMap['exp_1'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_1'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(2, - config, config.experimentKeyMap['exp_2'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_2'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(3, - config, config.experimentKeyMap['exp_3'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_3'], user, expect.anything(), expect.anything()); expect(mockBucket).toHaveBeenCalledTimes(2); verifyBucketCall(0, config, config.experimentIdMap['3002'], user); @@ -1127,16 +1143,17 @@ describe('DecisionService', () => { const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') .mockImplementation(( + op, config, experiment: any, user, - shouldIgnoreUPS, - userProfileTracker + decideOptions, + userProfileTracker: any, ) => { - return { - result: null, + return Value.of('sync', { + result: {}, reasons: [], - } + }); }); const config = createProjectConfig(getDecisionTestDatafile()); @@ -1166,10 +1183,10 @@ describe('DecisionService', () => { const { decisionService } = getDecisionService(); const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') - .mockReturnValue({ - result: null, + .mockReturnValue(Value.of('sync', { + result: {}, reasons: [], - }); + })); const config = createProjectConfig(getDecisionTestDatafile()); @@ -1206,11 +1223,11 @@ describe('DecisionService', () => { expect(resolveVariationSpy).toHaveBeenCalledTimes(3); expect(resolveVariationSpy).toHaveBeenNthCalledWith(1, - config, config.experimentKeyMap['exp_1'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_1'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(2, - config, config.experimentKeyMap['exp_2'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_2'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(3, - config, config.experimentKeyMap['exp_3'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_3'], user, expect.anything(), expect.anything()); expect(mockBucket).toHaveBeenCalledTimes(1); verifyBucketCall(0, config, config.experimentIdMap['default-rollout-id'], user); @@ -1220,10 +1237,10 @@ describe('DecisionService', () => { const { decisionService } = getDecisionService(); const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') - .mockReturnValue({ - result: null, + .mockReturnValue(Value.of('sync', { + result: {}, reasons: [], - }); + })); const config = createProjectConfig(getDecisionTestDatafile()); const rolloutId = config.featureKeyMap['flag_1'].rolloutId; @@ -1248,16 +1265,236 @@ describe('DecisionService', () => { expect(resolveVariationSpy).toHaveBeenCalledTimes(3); expect(resolveVariationSpy).toHaveBeenNthCalledWith(1, - config, config.experimentKeyMap['exp_1'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_1'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(2, - config, config.experimentKeyMap['exp_2'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_2'], user, expect.anything(), expect.anything()); expect(resolveVariationSpy).toHaveBeenNthCalledWith(3, - config, config.experimentKeyMap['exp_3'], user, false, expect.anything()); + 'sync', config, config.experimentKeyMap['exp_3'], user, expect.anything(), expect.anything()); expect(mockBucket).toHaveBeenCalledTimes(0); }); }); + describe('resolveVariationForFeatureList - async', () => { + beforeEach(() => { + mockBucket.mockReset(); + }); + + it('should return variation from the first experiment for which a variation is available', async () => { + const { decisionService } = getDecisionService(); + const config = createProjectConfig(getDecisionTestDatafile()); + + const user = new OptimizelyUserContext({ + optimizely: {} as any, + userId: 'tester', + attributes: { + age: 15, // should satisfy audience condition for all experiments + }, + }); + + mockBucket.mockImplementation((param: BucketerParams) => { + const ruleKey = param.experimentKey; + if (ruleKey === 'exp_2') { + return { + result: '5002', + reasons: [], + }; + } + return { + result: null, + reasons: [], + }; + }); + + const feature = config.featureKeyMap['flag_1']; + const value = decisionService.resolveVariationsForFeatureList('async', config, [feature], user, {}).get(); + expect(value).toBeInstanceOf(Promise); + + const variation = (await value)[0]; + expect(variation.result).toEqual({ + experiment: config.experimentKeyMap['exp_2'], + variation: config.variationIdMap['5002'], + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }); + }); + + it('should get decision from the cmab service if the experiment is a cmab experiment', async () => { + const { decisionService, cmabService } = getDecisionService(); + const config = createProjectConfig(getDecisionTestDatafile()); + + const user = new OptimizelyUserContext({ + optimizely: {} as any, + userId: 'tester', + attributes: { + country: 'BD', + age: 80, // should satisfy audience condition for exp_3 which is cmab and not others + }, + }); + + cmabService.getDecision.mockResolvedValue({ + variationId: '5003', + cmabUuid: 'uuid-test', + }); + + const feature = config.featureKeyMap['flag_1']; + const value = decisionService.resolveVariationsForFeatureList('async', config, [feature], user, {}).get(); + expect(value).toBeInstanceOf(Promise); + + const variation = (await value)[0]; + expect(variation.result).toEqual({ + cmabUuid: 'uuid-test', + experiment: config.experimentKeyMap['exp_3'], + variation: config.variationIdMap['5003'], + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }); + + expect(cmabService.getDecision).toHaveBeenCalledTimes(1); + expect(cmabService.getDecision).toHaveBeenCalledWith( + config, + user, + '2003', // id of exp_3 + {}, + ); + }); + + it('should pass the correct DecideOptionMap to cmabService', async () => { + const { decisionService, cmabService } = getDecisionService(); + const config = createProjectConfig(getDecisionTestDatafile()); + + const user = new OptimizelyUserContext({ + optimizely: {} as any, + userId: 'tester', + attributes: { + country: 'BD', + age: 80, // should satisfy audience condition for exp_3 which is cmab and not others + }, + }); + + cmabService.getDecision.mockResolvedValue({ + variationId: '5003', + cmabUuid: 'uuid-test', + }); + + const feature = config.featureKeyMap['flag_1']; + const value = decisionService.resolveVariationsForFeatureList('async', config, [feature], user, { + [OptimizelyDecideOption.RESET_CMAB_CACHE]: true, + [OptimizelyDecideOption.INVALIDATE_USER_CMAB_CACHE]: true, + }).get(); + expect(value).toBeInstanceOf(Promise); + + const variation = (await value)[0]; + expect(variation.result).toEqual({ + cmabUuid: 'uuid-test', + experiment: config.experimentKeyMap['exp_3'], + variation: config.variationIdMap['5003'], + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }); + + expect(cmabService.getDecision).toHaveBeenCalledTimes(1); + expect(cmabService.getDecision).toHaveBeenCalledWith( + config, + user, + '2003', // id of exp_3 + { + [OptimizelyDecideOption.RESET_CMAB_CACHE]: true, + [OptimizelyDecideOption.INVALIDATE_USER_CMAB_CACHE]: true, + }, + ); + }); + + it('should return error if cmab getDecision fails', async () => { + const { decisionService, cmabService } = getDecisionService(); + const config = createProjectConfig(getDecisionTestDatafile()); + + const user = new OptimizelyUserContext({ + optimizely: {} as any, + userId: 'tester', + attributes: { + country: 'BD', + age: 80, // should satisfy audience condition for exp_3 which is cmab and not others + }, + }); + + cmabService.getDecision.mockRejectedValue(new Error('I am an error')); + + const feature = config.featureKeyMap['flag_1']; + const value = decisionService.resolveVariationsForFeatureList('async', config, [feature], user, {}).get(); + expect(value).toBeInstanceOf(Promise); + + const variation = (await value)[0]; + + expect(variation.error).toBe(true); + expect(variation.result).toEqual({ + experiment: config.experimentKeyMap['exp_3'], + variation: null, + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }); + + expect(variation.reasons).toContainEqual( + [CMAB_FETCH_FAILED, 'exp_3'], + ); + + expect(cmabService.getDecision).toHaveBeenCalledTimes(1); + expect(cmabService.getDecision).toHaveBeenCalledWith( + config, + user, + '2003', // id of exp_3 + {}, + ); + }); + }); + + describe('resolveVariationForFeatureList - sync', () => { + beforeEach(() => { + mockBucket.mockReset(); + }); + + it('should skip cmab experiments', async () => { + const { decisionService, cmabService } = getDecisionService(); + const config = createProjectConfig(getDecisionTestDatafile()); + + const user = new OptimizelyUserContext({ + optimizely: {} as any, + userId: 'tester', + attributes: { + age: 15, // should satisfy audience condition for all experiments and targeted delivery + }, + }); + + mockBucket.mockImplementation((param: BucketerParams) => { + const ruleKey = param.experimentKey; + if (ruleKey === 'delivery_1') { + return { + result: '5004', + reasons: [], + }; + } + return { + result: null, + reasons: [], + }; + }); + + const feature = config.featureKeyMap['flag_1']; + const value = decisionService.resolveVariationsForFeatureList('sync', config, [feature], user, {}).get(); + + const variation = value[0]; + + expect(variation.result).toEqual({ + experiment: config.experimentKeyMap['delivery_1'], + variation: config.variationIdMap['5004'], + decisionSource: DECISION_SOURCES.ROLLOUT, + }); + + expect(mockBucket).toHaveBeenCalledTimes(3); + verifyBucketCall(0, config, config.experimentKeyMap['exp_1'], user); + verifyBucketCall(1, config, config.experimentKeyMap['exp_2'], user); + verifyBucketCall(2, config, config.experimentKeyMap['delivery_1'], user); + + expect(cmabService.getDecision).not.toHaveBeenCalled(); + }); + }); + describe('getVariationsForFeatureList', () => { beforeEach(() => { mockBucket.mockReset(); @@ -1268,27 +1505,28 @@ describe('DecisionService', () => { const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') .mockImplementation(( + op, config, experiment: any, user, - shouldIgnoreUPS, - userProfileTracker + decideOptions, + userProfileTracker: any, ) => { if (experiment.key === 'exp_2') { - return { - result: 'variation_2', + return Value.of('sync', { + result: { variationKey: 'variation_2' }, reasons: [], - }; + }); } else if (experiment.key === 'exp_4') { - return { - result: 'variation_flag_2', + return Value.of('sync', { + result: { variationKey: 'variation_flag_2' }, reasons: [], - }; + }); } - return { - result: null, + return Value.of('sync', { + result: {}, reasons: [], - } + }); }); const config = createProjectConfig(getDecisionTestDatafile()); @@ -1340,10 +1578,11 @@ describe('DecisionService', () => { const resolveVariationSpy = vi.spyOn(decisionService as any, 'resolveVariation') .mockImplementation(( + op, config, experiment: any, user, - shouldIgnoreUPS, + decideOptions, userProfileTracker: any, ) => { if (experiment.key === 'exp_2') { @@ -1352,25 +1591,25 @@ describe('DecisionService', () => { }; userProfileTracker.isProfileUpdated = true; - return { - result: 'variation_2', + return Value.of('sync', { + result: { variationKey: 'variation_2' }, reasons: [], - }; + }); } else if (experiment.key === 'exp_4') { userProfileTracker.userProfile[experiment.id] = { variation_id: '5100', }; userProfileTracker.isProfileUpdated = true; - return { - result: 'variation_flag_2', + return Value.of('sync', { + result: { variationKey: 'variation_flag_2' }, reasons: [], - }; + }); } - return { - result: null, + return Value.of('sync', { + result: {}, reasons: [], - } + }); }); const config = createProjectConfig(getDecisionTestDatafile()); diff --git a/lib/core/decision_service/index.tests.js b/lib/core/decision_service/index.tests.js index 8dd68aa88..98f9dde70 100644 --- a/lib/core/decision_service/index.tests.js +++ b/lib/core/decision_service/index.tests.js @@ -34,6 +34,7 @@ import AudienceEvaluator from '../audience_evaluator'; import eventDispatcher from '../../event_processor/event_dispatcher/default_dispatcher.browser'; import * as jsonSchemaValidator from '../../utils/json_schema_validator'; import { getMockProjectConfigManager } from '../../tests/mock/mock_project_config_manager'; +import { Value } from '../../utils/promise/operation_value'; import { getTestProjectConfig, @@ -1207,10 +1208,10 @@ describe('lib/core/decision_service', function() { var sandbox; var mockLogger = createLogger({ logLevel: LOG_LEVEL.INFO }); var fakeDecisionResponseWithArgs; - var fakeDecisionResponse = { - result: null, + var fakeDecisionResponse = Value.of('sync', { + result: {}, reasons: [], - }; + }); var user; beforeEach(function() { configObj = projectConfig.createProjectConfig(cloneDeep(testDataWithFeatures)); @@ -1247,19 +1248,20 @@ describe('lib/core/decision_service', function() { test_attribute: 'test_value', }, }); - fakeDecisionResponseWithArgs = { - result: 'variation', + fakeDecisionResponseWithArgs = Value.of('sync', { + result: { variationKey: 'variation' }, reasons: [], - }; + }); experiment = configObj.experimentIdMap['594098']; getVariationStub = sandbox.stub(decisionServiceInstance, 'resolveVariation'); getVariationStub.returns(fakeDecisionResponse); - getVariationStub.withArgs(configObj, experiment, user).returns(fakeDecisionResponseWithArgs); + getVariationStub.withArgs('sync', configObj, experiment, user, sinon.match.any, sinon.match.any).returns(fakeDecisionResponseWithArgs); }); it('returns a decision with a variation in the experiment the feature is attached to', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; const expectedDecision = { + cmabUuid: undefined, experiment: configObj.experimentIdMap['594098'], variation: configObj.variationIdMap['594096'], decisionSource: DECISION_SOURCES.FEATURE_TEST, @@ -1268,9 +1270,12 @@ describe('lib/core/decision_service', function() { assert.deepEqual(decision, expectedDecision); sinon.assert.calledWith( getVariationStub, + 'sync', configObj, experiment, user, + sinon.match.any, + sinon.match.any ); }); }); @@ -1316,10 +1321,10 @@ describe('lib/core/decision_service', function() { optimizely: {}, userId: 'user1', }); - fakeDecisionResponseWithArgs = { - result: 'var', + fakeDecisionResponseWithArgs = Value.of('sync', { + result: { variationKey: 'var' }, reasons: [], - }; + }); getVariationStub = sandbox.stub(decisionServiceInstance, 'resolveVariation'); getVariationStub.returns(fakeDecisionResponseWithArgs); getVariationStub.withArgs(configObj, 'exp_with_group', user).returns(fakeDecisionResponseWithArgs); @@ -1328,6 +1333,7 @@ describe('lib/core/decision_service', function() { it('returns a decision with a variation in an experiment in a group', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; var expectedDecision = { + cmabUuid: undefined, experiment: configObj.experimentIdMap['595010'], variation: configObj.variationIdMap['595008'], decisionSource: DECISION_SOURCES.FEATURE_TEST, @@ -1566,10 +1572,10 @@ describe('lib/core/decision_service', function() { var feature; var getVariationStub; var bucketStub; - fakeDecisionResponse = { - result: null, + fakeDecisionResponse = Value.of('sync', { + result: {}, reasons: [], - }; + }); var fakeBucketStubDecisionResponse = { result: '599057', reasons: [], @@ -1662,6 +1668,7 @@ describe('lib/core/decision_service', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; var expectedExperiment = projectConfig.getExperimentFromKey(configObj, 'group_2_exp_1'); var expectedDecision = { + cmabUuid: undefined, experiment: expectedExperiment, variation: { id: '38901', @@ -1689,6 +1696,7 @@ describe('lib/core/decision_service', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; var expectedExperiment = projectConfig.getExperimentFromKey(configObj, 'group_2_exp_2'); var expectedDecision = { + cmabUuid: undefined, experiment: expectedExperiment, variation: { id: '38905', @@ -1716,6 +1724,7 @@ describe('lib/core/decision_service', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; var expectedExperiment = projectConfig.getExperimentFromKey(configObj, 'group_2_exp_3'); var expectedDecision = { + cmabUuid: undefined, experiment: expectedExperiment, variation: { id: '38906', @@ -1798,6 +1807,7 @@ describe('lib/core/decision_service', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; var expectedExperiment = projectConfig.getExperimentFromKey(configObj, 'test_experiment3'); var expectedDecision = { + cmabUuid: undefined, experiment: expectedExperiment, variation: { id: '222239', @@ -1826,6 +1836,7 @@ describe('lib/core/decision_service', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; var expectedExperiment = projectConfig.getExperimentFromKey(configObj, 'test_experiment4'); var expectedDecision = { + cmabUuid: undefined, experiment: expectedExperiment, variation: { id: '222240', @@ -1854,6 +1865,7 @@ describe('lib/core/decision_service', function() { var decision = decisionServiceInstance.getVariationForFeature(configObj, feature, user).result; var expectedExperiment = projectConfig.getExperimentFromKey(configObj, 'test_experiment5'); var expectedDecision = { + cmabUuid: undefined, experiment: expectedExperiment, variation: { id: '222241', diff --git a/lib/core/decision_service/index.ts b/lib/core/decision_service/index.ts index 386606cc9..e8f29cf84 100644 --- a/lib/core/decision_service/index.ts +++ b/lib/core/decision_service/index.ts @@ -48,6 +48,7 @@ import { UserProfileService, Variation, } from '../../shared_types'; + import { INVALID_USER_ID, INVALID_VARIATION_KEY, @@ -68,6 +69,9 @@ import { VARIATION_REMOVED_FOR_USER, } from 'log_message'; import { OptimizelyError } from '../../error/optimizly_error'; +import { CmabService } from './cmab/cmab_service'; +import { Maybe, OpType, OpValue } from '../../utils/type'; +import { Value } from '../../utils/promise/operation_value'; export const EXPERIMENT_NOT_RUNNING = 'Experiment %s is not running.'; export const RETURNING_STORED_VARIATION = @@ -102,17 +106,22 @@ export const USER_HAS_FORCED_DECISION_WITH_RULE_SPECIFIED_BUT_INVALID = 'Invalid variation is mapped to flag (%s), rule (%s) and user (%s) in the forced decision map.'; export const USER_HAS_FORCED_DECISION_WITH_NO_RULE_SPECIFIED_BUT_INVALID = 'Invalid variation is mapped to flag (%s) and user (%s) in the forced decision map.'; +export const CMAB_NOT_SUPPORTED_IN_SYNC = 'CMAB is not supported in sync mode.'; +export const CMAB_FETCH_FAILED = 'Failed to fetch CMAB data for experiment %s.'; +export const CMAB_FETCHED_VARIATION_INVALID = 'Fetched variation %s for cmab experiment %s is invalid.'; export interface DecisionObj { experiment: Experiment | null; variation: Variation | null; decisionSource: string; + cmabUuid?: string; } interface DecisionServiceOptions { userProfileService?: UserProfileService; logger?: LoggerFacade; UNSTABLE_conditionEvaluators: unknown; + cmabService: CmabService; } interface DeliveryRuleResponse extends DecisionResponse { @@ -124,6 +133,18 @@ interface UserProfileTracker { isProfileUpdated: boolean; } +type VarationKeyWithCmabParams = { + variationKey?: string; + cmabUuid?: string; +}; +export type DecisionReason = [string, ...any[]]; +export type VariationResult = DecisionResponse; +export type DecisionResult = DecisionResponse; +type VariationIdWithCmabParams = { + variationId? : string; + cmabUuid?: string; +}; +export type DecideOptionsMap = Partial>; /** * Optimizely's decision service that determines which variation of an experiment the user will be allocated to. * @@ -144,12 +165,18 @@ export class DecisionService { private audienceEvaluator: AudienceEvaluator; private forcedVariationMap: { [key: string]: { [id: string]: string } }; private userProfileService?: UserProfileService; + private cmabService: CmabService; constructor(options: DecisionServiceOptions) { this.logger = options.logger; this.audienceEvaluator = createAudienceEvaluator(options.UNSTABLE_conditionEvaluators, this.logger); this.forcedVariationMap = {}; this.userProfileService = options.userProfileService; + this.cmabService = options.cmabService; + } + + private isCmab(experiment: Experiment): boolean { + return !!experiment.cmab; } /** @@ -161,54 +188,51 @@ export class DecisionService { * @returns {DecisionResponse} - A DecisionResponse containing the variation the user is bucketed into, * along with the decision reasons. */ - private resolveVariation( + private resolveVariation( + op: OP, configObj: ProjectConfig, experiment: Experiment, user: OptimizelyUserContext, - shouldIgnoreUPS: boolean, - userProfileTracker: UserProfileTracker - ): DecisionResponse { + decideOptions: DecideOptionsMap, + userProfileTracker?: UserProfileTracker, + ): Value { const userId = user.getUserId(); - const attributes = user.getAttributes(); - // by default, the bucketing ID should be the user ID - const bucketingId = this.getBucketingId(userId, attributes); const experimentKey = experiment.key; - const decideReasons: (string | number)[][] = []; - if (!isActive(configObj, experimentKey)) { this.logger?.info(EXPERIMENT_NOT_RUNNING, experimentKey); - decideReasons.push([EXPERIMENT_NOT_RUNNING, experimentKey]); - return { - result: null, - reasons: decideReasons, - }; + return Value.of(op, { + result: {}, + reasons: [[EXPERIMENT_NOT_RUNNING, experimentKey]], + }); } + const decideReasons: DecisionReason[] = []; + const decisionForcedVariation = this.getForcedVariation(configObj, experimentKey, userId); decideReasons.push(...decisionForcedVariation.reasons); const forcedVariationKey = decisionForcedVariation.result; if (forcedVariationKey) { - return { - result: forcedVariationKey, + return Value.of(op, { + result: { variationKey: forcedVariationKey }, reasons: decideReasons, - }; + }); } const decisionWhitelistedVariation = this.getWhitelistedVariation(experiment, userId); decideReasons.push(...decisionWhitelistedVariation.reasons); let variation = decisionWhitelistedVariation.result; if (variation) { - return { - result: variation.key, + return Value.of(op, { + result: { variationKey: variation.key }, reasons: decideReasons, - }; + }); } - // check for sticky bucketing if decide options do not include shouldIgnoreUPS - if (!shouldIgnoreUPS) { + // check for sticky bucketing + if (userProfileTracker) { variation = this.getStoredVariation(configObj, experiment, userId, userProfileTracker.userProfile); if (variation) { this.logger?.info( @@ -223,14 +247,13 @@ export class DecisionService { experimentKey, userId, ]); - return { - result: variation.key, + return Value.of(op, { + result: { variationKey: variation.key }, reasons: decideReasons, - }; + }); } } - // Perform regular targeting and bucketing const decisionifUserIsInAudience = this.checkIfUserIsInAudience( configObj, experiment, @@ -250,57 +273,124 @@ export class DecisionService { userId, experimentKey, ]); - return { - result: null, + return Value.of(op, { + result: {}, reasons: decideReasons, - }; + }); } - const bucketerParams = this.buildBucketerParams(configObj, experiment, bucketingId, userId); - const decisionVariation = bucket(bucketerParams); - decideReasons.push(...decisionVariation.reasons); - const variationId = decisionVariation.result; - if (variationId) { - variation = configObj.variationIdMap[variationId]; - } - if (!variation) { - this.logger?.debug( - USER_HAS_NO_VARIATION, + const decisionVariationValue = this.isCmab(experiment) ? + this.getDecisionForCmabExperiment(op, configObj, experiment, user, decideOptions) : + this.getDecisionFromBucketer(op, configObj, experiment, user); + + return decisionVariationValue.then((variationResult): Value => { + decideReasons.push(...variationResult.reasons); + if (variationResult.error) { + return Value.of(op, { + error: true, + result: {}, + reasons: decideReasons, + }); + } + + const variationId = variationResult.result.variationId; + variation = variationId ? configObj.variationIdMap[variationId] : null; + if (!variation) { + this.logger?.debug( + USER_HAS_NO_VARIATION, + userId, + experimentKey, + ); + decideReasons.push([ + USER_HAS_NO_VARIATION, + userId, + experimentKey, + ]); + return Value.of(op, { + result: {}, + reasons: decideReasons, + }); + } + + this.logger?.info( + USER_HAS_VARIATION, userId, + variation.key, experimentKey, ); decideReasons.push([ - USER_HAS_NO_VARIATION, + USER_HAS_VARIATION, userId, + variation.key, experimentKey, ]); - return { - result: null, + // update experiment bucket map if decide options do not include shouldIgnoreUPS + if (userProfileTracker) { + this.updateUserProfile(experiment, variation, userProfileTracker); + } + + return Value.of(op, { + result: { variationKey: variation.key, cmabUuid: variationResult.result.cmabUuid }, reasons: decideReasons, - }; - } + }); + }); + } - this.logger?.info( - USER_HAS_VARIATION, - userId, - variation.key, - experimentKey, - ); - decideReasons.push([ - USER_HAS_VARIATION, - userId, - variation.key, - experimentKey, - ]); - // persist bucketing if decide options do not include shouldIgnoreUPS - if (!shouldIgnoreUPS) { - this.updateUserProfile(experiment, variation, userProfileTracker); + private getDecisionForCmabExperiment( + op: OP, + configObj: ProjectConfig, + experiment: Experiment, + user: OptimizelyUserContext, + decideOptions: DecideOptionsMap, + ): Value> { + if (op === 'sync') { + return Value.of(op, { + error: false, // this is not considered an error, the evaluation should continue to next rule + result: {}, + reasons: [[CMAB_NOT_SUPPORTED_IN_SYNC]], + }); } - return { - result: variation.key, - reasons: decideReasons, - }; + const cmabPromise = this.cmabService.getDecision(configObj, user, experiment.id, decideOptions).then( + (cmabDecision) => { + return { + error: false, + result: cmabDecision, + reasons: [] as DecisionReason[], + }; + } + ).catch((ex: any) => { + this.logger?.error(CMAB_FETCH_FAILED, experiment.key); + return { + error: true, + result: {}, + reasons: [[CMAB_FETCH_FAILED, experiment.key]] as DecisionReason[], + }; + }); + + return Value.of(op, cmabPromise); + } + + private getDecisionFromBucketer( + op: OP, + configObj: ProjectConfig, + experiment: Experiment, + user: OptimizelyUserContext + ): Value> { + const userId = user.getUserId(); + const attributes = user.getAttributes(); + + // by default, the bucketing ID should be the user ID + const bucketingId = this.getBucketingId(userId, attributes); + const bucketerParams = this.buildBucketerParams(configObj, experiment, bucketingId, userId); + + const decisionVariation = bucket(bucketerParams); + return Value.of(op, { + result: { + variationId: decisionVariation.result || undefined, + }, + reasons: decisionVariation.reasons, + }); } /** @@ -316,24 +406,25 @@ export class DecisionService { configObj: ProjectConfig, experiment: Experiment, user: OptimizelyUserContext, - options: { [key: string]: boolean } = {} + options: DecideOptionsMap = {} ): DecisionResponse { const shouldIgnoreUPS = options[OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE]; - const userProfileTracker: UserProfileTracker = { - isProfileUpdated: false, - userProfile: null, - } - if(!shouldIgnoreUPS) { - userProfileTracker.userProfile = this.resolveExperimentBucketMap(user.getUserId(), user.getAttributes()); - } + const userProfileTracker: Maybe = shouldIgnoreUPS ? undefined + : { + isProfileUpdated: false, + userProfile: this.resolveExperimentBucketMap('sync', user.getUserId(), user.getAttributes()).get(), + }; - const result = this.resolveVariation(configObj, experiment, user, shouldIgnoreUPS, userProfileTracker); + const result = this.resolveVariation('sync', configObj, experiment, user, options, userProfileTracker).get(); - if(!shouldIgnoreUPS) { - this.saveUserProfile(user.getUserId(), userProfileTracker) + if(userProfileTracker) { + this.saveUserProfile('sync', user.getUserId(), userProfileTracker) } - return result + return { + result: result.result.variationKey || null, + reasons: result.reasons, + } } /** @@ -342,15 +433,19 @@ export class DecisionService { * @param {UserAttributes} attributes * @return {ExperimentBucketMap} finalized copy of experiment_bucket_map */ - private resolveExperimentBucketMap( + private resolveExperimentBucketMap( + op: OP, userId: string, - attributes?: UserAttributes - ): ExperimentBucketMap { - attributes = attributes || {}; - - const userProfile = this.getUserProfile(userId) || {} as UserProfile; - const attributeExperimentBucketMap = attributes[CONTROL_ATTRIBUTES.STICKY_BUCKETING_KEY]; - return { ...userProfile.experiment_bucket_map, ...attributeExperimentBucketMap as any }; + attributes: UserAttributes = {}, + ): Value { + const fromAttributes = (attributes[CONTROL_ATTRIBUTES.STICKY_BUCKETING_KEY] || {}) as any as ExperimentBucketMap; + return this.getUserProfile(op, userId).then((userProfile) => { + const fromUserProfileService = userProfile?.experiment_bucket_map || {}; + return Value.of(op, { + ...fromUserProfileService, + ...fromAttributes, + }); + }); } /** @@ -364,7 +459,7 @@ export class DecisionService { experiment: Experiment, userId: string ): DecisionResponse { - const decideReasons: (string | number)[][] = []; + const decideReasons: DecisionReason[] = []; if (experiment.forcedVariations && experiment.forcedVariations.hasOwnProperty(userId)) { const forcedVariationKey = experiment.forcedVariations[userId]; if (experiment.variationKeyMap.hasOwnProperty(forcedVariationKey)) { @@ -424,7 +519,7 @@ export class DecisionService { user: OptimizelyUserContext, loggingKey?: string | number, ): DecisionResponse { - const decideReasons: (string | number)[][] = []; + const decideReasons: DecisionReason[] = []; const experimentAudienceConditions = getExperimentAudienceConditions(configObj, experiment.id); const audiencesById = getAudiencesById(configObj); this.logger?.debug( @@ -522,29 +617,28 @@ export class DecisionService { /** * Get the user profile with the given user ID * @param {string} userId - * @return {UserProfile|null} the stored user profile or null if one isn't found + * @return {UserProfile} the stored user profile or an empty profile if one isn't found or error */ - private getUserProfile(userId: string): UserProfile | null { - const userProfile = { + private getUserProfile(op: OP, userId: string): Value { + const emptyProfile = { user_id: userId, experiment_bucket_map: {}, }; - if (!this.userProfileService) { - return userProfile; - } - - try { - return this.userProfileService.lookup(userId); - } catch (ex: any) { - this.logger?.error( - USER_PROFILE_LOOKUP_ERROR, - userId, - ex.message, - ); + if (this.userProfileService) { + try { + return Value.of(op, this.userProfileService.lookup(userId)); + } catch (ex: any) { + this.logger?.error( + USER_PROFILE_LOOKUP_ERROR, + userId, + ex.message, + ); + } + return Value.of(op, emptyProfile); } - return null; + return Value.of(op, emptyProfile); } private updateUserProfile( @@ -569,31 +663,42 @@ export class DecisionService { * @param {string} userId * @param {ExperimentBucketMap} experimentBucketMap */ - private saveUserProfile( + private saveUserProfile( + op: OP, userId: string, userProfileTracker: UserProfileTracker - ): void { + ): Value { const { userProfile, isProfileUpdated } = userProfileTracker; - if (!this.userProfileService || !userProfile || !isProfileUpdated) { - return; + if (!userProfile || !isProfileUpdated) { + return Value.of(op, undefined); } - try { - this.userProfileService.save({ - user_id: userId, - experiment_bucket_map: userProfile, - }); + if (op === 'sync' && !this.userProfileService) { + return Value.of(op, undefined); + } - this.logger?.info( - SAVED_USER_VARIATION, - userId, - ); - } catch (ex: any) { - this.logger?.error(USER_PROFILE_SAVE_ERROR, userId, ex.message); + if (this.userProfileService) { + try { + this.userProfileService.save({ + user_id: userId, + experiment_bucket_map: userProfile, + }); + + this.logger?.info( + SAVED_USER_VARIATION, + userId, + ); + } catch (ex: any) { + this.logger?.error(USER_PROFILE_SAVE_ERROR, userId, ex.message); + } + return Value.of(op, undefined); } + + return Value.of(op, undefined); } + /** * Determines variations for the specified feature flags. * @@ -604,62 +709,99 @@ export class DecisionService { * @returns {DecisionResponse[]} - An array of DecisionResponse containing objects with * experiment, variation, decisionSource properties, and decision reasons. */ - getVariationsForFeatureList(configObj: ProjectConfig, + getVariationsForFeatureList( + configObj: ProjectConfig, + featureFlags: FeatureFlag[], + user: OptimizelyUserContext, + options: DecideOptionsMap = {}): DecisionResult[] { + return this.resolveVariationsForFeatureList('sync', configObj, featureFlags, user, options).get(); + } + + resolveVariationsForFeatureList( + op: OP, + configObj: ProjectConfig, featureFlags: FeatureFlag[], user: OptimizelyUserContext, - options: { [key: string]: boolean } = {}): DecisionResponse[] { + options: DecideOptionsMap): Value { const userId = user.getUserId(); const attributes = user.getAttributes(); const decisions: DecisionResponse[] = []; - const userProfileTracker : UserProfileTracker = { - isProfileUpdated: false, - userProfile: null, - } + // const userProfileTracker : UserProfileTracker = { + // isProfileUpdated: false, + // userProfile: null, + // } const shouldIgnoreUPS = !!options[OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE]; - if(!shouldIgnoreUPS) { - userProfileTracker.userProfile = this.resolveExperimentBucketMap(userId, attributes); - } + const userProfileTrackerValue: Value> = shouldIgnoreUPS ? Value.of(op, undefined) + : this.resolveExperimentBucketMap(op, userId, attributes).then((userProfile) => { + return Value.of(op, { + isProfileUpdated: false, + userProfile: userProfile, + }); + }); - for(const feature of featureFlags) { - const decideReasons: (string | number)[][] = []; - const decisionVariation = this.getVariationForFeatureExperiment(configObj, feature, user, shouldIgnoreUPS, userProfileTracker); - decideReasons.push(...decisionVariation.reasons); - const experimentDecision = decisionVariation.result; + return userProfileTrackerValue.then((userProfileTracker) => { + const flagResults = featureFlags.map((feature) => this.resolveVariationForFlag(op, configObj, feature, user, options, userProfileTracker)); + const opFlagResults = Value.all(op, flagResults); - if (experimentDecision.variation !== null) { - decisions.push({ - result: experimentDecision, - reasons: decideReasons, - }); - continue; + return opFlagResults.then(() => { + if(userProfileTracker) { + this.saveUserProfile(op, userId, userProfileTracker); + } + return opFlagResults; + }); + }); + } + + private resolveVariationForFlag( + op: OP, + configObj: ProjectConfig, + feature: FeatureFlag, + user: OptimizelyUserContext, + decideOptions: DecideOptionsMap, + userProfileTracker?: UserProfileTracker + ): Value { + const decideReasons: DecisionReason[] = []; + + const forcedDecisionResponse = this.findValidatedForcedDecision(configObj, user, feature.key); + decideReasons.push(...forcedDecisionResponse.reasons); + + if (forcedDecisionResponse.result) { + return Value.of(op, { + result: { + variation: forcedDecisionResponse.result, + experiment: null, + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }, + reasons: decideReasons, + }); + } + + return this.getVariationForFeatureExperiment(op, configObj, feature, user, decideOptions, userProfileTracker).then((experimentDecision) => { + if (experimentDecision.error || experimentDecision.result.variation !== null) { + return Value.of(op, experimentDecision); } - const decisionRolloutVariation = this.getVariationForRollout(configObj, feature, user); - decideReasons.push(...decisionRolloutVariation.reasons); - const rolloutDecision = decisionRolloutVariation.result; + decideReasons.push(...experimentDecision.reasons); + + const rolloutDecision = this.getVariationForRollout(configObj, feature, user); + decideReasons.push(...rolloutDecision.reasons); + const rolloutDecisionResult = rolloutDecision.result; const userId = user.getUserId(); - - if (rolloutDecision.variation) { + + if (rolloutDecisionResult.variation) { this.logger?.debug(USER_IN_ROLLOUT, userId, feature.key); decideReasons.push([USER_IN_ROLLOUT, userId, feature.key]); } else { this.logger?.debug(USER_NOT_IN_ROLLOUT, userId, feature.key); decideReasons.push([USER_NOT_IN_ROLLOUT, userId, feature.key]); } - - decisions.push({ - result: rolloutDecision, + + return Value.of(op, { + result: rolloutDecisionResult, reasons: decideReasons, }); - } - - if(!shouldIgnoreUPS) { - this.saveUserProfile(userId, userProfileTracker); - } - - return decisions; - + }); } /** @@ -681,68 +823,111 @@ export class DecisionService { configObj: ProjectConfig, feature: FeatureFlag, user: OptimizelyUserContext, - options: { [key: string]: boolean } = {} + options: DecideOptionsMap = {} ): DecisionResponse { - return this.getVariationsForFeatureList(configObj, [feature], user, options)[0] + return this.resolveVariationsForFeatureList('sync', configObj, [feature], user, options).get()[0] } - private getVariationForFeatureExperiment( + private getVariationForFeatureExperiment( + op: OP, configObj: ProjectConfig, feature: FeatureFlag, user: OptimizelyUserContext, - shouldIgnoreUPS: boolean, - userProfileTracker: UserProfileTracker - ): DecisionResponse { + decideOptions: DecideOptionsMap, + userProfileTracker?: UserProfileTracker, + ): Value { - const decideReasons: (string | number)[][] = []; - let variationKey = null; - let decisionVariation; - let index; - let variationForFeatureExperiment; - - // Check if the feature flag is under an experiment and the the user is bucketed into one of these experiments - if (feature.experimentIds.length > 0) { - // Evaluate each experiment ID and return the first bucketed experiment variation - for (index = 0; index < feature.experimentIds.length; index++) { - const experiment = getExperimentFromId(configObj, feature.experimentIds[index], this.logger); - if (experiment) { - decisionVariation = this.getVariationFromExperimentRule(configObj, feature.key, experiment, user, shouldIgnoreUPS, userProfileTracker); - decideReasons.push(...decisionVariation.reasons); - variationKey = decisionVariation.result; - if (variationKey) { - let variation = null; - variation = experiment.variationKeyMap[variationKey]; - if (!variation) { - variation = getFlagVariationByKey(configObj, feature.key, variationKey); - } - variationForFeatureExperiment = { - experiment: experiment, - variation: variation, - decisionSource: DECISION_SOURCES.FEATURE_TEST, - }; - - return { - result: variationForFeatureExperiment, - reasons: decideReasons, - } - } - } - } - } else { + // const decideReasons: DecisionReason[] = []; + // let variationKey = null; + // let decisionVariation; + // let index; + // let variationForFeatureExperiment; + + if (feature.experimentIds.length === 0) { this.logger?.debug(FEATURE_HAS_NO_EXPERIMENTS, feature.key); - decideReasons.push([FEATURE_HAS_NO_EXPERIMENTS, feature.key]); + return Value.of(op, { + result: { + experiment: null, + variation: null, + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }, + reasons: [ + [FEATURE_HAS_NO_EXPERIMENTS, feature.key], + ], + }); } + + return this.traverseFeatureExperimentList(op, configObj, feature, 0, user, [], decideOptions, userProfileTracker); + } - variationForFeatureExperiment = { - experiment: null, - variation: null, - decisionSource: DECISION_SOURCES.FEATURE_TEST, - }; + private traverseFeatureExperimentList( + op: OP, + configObj: ProjectConfig, + feature: FeatureFlag, + fromIndex: number, + user: OptimizelyUserContext, + decideReasons: DecisionReason[], + decideOptions: DecideOptionsMap, + userProfileTracker?: UserProfileTracker, + ): Value { + const experimentIds = feature.experimentIds; + if (fromIndex >= experimentIds.length) { + return Value.of(op, { + result: { + experiment: null, + variation: null, + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }, + reasons: decideReasons, + }); + } - return { - result: variationForFeatureExperiment, - reasons: decideReasons, - }; + const experiment = getExperimentFromId(configObj, experimentIds[fromIndex], this.logger); + if (!experiment) { + return this.traverseFeatureExperimentList( + op, configObj, feature, fromIndex + 1, user, decideReasons, decideOptions, userProfileTracker); + } + + const decisionVariationValue = this.getVariationFromExperimentRule( + op, configObj, feature.key, experiment, user, decideOptions, userProfileTracker, + ); + + return decisionVariationValue.then((decisionVariation) => { + decideReasons.push(...decisionVariation.reasons); + + if (decisionVariation.error) { + return Value.of(op, { + error: true, + result: { + experiment, + variation: null, + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }, + reasons: decideReasons, + }); + } + + if(!decisionVariation.result.variationKey) { + return this.traverseFeatureExperimentList( + op, configObj, feature, fromIndex + 1, user, decideReasons, decideOptions, userProfileTracker); + } + + const variationKey = decisionVariation.result.variationKey; + let variation: Variation | null = experiment.variationKeyMap[variationKey]; + if (!variation) { + variation = getFlagVariationByKey(configObj, feature.key, variationKey); + } + + return Value.of(op, { + result: { + cmabUuid: decisionVariation.result.cmabUuid, + experiment, + variation, + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }, + reasons: decideReasons, + }); + }); } private getVariationForRollout( @@ -750,7 +935,7 @@ export class DecisionService { feature: FeatureFlag, user: OptimizelyUserContext, ): DecisionResponse { - const decideReasons: (string | number)[][] = []; + const decideReasons: DecisionReason[] = []; let decisionObj: DecisionObj; if (!feature.rolloutId) { this.logger?.debug(NO_ROLLOUT_EXISTS, feature.key); @@ -882,7 +1067,7 @@ export class DecisionService { ruleKey?: string ): DecisionResponse { - const decideReasons: (string | number)[][] = []; + const decideReasons: DecisionReason[] = []; const forcedDecision = user.getForcedDecision({ flagKey, ruleKey }); let variation = null; let variationKey; @@ -1015,7 +1200,7 @@ export class DecisionService { experimentKey: string, userId: string ): DecisionResponse { - const decideReasons: (string | number)[][] = []; + const decideReasons: DecisionReason[] = []; const experimentToVariationMap = this.forcedVariationMap[userId]; if (!experimentToVariationMap) { this.logger?.debug( @@ -1170,15 +1355,16 @@ export class DecisionService { } } - private getVariationFromExperimentRule( + private getVariationFromExperimentRule( + op: OP, configObj: ProjectConfig, flagKey: string, rule: Experiment, user: OptimizelyUserContext, - shouldIgnoreUPS: boolean, - userProfileTracker: UserProfileTracker - ): DecisionResponse { - const decideReasons: (string | number)[][] = []; + decideOptions: DecideOptionsMap, + userProfileTracker?: UserProfileTracker, + ): Value { + const decideReasons: DecisionReason[] = []; // check forced decision first const forcedDecisionResponse = this.findValidatedForcedDecision(configObj, user, flagKey, rule.key); @@ -1186,19 +1372,31 @@ export class DecisionService { const forcedVariation = forcedDecisionResponse.result; if (forcedVariation) { - return { - result: forcedVariation.key, + return Value.of(op, { + result: { variationKey: forcedVariation.key }, reasons: decideReasons, - }; + }); } - const decisionVariation = this.resolveVariation(configObj, rule, user, shouldIgnoreUPS, userProfileTracker); - decideReasons.push(...decisionVariation.reasons); - const variationKey = decisionVariation.result; + const decisionVariationValue = this.resolveVariation(op, configObj, rule, user, decideOptions, userProfileTracker); - return { - result: variationKey, - reasons: decideReasons, - }; + return decisionVariationValue.then((variationResult) => { + decideReasons.push(...variationResult.reasons); + return Value.of(op, { + error: variationResult.error, + result: variationResult.result, + reasons: decideReasons, + }); + }); + + // return response; + + // decideReasons.push(...decisionVariation.reasons); + // const variationKey = decisionVariation.result; + + // return { + // result: variationKey, + // reasons: decideReasons, + // }; } private getVariationFromDeliveryRule( @@ -1208,7 +1406,7 @@ export class DecisionService { ruleIndex: number, user: OptimizelyUserContext ): DeliveryRuleResponse { - const decideReasons: (string | number)[][] = []; + const decideReasons: DecisionReason[] = []; let skipToEveryoneElse = false; // check forced decision first diff --git a/lib/entrypoint.universal.test-d.ts b/lib/entrypoint.universal.test-d.ts index 1b5afb060..fb91017b6 100644 --- a/lib/entrypoint.universal.test-d.ts +++ b/lib/entrypoint.universal.test-d.ts @@ -48,10 +48,11 @@ import { import { LogLevel } from './logging/logger'; import { OptimizelyDecideOption } from './shared_types'; +import { UniversalConfig } from './index.universal'; export type UniversalEntrypoint = { // client factory - createInstance: (config: Config) => Client | null; + createInstance: (config: UniversalConfig) => Client | null; // config manager related exports createStaticProjectConfigManager: (config: StaticConfigManagerConfig) => OpaqueConfigManager; diff --git a/lib/event_processor/event_builder/log_event.ts b/lib/event_processor/event_builder/log_event.ts index 520ab4d0b..6266d8a5a 100644 --- a/lib/event_processor/event_builder/log_event.ts +++ b/lib/event_processor/event_builder/log_event.ts @@ -72,6 +72,7 @@ type Metadata = { rule_type: string; variation_key: string; enabled: boolean; + cmab_uuid?: string; } export type SnapshotEvent = { @@ -156,7 +157,7 @@ function makeConversionSnapshot(conversion: ConversionEvent): Snapshot { } function makeDecisionSnapshot(event: ImpressionEvent): Snapshot { - const { layer, experiment, variation, ruleKey, flagKey, ruleType, enabled } = event + const { layer, experiment, variation, ruleKey, flagKey, ruleType, enabled, cmabUuid } = event const layerId = layer ? layer.id : null const experimentId = experiment?.id ?? '' const variationId = variation?.id ?? '' @@ -174,6 +175,7 @@ function makeDecisionSnapshot(event: ImpressionEvent): Snapshot { rule_type: ruleType, variation_key: variationKey, enabled: enabled, + cmab_uuid: cmabUuid, }, }, ], diff --git a/lib/event_processor/event_builder/user_event.tests.js b/lib/event_processor/event_builder/user_event.tests.js index 085435f09..19964e931 100644 --- a/lib/event_processor/event_builder/user_event.tests.js +++ b/lib/event_processor/event_builder/user_event.tests.js @@ -142,6 +142,7 @@ describe('user_event', function() { flagKey: 'flagkey1', ruleType: 'experiment', enabled: true, + cmabUuid: undefined, }); }); }); @@ -235,6 +236,7 @@ describe('user_event', function() { flagKey: 'flagkey1', ruleType: 'experiment', enabled: false, + cmabUuid: undefined, }); }); }); diff --git a/lib/event_processor/event_builder/user_event.ts b/lib/event_processor/event_builder/user_event.ts index 970d12937..e2e52bedc 100644 --- a/lib/event_processor/event_builder/user_event.ts +++ b/lib/event_processor/event_builder/user_event.ts @@ -76,6 +76,7 @@ export type ImpressionEvent = BaseUserEvent & { flagKey: string; ruleType: string; enabled: boolean; + cmabUuid?: string; }; export type EventTags = { @@ -144,6 +145,7 @@ export const buildImpressionEvent = function({ const experimentId = decision.getExperimentId(decisionObj); const variationKey = decision.getVariationKey(decisionObj); const variationId = decision.getVariationId(decisionObj); + const cmabUuid = decisionObj.cmabUuid; const layerId = experimentId !== null ? getLayerId(configObj, experimentId) : null; @@ -185,6 +187,7 @@ export const buildImpressionEvent = function({ flagKey: flagKey, ruleType: ruleType, enabled: enabled, + cmabUuid, }; }; diff --git a/lib/index.browser.ts b/lib/index.browser.ts index b8c31659d..98c7a11d2 100644 --- a/lib/index.browser.ts +++ b/lib/index.browser.ts @@ -18,6 +18,7 @@ import sendBeaconEventDispatcher from './event_processor/event_dispatcher/send_b import { getOptimizelyInstance } from './client_factory'; import { EventDispatcher } from './event_processor/event_dispatcher/event_dispatcher'; import { JAVASCRIPT_CLIENT_ENGINE } from './utils/enums'; +import { BrowserRequestHandler } from './utils/http_request_handler/request_handler.browser'; /** * Creates an instance of the Optimizely class @@ -26,7 +27,10 @@ import { JAVASCRIPT_CLIENT_ENGINE } from './utils/enums'; * null on error */ export const createInstance = function(config: Config): Client | null { - const client = getOptimizelyInstance(config); + const client = getOptimizelyInstance({ + ...config, + requestHandler: new BrowserRequestHandler(), + }); if (client) { const unloadEvent = 'onpagehide' in window ? 'pagehide' : 'unload'; diff --git a/lib/index.node.ts b/lib/index.node.ts index cb1802af8..348c8c3d9 100644 --- a/lib/index.node.ts +++ b/lib/index.node.ts @@ -17,6 +17,7 @@ import { NODE_CLIENT_ENGINE } from './utils/enums'; import { Client, Config } from './shared_types'; import { getOptimizelyInstance } from './client_factory'; import { EventDispatcher } from './event_processor/event_dispatcher/event_dispatcher'; +import { NodeRequestHandler } from './utils/http_request_handler/request_handler.node'; /** * Creates an instance of the Optimizely class @@ -28,6 +29,7 @@ export const createInstance = function(config: Config): Client | null { const nodeConfig = { ...config, clientEnging: config.clientEngine || NODE_CLIENT_ENGINE, + requestHandler: new NodeRequestHandler(), } return getOptimizelyInstance(nodeConfig); diff --git a/lib/index.react_native.ts b/lib/index.react_native.ts index 48a8ee35c..fbdf9c8a0 100644 --- a/lib/index.react_native.ts +++ b/lib/index.react_native.ts @@ -20,6 +20,7 @@ import { Client, Config } from './shared_types'; import { getOptimizelyInstance } from './client_factory'; import { REACT_NATIVE_JS_CLIENT_ENGINE } from './utils/enums'; import { EventDispatcher } from './event_processor/event_dispatcher/event_dispatcher'; +import { BrowserRequestHandler } from './utils/http_request_handler/request_handler.browser'; /** * Creates an instance of the Optimizely class @@ -31,6 +32,7 @@ export const createInstance = function(config: Config): Client | null { const rnConfig = { ...config, clientEngine: config.clientEngine || REACT_NATIVE_JS_CLIENT_ENGINE, + requestHandler: new BrowserRequestHandler(), } return getOptimizelyInstance(rnConfig); diff --git a/lib/index.universal.ts b/lib/index.universal.ts index 5df959975..6bd233a32 100644 --- a/lib/index.universal.ts +++ b/lib/index.universal.ts @@ -17,13 +17,19 @@ import { Client, Config } from './shared_types'; import { getOptimizelyInstance } from './client_factory'; import { JAVASCRIPT_CLIENT_ENGINE } from './utils/enums'; +import { RequestHandler } from './utils/http_request_handler/http'; + +export type UniversalConfig = Config & { + requestHandler: RequestHandler; +} + /** * Creates an instance of the Optimizely class * @param {Config} config * @return {Client|null} the Optimizely client object * null on error */ -export const createInstance = function(config: Config): Client | null { +export const createInstance = function(config: UniversalConfig): Client | null { return getOptimizelyInstance(config); }; diff --git a/lib/message/error_message.ts b/lib/message/error_message.ts index e6a2260a3..d820f59ee 100644 --- a/lib/message/error_message.ts +++ b/lib/message/error_message.ts @@ -108,5 +108,6 @@ export const UNABLE_TO_ATTACH_UNLOAD = 'unable to bind optimizely.close() to pag export const UNABLE_TO_PARSE_AND_SKIPPED_HEADER = 'Unable to parse & skipped header item'; export const CMAB_FETCH_FAILED = 'CMAB decision fetch failed with status: %s'; export const INVALID_CMAB_FETCH_RESPONSE = 'Invalid CMAB fetch response'; +export const PROMISE_NOT_ALLOWED = "Promise value is not allowed in sync operation"; export const messages: string[] = []; diff --git a/lib/optimizely/index.spec.ts b/lib/optimizely/index.spec.ts index 593cb84ba..1d41c7982 100644 --- a/lib/optimizely/index.spec.ts +++ b/lib/optimizely/index.spec.ts @@ -25,6 +25,13 @@ import { createProjectConfig } from '../project_config/project_config'; import { getMockLogger } from '../tests/mock/mock_logger'; import { createOdpManager } from '../odp/odp_manager_factory.node'; import { extractOdpManager } from '../odp/odp_manager_factory'; +import { Value } from '../utils/promise/operation_value'; +import { getDecisionTestDatafile } from '../tests/decision_test_datafile'; +import { DECISION_SOURCES } from '../utils/enums'; +import OptimizelyUserContext from '../optimizely_user_context'; +import { newErrorDecision } from '../optimizely_decision'; +import { EventDispatcher } from '../shared_types'; +import { ImpressionEvent } from '../event_processor/event_builder/user_event'; describe('Optimizely', () => { const eventDispatcher = { @@ -52,10 +59,121 @@ describe('Optimizely', () => { eventProcessor, odpManager, disposable: true, + cmabService: {} as any }); expect(projectConfigManager.makeDisposable).toHaveBeenCalled(); expect(eventProcessor.makeDisposable).toHaveBeenCalled(); expect(odpManager.makeDisposable).toHaveBeenCalled(); }); + + describe('decideAsync', () => { + it('should return an error decision with correct reasons if decisionService returns error', async () => { + const projectConfig = createProjectConfig(getDecisionTestDatafile()); + + const projectConfigManager = getMockProjectConfigManager({ + initConfig: projectConfig, + }); + + const optimizely = new Optimizely({ + clientEngine: 'node-sdk', + projectConfigManager, + jsonSchemaValidator, + logger, + eventProcessor, + odpManager, + disposable: true, + cmabService: {} as any + }); + + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + const decisionService = optimizely.decisionService; + vi.spyOn(decisionService, 'resolveVariationsForFeatureList').mockImplementation(() => { + return Value.of('async', [{ + error: true, + result: { + variation: null, + experiment: projectConfig.experimentKeyMap['exp_3'], + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }, + reasons:[ + ['test reason %s', '1'], + ['test reason %s', '2'], + ] + }]); + }); + + const user = new OptimizelyUserContext({ + optimizely: {} as any, + userId: 'tester', + attributes: { + country: 'BD', + age: 80, // should satisfy audience condition for exp_3 which is cmab and not others + }, + }); + + const decision = await optimizely.decideAsync(user, 'flag_1', []); + + expect(decision).toEqual(newErrorDecision('flag_1', user, ['test reason 1', 'test reason 2'])); + }); + + it('should include cmab uuid in dispatched event if decisionService returns a cmab uuid', async () => { + const projectConfig = createProjectConfig(getDecisionTestDatafile()); + + const projectConfigManager = getMockProjectConfigManager({ + initConfig: projectConfig, + }); + + const eventProcessor = getForwardingEventProcessor(eventDispatcher); + const processSpy = vi.spyOn(eventProcessor, 'process'); + + const optimizely = new Optimizely({ + clientEngine: 'node-sdk', + projectConfigManager, + eventProcessor, + jsonSchemaValidator, + logger, + odpManager, + disposable: true, + cmabService: {} as any + }); + + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-ignore + const decisionService = optimizely.decisionService; + vi.spyOn(decisionService, 'resolveVariationsForFeatureList').mockImplementation(() => { + return Value.of('async', [{ + error: false, + result: { + cmabUuid: 'uuid-cmab', + variation: projectConfig.variationIdMap['5003'], + experiment: projectConfig.experimentKeyMap['exp_3'], + decisionSource: DECISION_SOURCES.FEATURE_TEST, + }, + reasons: [], + }]); + }); + + const user = new OptimizelyUserContext({ + optimizely: {} as any, + userId: 'tester', + attributes: { + country: 'BD', + age: 80, // should satisfy audience condition for exp_3 which is cmab and not others + }, + }); + + const decision = await optimizely.decideAsync(user, 'flag_1', []); + + expect(decision.ruleKey).toBe('exp_3'); + expect(decision.flagKey).toBe('flag_1'); + expect(decision.variationKey).toBe('variation_3'); + expect(decision.enabled).toBe(true); + + expect(eventProcessor.process).toHaveBeenCalledOnce(); + const event = processSpy.mock.calls[0][0] as ImpressionEvent; + expect(event.cmabUuid).toBe('uuid-cmab'); + }); + }); }); diff --git a/lib/optimizely/index.tests.js b/lib/optimizely/index.tests.js index cd74a2d00..ac1a0fd96 100644 --- a/lib/optimizely/index.tests.js +++ b/lib/optimizely/index.tests.js @@ -224,6 +224,8 @@ describe('lib/optimizely', function() { save: function() {}, }; + const cmabService = {}; + new Optimizely({ clientEngine: 'node-sdk', logger: createdLogger, @@ -231,12 +233,14 @@ describe('lib/optimizely', function() { jsonSchemaValidator: jsonSchemaValidator, userProfileService: userProfileServiceInstance, notificationCenter, + cmabService, eventProcessor, }); sinon.assert.calledWith(decisionService.createDecisionService, { userProfileService: userProfileServiceInstance, logger: createdLogger, + cmabService, UNSTABLE_conditionEvaluators: undefined, }); @@ -251,6 +255,8 @@ describe('lib/optimizely', function() { save: function() {}, }; + const cmabService = {}; + new Optimizely({ clientEngine: 'node-sdk', logger: createdLogger, @@ -259,12 +265,14 @@ describe('lib/optimizely', function() { userProfileService: invalidUserProfile, notificationCenter, eventProcessor, + cmabService, }); sinon.assert.calledWith(decisionService.createDecisionService, { userProfileService: undefined, logger: createdLogger, UNSTABLE_conditionEvaluators: undefined, + cmabService, }); // var logMessage = buildLogMessageFromArgs(createdLogger.log.args[0]); @@ -360,6 +368,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'variation', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -424,6 +433,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'variationWithAudience', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -493,6 +503,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'variationWithAudience', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -567,6 +578,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'variationWithAudience', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -674,6 +686,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'var2exp2', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -736,6 +749,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'var2exp1', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -2237,6 +2251,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'variation', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -2299,6 +2314,7 @@ describe('lib/optimizely', function() { rule_type: 'experiment', variation_key: 'variation', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -4534,6 +4550,7 @@ describe('lib/optimizely', function() { rule_type: 'feature-test', variation_key: 'variation_with_traffic', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -5261,6 +5278,7 @@ describe('lib/optimizely', function() { userId, }); var decision = optlyInstance.decide(user, flagKey); + expect(decision.reasons).to.include( sprintf(USER_BUCKETED_INTO_EXPERIMENT_IN_GROUP, userId, experimentKey, groupId) ); @@ -6222,6 +6240,7 @@ describe('lib/optimizely', function() { rule_type: 'feature-test', variation_key: 'variation', enabled: true, + cmab_uuid: undefined, }, }, ], @@ -6449,6 +6468,7 @@ describe('lib/optimizely', function() { rule_type: 'feature-test', variation_key: 'control', enabled: false, + cmab_uuid: undefined, }, }, ], @@ -6652,6 +6672,7 @@ describe('lib/optimizely', function() { rule_type: 'rollout', variation_key: '', enabled: false, + cmab_uuid: undefined, }, }, ], diff --git a/lib/optimizely/index.ts b/lib/optimizely/index.ts index bf8e6c717..4b4e749a3 100644 --- a/lib/optimizely/index.ts +++ b/lib/optimizely/index.ts @@ -60,7 +60,7 @@ import { NODE_CLIENT_ENGINE, CLIENT_VERSION, } from '../utils/enums'; -import { Fn, Maybe } from '../utils/type'; +import { Fn, Maybe, OpType, OpValue } from '../utils/type'; import { resolvablePromise } from '../utils/promise/resolvablePromise'; import { NOTIFICATION_TYPES, DecisionNotificationType, DECISION_NOTIFICATION_TYPES } from '../notification_center/type'; @@ -102,6 +102,8 @@ import { import { ErrorNotifier } from '../error/error_notifier'; import { ErrorReporter } from '../error/error_reporter'; import { OptimizelyError } from '../error/optimizly_error'; +import { Value } from '../utils/promise/operation_value'; +import { CmabService } from '../core/decision_service/cmab/cmab_service'; const DEFAULT_ONREADY_TIMEOUT = 30000; @@ -118,6 +120,7 @@ type DecisionReasons = (string | number)[]; export type OptimizelyOptions = { projectConfigManager: ProjectConfigManager; UNSTABLE_conditionEvaluators?: unknown; + cmabService: CmabService; clientEngine: string; clientVersion?: string; errorNotifier?: ErrorNotifier; @@ -225,6 +228,7 @@ export default class Optimizely extends BaseService implements Client { this.decisionService = createDecisionService({ userProfileService: userProfileService, + cmabService: config.cmabService, logger: this.logger, UNSTABLE_conditionEvaluators: config.UNSTABLE_conditionEvaluators, }); @@ -1396,6 +1400,18 @@ export default class Optimizely extends BaseService implements Client { return this.decideForKeys(user, [key], options, true)[key]; } + async decideAsync(user: OptimizelyUserContext, key: string, options: OptimizelyDecideOption[] = []): Promise { + const configObj = this.getProjectConfig(); + + if (!configObj) { + this.errorReporter.report(NO_PROJECT_CONFIG_FAILURE, 'decide'); + return newErrorDecision(key, user, [DECISION_MESSAGES.SDK_NOT_READY]); + } + + const result = await this.decideForKeysAsync(user, [key], options, true); + return result[key]; + } + /** * Get all decide options. * @param {OptimizelyDecideOption[]} options decide options @@ -1525,20 +1541,38 @@ export default class Optimizely extends BaseService implements Client { options: OptimizelyDecideOption[] = [], ignoreEnabledFlagOption?:boolean ): Record { + return this.getDecisionForKeys('sync', user, keys, options, ignoreEnabledFlagOption).get(); + } + + decideForKeysAsync( + user: OptimizelyUserContext, + keys: string[], + options: OptimizelyDecideOption[] = [], + ignoreEnabledFlagOption?:boolean + ): Promise> { + return this.getDecisionForKeys('async', user, keys, options, ignoreEnabledFlagOption).get(); + } + + private getDecisionForKeys( + op: OP, + user: OptimizelyUserContext, + keys: string[], + options: OptimizelyDecideOption[] = [], + ignoreEnabledFlagOption?:boolean + ): Value> { const decisionMap: Record = {}; const flagDecisions: Record = {}; const decisionReasonsMap: Record = {}; - const flagsWithoutForcedDecision = []; - const validKeys = []; const configObj = this.getProjectConfig() if (!configObj) { this.errorReporter.report(NO_PROJECT_CONFIG_FAILURE, 'decideForKeys'); - return decisionMap; + return Value.of(op, decisionMap); } + if (keys.length === 0) { - return decisionMap; + return Value.of(op, decisionMap); } const allDecideOptions = this.getAllDecideOptions(options); @@ -1547,6 +1581,8 @@ export default class Optimizely extends BaseService implements Client { delete allDecideOptions[OptimizelyDecideOption.ENABLED_FLAGS_ONLY]; } + const validFlags: FeatureFlag[] = []; + for(const key of keys) { const feature = configObj.featureKeyMap[key]; if (!feature) { @@ -1555,40 +1591,42 @@ export default class Optimizely extends BaseService implements Client { continue; } - validKeys.push(key); - const forcedDecisionResponse = this.decisionService.findValidatedForcedDecision(configObj, user, key); - decisionReasonsMap[key] = forcedDecisionResponse.reasons - const variation = forcedDecisionResponse.result; - - if (variation) { - flagDecisions[key] = { - experiment: null, - variation: variation, - decisionSource: DECISION_SOURCES.FEATURE_TEST, - }; - } else { - flagsWithoutForcedDecision.push(feature) - } + validFlags.push(feature); } - const decisionList = this.decisionService.getVariationsForFeatureList(configObj, flagsWithoutForcedDecision, user, allDecideOptions); + return this.decisionService.resolveVariationsForFeatureList(op, configObj, validFlags, user, allDecideOptions) + .then((decisionList) => { + for(let i = 0; i < validFlags.length; i++) { + const key = validFlags[i].key; + const decision = decisionList[i]; + + if(decision.error) { + decisionMap[key] = newErrorDecision(key, user, decision.reasons.map(r => sprintf(r[0], ...r.slice(1)))); + } else { + flagDecisions[key] = decision.result; + decisionReasonsMap[key] = decision.reasons; + } + } - for(let i = 0; i < flagsWithoutForcedDecision.length; i++) { - const key = flagsWithoutForcedDecision[i].key; - const decision = decisionList[i]; - flagDecisions[key] = decision.result; - decisionReasonsMap[key] = [...decisionReasonsMap[key], ...decision.reasons]; - } + for(const validFlag of validFlags) { + const validKey = validFlag.key; - for(const validKey of validKeys) { - const decision = this.generateDecision(user, validKey, flagDecisions[validKey], decisionReasonsMap[validKey], allDecideOptions, configObj); + // if there is already a value for this flag, that must have come from + // the newErrorDecision above, so we skip it + if (decisionMap[validKey]) { + continue; + } - if(!allDecideOptions[OptimizelyDecideOption.ENABLED_FLAGS_ONLY] || decision.enabled) { - decisionMap[validKey] = decision; - } - } + const decision = this.generateDecision(user, validKey, flagDecisions[validKey], decisionReasonsMap[validKey], allDecideOptions, configObj); + + if(!allDecideOptions[OptimizelyDecideOption.ENABLED_FLAGS_ONLY] || decision.enabled) { + decisionMap[validKey] = decision; + } + } - return decisionMap; + return Value.of(op, decisionMap); + }, + ); } /** @@ -1613,6 +1651,22 @@ export default class Optimizely extends BaseService implements Client { return this.decideForKeys(user, allFlagKeys, options); } + async decideAllAsync( + user: OptimizelyUserContext, + options: OptimizelyDecideOption[] = [] + ): Promise> { + const decisionMap: { [key: string]: OptimizelyDecision } = {}; + const configObj = this.getProjectConfig(); + if (!configObj) { + this.errorReporter.report(NO_PROJECT_CONFIG_FAILURE, 'decideAll'); + return decisionMap; + } + + const allFlagKeys = Object.keys(configObj.featureKeyMap); + + return this.decideForKeysAsync(user, allFlagKeys, options); + } + /** * Updates ODP Config with most recent ODP key, host, pixelUrl, and segments from the project config */ diff --git a/lib/shared_types.ts b/lib/shared_types.ts index 4db7c0da1..6f7bfc5e8 100644 --- a/lib/shared_types.ts +++ b/lib/shared_types.ts @@ -67,8 +67,9 @@ export interface BucketerParams { } export interface DecisionResponse { + readonly error?: boolean; readonly result: T; - readonly reasons: (string | number)[][]; + readonly reasons: [string, ...any[]][]; } export type UserAttributeValue = string | number | boolean | null; diff --git a/lib/tests/decision_test_datafile.ts b/lib/tests/decision_test_datafile.ts index 84c72de90..5048d2549 100644 --- a/lib/tests/decision_test_datafile.ts +++ b/lib/tests/decision_test_datafile.ts @@ -48,6 +48,26 @@ const testDatafile = { conditions: "[\"or\", {\"match\": \"exact\", \"name\": \"$opt_dummy_attribute\", \"type\": \"custom_attribute\", \"value\": \"$opt_dummy_value\"}]", id: "4003" }, + { + name: "age_94", + conditions: "[\"or\", {\"match\": \"exact\", \"name\": \"$opt_dummy_attribute\", \"type\": \"custom_attribute\", \"value\": \"$opt_dummy_value\"}]", + id: "4004" + }, + { + name: "age_95", + conditions: "[\"or\", {\"match\": \"exact\", \"name\": \"$opt_dummy_attribute\", \"type\": \"custom_attribute\", \"value\": \"$opt_dummy_value\"}]", + id: "4005" + }, + { + name: "age_96", + conditions: "[\"or\", {\"match\": \"exact\", \"name\": \"$opt_dummy_attribute\", \"type\": \"custom_attribute\", \"value\": \"$opt_dummy_value\"}]", + id: "4006" + }, + { + name: "age_97", + conditions: "[\"or\", {\"match\": \"exact\", \"name\": \"$opt_dummy_attribute\", \"type\": \"custom_attribute\", \"value\": \"$opt_dummy_value\"}]", + id: "4007" + }, { id: "$opt_dummy_audience", name: "Optimizely-Generated Audience for Backwards Compatibility", @@ -117,6 +137,63 @@ const testDatafile = { ], id: "4003" }, + { + name: "age_94", + conditions: [ + "and", + [ + "or", + [ + "or", + { + "match": "le", + name: "age", + "type": "custom_attribute", + value: 94 + } + ] + ] + ], + id: "4004" + }, + { + name: "age_95", + conditions: [ + "and", + [ + "or", + [ + "or", + { + "match": "le", + name: "age", + "type": "custom_attribute", + value: 95 + } + ] + ] + ], + id: "4005" + }, + { + name: "age_96", + conditions: [ + "and", + [ + "or", + [ + "or", + { + "match": "le", + name: "age", + "type": "custom_attribute", + value: 96 + } + ] + ] + ], + id: "4006" + }, ], variables: [], environmentKey: "production", @@ -393,8 +470,10 @@ const testDatafile = { forcedVariations: { }, - audienceIds: [], - audienceConditions: [] + audienceConditions: [ + "or", + "4002" + ] }, { id: "2003", @@ -428,7 +507,13 @@ const testDatafile = { }, audienceIds: [], - audienceConditions: [] + audienceConditions: [ + "or", + "4003" + ], + cmab: { + attributes: ["7001"], + } }, { id: "2004", diff --git a/lib/utils/enums/index.ts b/lib/utils/enums/index.ts index 573857d00..bb5ca5e73 100644 --- a/lib/utils/enums/index.ts +++ b/lib/utils/enums/index.ts @@ -111,5 +111,5 @@ export { NOTIFICATION_TYPES } from '../../notification_center/type'; */ export const REQUEST_TIMEOUT_MS = 60 * 1000; // 1 minute - - +export const DEFAULT_CMAB_CACHE_TIMEOUT = 30 * 60 * 1000; // 30 minutes +export const DEFAULT_CMAB_CACHE_SIZE = 1000; diff --git a/lib/utils/promise/operation_value.ts b/lib/utils/promise/operation_value.ts new file mode 100644 index 000000000..7f7aa3779 --- /dev/null +++ b/lib/utils/promise/operation_value.ts @@ -0,0 +1,50 @@ +import { PROMISE_NOT_ALLOWED } from '../../message/error_message'; +import { OptimizelyError } from '../../error/optimizly_error'; +import { OpType, OpValue } from '../type'; + + +const isPromise = (val: any): boolean => { + return val && typeof val.then === 'function'; +} + +/** + * A class that wraps a value that can be either a synchronous value or a promise and provides + * a promise like interface. This class is used to handle both synchronous and asynchronous values + * in a uniform way. + */ +export class Value { + constructor(public op: OP, public val: OpValue) {} + + get(): OpValue { + return this.val; + } + + then(fn: (v: V) => Value): Value { + if (this.op === 'sync') { + const newVal = fn(this.val as V); + return Value.of(this.op, newVal.get() as NV); + } + return Value.of(this.op, (this.val as Promise).then(fn) as Promise); + } + + static all = (op: OP, vals: Value[]): Value => { + if (op === 'sync') { + const values = vals.map(v => v.get() as V); + return Value.of(op, values); + } + + const promises = vals.map(v => v.get() as Promise); + return Value.of(op, Promise.all(promises)); + } + + static of(op: OP, val: V | Promise): Value { + if (op === 'sync') { + if (isPromise(val)) { + throw new OptimizelyError(PROMISE_NOT_ALLOWED); + } + return new Value(op, val as OpValue); + } + + return new Value(op, Promise.resolve(val) as OpValue); + } +} diff --git a/lib/utils/type.ts b/lib/utils/type.ts index 0ddc6fc3c..a6c31d769 100644 --- a/lib/utils/type.ts +++ b/lib/utils/type.ts @@ -28,3 +28,6 @@ export type AsyncProducer = () => Promise; export type Maybe = T | undefined; export type Either = { type: 'left', value: A } | { type: 'right', value: B }; + +export type OpType = 'sync' | 'async'; +export type OpValue = O extends 'sync' ? V : Promise;