optimizely · mikechu-optimizely · Aug 31, 2022 · Aug 16, 2022 · Aug 18, 2022 · Aug 18, 2022
diff --git a/packages/optimizely-sdk/lib/core/project_config/project_config_manager.tests.js b/packages/optimizely-sdk/lib/core/project_config/project_config_manager.tests.js
@@ -97,7 +97,7 @@ describe('lib/core/project_config/project_config_manager', function() {
     var errorMessage = globalStubErrorHandler.handleError.lastCall.args[0].message;
     assert.strictEqual(
       errorMessage,
-      sprintf(ERROR_MESSAGES.INVALID_DATAFILE, 'JSON_SCHEMA_VALIDATOR', 'projectId', 'is missing and it is required')
+      sprintf(ERROR_MESSAGES.INVALID_DATAFILE, 'JSON_SCHEMA_VALIDATOR (Project Config JSON Schema)', 'projectId', 'is missing and it is required'),
     );
     return manager.onReady().then(function(result) {
       assert.include(result, {

diff --git a/packages/optimizely-sdk/lib/core/project_config/project_config_schema.ts b/packages/optimizely-sdk/lib/core/project_config/project_config_schema.ts
@@ -21,6 +21,7 @@ import { JSONSchema4 } from 'json-schema';
 
 var schemaDefinition = {
   $schema: 'http://json-schema.org/draft-04/schema#',
+  title: 'Project Config JSON Schema',
   type: 'object',
   properties: {
     projectId: {

diff --git a/packages/optimizely-sdk/lib/index.browser.ts b/packages/optimizely-sdk/lib/index.browser.ts
@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -18,9 +18,9 @@ import {
   getLogger,
   setErrorHandler,
   getErrorHandler,
-  LogLevel
+  LogLevel,
 } from './modules/logging';
-import { LocalStoragePendingEventsDispatcher } from '../lib/modules/event_processor';
+import { LocalStoragePendingEventsDispatcher } from './modules/event_processor';
 import configValidator from './utils/config_validator';
 import defaultErrorHandler from './plugins/error_handler';
 import defaultEventDispatcher from './plugins/event_dispatcher/index.browser';
@@ -32,6 +32,8 @@ import { createNotificationCenter } from './core/notification_center';
 import { default as eventProcessor } from './plugins/event_processor';
 import { OptimizelyDecideOption, Client, Config } from './shared_types';
 import { createHttpPollingDatafileManager } from './plugins/datafile_manager/http_polling_datafile_manager';
+import { EXECUTION_CONTEXT_TYPE } from './utils/enums';
+import { ExecutionContext } from './utils/execution_context';
 
 const logger = getLogger();
 logHelper.setLogHandler(loggerPlugin.createLogger());
@@ -44,11 +46,13 @@ const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
 
 let hasRetriedEvents = false;
 
+ExecutionContext.Current = EXECUTION_CONTEXT_TYPE.BROWSER;
+
 /**
  * Creates an instance of the Optimizely class
  * @param  {Config} config
  * @return {Client|null} the Optimizely client object
- *                           null on error 
+ *                           null on error
  */
 const createInstance = function(config: Config): Client | null {
   try {
@@ -70,6 +74,7 @@ const createInstance = function(config: Config): Client | null {
     try {
       configValidator.validate(config);
       isValidInstance = true;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (ex: any) {
       logger.error(ex);
     }
@@ -141,11 +146,13 @@ const createInstance = function(config: Config): Client | null {
           false
         );
       }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (e: any) {
       logger.error(enums.LOG_MESSAGES.UNABLE_TO_ATTACH_UNLOAD, MODULE_NAME, e.message);
     }
 
     return optimizely;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
   } catch (e: any) {
     logger.error(e);
     return null;

diff --git a/packages/optimizely-sdk/lib/index.node.ts b/packages/optimizely-sdk/lib/index.node.ts
@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.         *
  * You may obtain a copy of the License at                                  *
  *                                                                          *
- *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *    https://www.apache.org/licenses/LICENSE-2.0                            *
  *                                                                          *
  * Unless required by applicable law or agreed to in writing, software      *
  * distributed under the License is distributed on an "AS IS" BASIS,        *
@@ -32,6 +32,8 @@ import { createNotificationCenter } from './core/notification_center';
 import { createEventProcessor } from './plugins/event_processor';
 import { OptimizelyDecideOption, Client, Config } from './shared_types';
 import { createHttpPollingDatafileManager } from './plugins/datafile_manager/http_polling_datafile_manager';
+import { ExecutionContext } from './utils/execution_context';
+import { EXECUTION_CONTEXT_TYPE } from './utils/enums';
 
 const logger = getLogger();
 setLogLevel(LogLevel.ERROR);
@@ -40,13 +42,15 @@ const DEFAULT_EVENT_BATCH_SIZE = 10;
 const DEFAULT_EVENT_FLUSH_INTERVAL = 30000; // Unit is ms, default is 30s
 const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
 
+ExecutionContext.Current = EXECUTION_CONTEXT_TYPE.NODE;
+
 /**
  * Creates an instance of the Optimizely class
  * @param  {Config} config
  * @return {Client|null} the Optimizely client object
- *                           null on error 
+ *                           null on error
  */
- const createInstance = function(config: Config): Client | null {
+const createInstance = function(config: Config): Client | null {
   try {
     let hasLogger = false;
     let isValidInstance = false;
@@ -68,6 +72,7 @@ const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
     try {
       configValidator.validate(config);
       isValidInstance = true;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (ex: any) {
       if (hasLogger) {
         logger.error(ex);
@@ -117,6 +122,7 @@ const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
     };
 
     return new Optimizely(optimizelyOptions);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
   } catch (e: any) {
     logger.error(e);
     return null;

diff --git a/packages/optimizely-sdk/lib/index.react_native.ts b/packages/optimizely-sdk/lib/index.react_native.ts
@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -32,6 +32,8 @@ import { createNotificationCenter } from './core/notification_center';
 import { createEventProcessor } from './plugins/event_processor/index.react_native';
 import { OptimizelyDecideOption, Client, Config } from './shared_types';
 import { createHttpPollingDatafileManager } from './plugins/datafile_manager/http_polling_datafile_manager';
+import { EXECUTION_CONTEXT_TYPE } from './utils/enums';
+import { ExecutionContext } from './utils/execution_context';
 
 const logger = getLogger();
 setLogHandler(loggerPlugin.createLogger());
@@ -41,13 +43,15 @@ const DEFAULT_EVENT_BATCH_SIZE = 10;
 const DEFAULT_EVENT_FLUSH_INTERVAL = 1000; // Unit is ms, default is 1s
 const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
 
+ExecutionContext.Current = EXECUTION_CONTEXT_TYPE.BROWSER;
+
 /**
  * Creates an instance of the Optimizely class
  * @param  {Config} config
  * @return {Client|null} the Optimizely client object
- *                           null on error 
+ *                           null on error
  */
- const createInstance = function(config: Config): Client | null {
+const createInstance = function(config: Config): Client | null {
   try {
     // TODO warn about setting per instance errorHandler / logger / logLevel
     let isValidInstance = false;
@@ -67,6 +71,7 @@ const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
     try {
       configValidator.validate(config);
       isValidInstance = true;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (ex: any) {
       logger.error(ex);
     }
@@ -117,6 +122,7 @@ const DEFAULT_EVENT_MAX_QUEUE_SIZE = 10000;
     }
 
     return new Optimizely(optimizelyOptions);
+    // eslint-disable-next-line @typescript-eslint/no-explicit
10000
-any
   } catch (e: any) {
     logger.error(e);
     return null;

diff --git a/packages/optimizely-sdk/lib/plugins/odp/graphql_manager.ts b/packages/optimizely-sdk/lib/plugins/odp/graphql_manager.ts
@@ -0,0 +1,137 @@
+/**
+ * Copyright 2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ErrorHandler, LogHandler, LogLevel } from '../../modules/logging';
+import { Response } from './odp_types';
+import { IOdpClient, OdpClient } from './odp_client';
+import { validate } from '../../utils/json_schema_validator';
+import { OdpResponseSchema } from './odp_response_schema';
+import { QuerySegmentsParameters } from './query_segments_parameters';
+import { RequestHandlerFactory } from '../../utils/http_request_handler/request_handler_factory';
+
+/**
+ * Expected value for a qualified/valid segment
+ */
+const QUALIFIED = 'qualified';
+/**
+ * Return value when no valid segments found
+ */
+const EMPTY_SEGMENTS_COLLECTION: string[] = [];
+/**
+ * Return value for scenarios with no valid JSON
+ */
+const EMPTY_JSON_RESPONSE = null;
+
+/**
+ * Manager for communicating with the Optimizely Data Platform GraphQL endpoint
+ */
+export interface IGraphQLManager {
+  fetchSegments(apiKey: string, apiHost: string, userKey: string, userValue: string, segmentsToCheck: string[]): Promise<string[]>;
+}
+
+/**
+ * Concrete implementation for communicating with the Optimizely Data Platform GraphQL endpoint
+ */
+export class GraphqlManager implements IGraphQLManager {
+  private readonly _errorHandler: ErrorHandler;
+  private readonly _logger: LogHandler;
+  private readonly _odpClient: IOdpClient;
+
+  /**
+   * Retrieves the audience segments from the Optimizely Data Platform (ODP)
+   * @param errorHandler Handler to record exceptions
+   * @param logger Collect and record events/errors for this GraphQL implementation
+   * @param client Client to use to send queries to ODP
+   */
+  constructor(errorHandler: ErrorHandler, logger: LogHandler, client?: IOdpClient) {
+    this._errorHandler = errorHandler;
+    this._logger = logger;
+
+    this._odpClient = client ?? new OdpClient(this._errorHandler,
+      this._logger,
+      RequestHandlerFactory.createHandler(this._logger));
+  }
+
+  /**
+   * Retrieves the audience segments from ODP
+   * @param apiKey ODP public key
+   * @param apiHost Fully-qualified URL of ODP
+   * @param userKey 'vuid' or 'fs_user_id key'
+   * @param userValue Associated value to query for the user key
+   * @param segmentsToCheck Audience segments to check for experiment inclusion
+   */
+  public async fetchSegments(apiKey: string, apiHost: string, userKey: string, userValue: string, segmentsToCheck: string[]): Promise<string[]> {
+    const parameters = new QuerySegmentsParameters({
+      apiKey,
+      apiHost,
+      userKey,
+      userValue,
+      segmentsToCheck,
+    });
+    const segmentsResponse = await this._odpClient.querySegments(parameters);
+    if (!segmentsResponse) {
+      this._logger.log(LogLevel.ERROR, 'Audience segments fetch failed (network error)');
+      return EMPTY_SEGMENTS_COLLECTION;
+    }
+
+        const parsedSegments = this.parseSegmentsResponseJson(segmentsResponse);
+    if (!parsedSegments) {
+      this._logger.log(LogLevel.ERROR, 'Audience segments fetch failed (decode error)');
+      return EMPTY_SEGMENTS_COLLECTION;
+    }
+
+    if (parsedSegments.errors?.length > 0) {
+      const errors = parsedSegments.errors.map((e) => e.message).join('; ');
+
+      this._logger.log(LogLevel.WARNING, `Audience segments fetch failed (${errors})`);
+
+      return EMPTY_SEGMENTS_COLLECTION;
+    }
+
+    const edges = parsedSegments?.data?.customer?.audiences?.edges;
+    if (!edges) {
+      this._logger.log(LogLevel.WARNING, 'Audience segments fetch failed (decode error)');
+      return EMPTY_SEGMENTS_COLLECTION;
+    }
+
+    return edges.filter(edge => edge.node.state == QUALIFIED).map(edge => edge.node.name);
+  }
+
+  /**
+   * Parses JSON response
+   * @param jsonResponse JSON response from ODP
+   * @private
+   * @returns Response Strongly-typed ODP Response object
+   */
+  private parseSegmentsResponseJson(jsonResponse: string): Response | null {
+    let jsonObject = {};
+
+    try {
+      jsonObject = JSON.parse(jsonResponse);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      this._errorHandler.handleError(error);
+      this._logger.log(LogLevel.ERROR, 'Attempted to parse invalid segment response JSON.');
+      return EMPTY_JSON_RESPONSE;
+    }
+
+    if (validate(jsonObject, OdpResponseSchema, false)) {
+      return jsonObject as Response;
+    }
+
+    return EMPTY_JSON_RESPONSE;
+  }
+}