@webex/internal-plugin-dss 2.60.1-next.9 → 2.60.2

package/src/dss.ts

@@ -2,13 +2,10 @@
 /*!
  * Copyright (c) 2015-2022 Cisco Systems, Inc. See LICENSE file.
  */
-/* eslint-disable no-underscore-dangle */
 import uuid from 'uuid';
 import {WebexPlugin} from '@webex/webex-core';
 import '@webex/internal-plugin-mercury';
 import {range, isEqual, get} from 'lodash';
-
-import {Timer} from '@webex/common-timers';
 import type {
   SearchOptions,
   LookupDetailOptions,
@@ -16,6 +13,7 @@ import type {
   LookupByEmailOptions,
   SearchPlaceOptions,
 } from './types';
+
 import {
   DSS_REGISTERED,
   DSS_UNREGISTERED,
@@ -24,15 +22,7 @@ import {
   DSS_SERVICE_NAME,
   DSS_SEARCH_MERCURY_EVENT,
   DSS_RESULT,
-  LOOKUP_DATA_PATH,
-  LOOKUP_FOUND_PATH,
-  LOOKUP_NOT_FOUND_PATH,
-  LOOKUP_REQUEST_KEY,
-  SEARCH_DATA_PATH,
 } from './constants';
-import DssBatcher from './dss-batcher';
-import {DssTimeoutError} from './dss-errors';
-import {BatcherOptions, RequestOptions, RequestResult} from './types';
 
 const DSS = WebexPlugin.extend({
   namespace: 'DSS',
@@ -45,18 +35,6 @@ const DSS = WebexPlugin.extend({
    */
   registered: false,
 
-  /**
-   * Initializer
-   * @private
-   * @param {Object} attrs
-   * @param {Object} options
-   * @returns {undefined}
-   */
-  initialize(...args) {
-    Reflect.apply(WebexPlugin.prototype.initialize, this, args);
-    this.batchers = {};
-  },
-
   /**
    * Explicitly sets up the DSS plugin by connecting to mercury, and listening for DSS events.
    * @returns {Promise}
@@ -136,7 +114,6 @@ const DSS = WebexPlugin.extend({
   },
 
   /**
-   * constructs the event name based on request id
    * @param {UUID} requestId the id of the request
    * @returns {string}
    */
@@ -145,7 +122,6 @@ const DSS = WebexPlugin.extend({
   },
 
   /**
-   * Takes incoming data and triggers correct events
    * @param {Object} data the event data
    * @returns {undefined}
    */
@@ -158,78 +134,40 @@ const DSS = WebexPlugin.extend({
    * Makes the request to the directory service
    * @param {Object} options
    * @param {string} options.resource the URL to query
-   * @param {Mixed} options.params additional params for the body of the request
-   * @param {string} options.dataPath the path to get the data in the result object
-   * @param {string} [options.foundPath] the path to get the lookups of the found data
-   * @param {string} [options.notFoundPath] the path to get the lookups of the not found data
-   * @returns {Promise<Object>} result Resolves with an object
-   * @returns {Array} result.resultArray an array of entities found
-   * @returns {Array} result.foundArray an array of the lookups of the found entities (if foundPath provided)
-   * @returns {Array} result.notFoundArray an array of the lookups of the not found entities (if notFoundPath provided)
-   * @throws {DssTimeoutError} when server does not respond in the specified timeframe
+   * @param {string} options.params additional params for the body of the request
+   * @param {string} options.dataPath to path to get the data in the result object
+   * @returns {Promise} Resolves with an array of entities found
    */
-  _request(options: RequestOptions): Promise<RequestResult> {
-    const {resource, params, dataPath, foundPath, notFoundPath} = options;
+  _request(options) {
+    const {resource, params, dataPath} = options;
 
-    const timeout = this.config.requestTimeout;
     const requestId = uuid.v4();
     const eventName = this._getResultEventName(requestId);
     const result = {};
-    let expectedSeqNums: string[];
-    let notFoundArray: unknown[];
-
-    return new Promise((resolve, reject) => {
-      const timer = new Timer(() => {
-        this.stopListening(this, eventName);
-        reject(new DssTimeoutError({requestId, timeout, resource, params}));
-      }, timeout);
+    let expectedSeqNums;
 
+    return new Promise((resolve) => {
       this.listenTo(this, eventName, (data) => {
-        timer.reset();
-        const resultData = get(data, dataPath, []);
-        let found;
+        const resultData = get(data, dataPath);
 
-        if (foundPath) {
-          found = get(data, foundPath, []);
-        }
-        result[data.sequence] = foundPath ? {resultData, found} : {resultData};
+        result[data.sequence] = resultData;
 
         if (data.finished) {
           expectedSeqNums = range(data.sequence + 1).map(String);
-          if (notFoundPath) {
-            notFoundArray = get(data, notFoundPath, []);
-          }
         }
 
         const done = isEqual(expectedSeqNums, Object.keys(result));
 
         if (done) {
-          timer.cancel();
-
-          const resultArray: any[] = [];
-          const foundArray: any[] = [];
-
+          const resultArray = [];
           expectedSeqNums.forEach((index) => {
             const seqResult = result[index];
-
             if (seqResult) {
-              resultArray.push(...seqResult.resultData);
-              if (foundPath) {
-                foundArray.push(...seqResult.found);
-              }
+              resultArray.push(...seqResult);
             }
           });
-          const resolveValue: RequestResult = {
-            resultArray,
-          };
-
-          if (foundPath) {
-            resolveValue.foundArray = foundArray;
-          }
-          if (notFoundPath) {
-            resolveValue.notFoundArray = notFoundArray;
-          }
-          resolve(resolveValue);
+
+          resolve(resultArray);
           this.stopListening(this, eventName);
         }
       });
@@ -240,128 +178,62 @@ const DSS = WebexPlugin.extend({
         contentType: 'application/json',
         body: {requestId, ...params},
       });
-      timer.start();
     });
   },
 
-  /**
-   * Uses a batcher to make the request to the directory service
-   * @param {Object} options
-   * @param {string} options.resource the URL to query
-   * @param {string} options.value the id or email to lookup
-   * @returns {Promise} Resolves with an array of entities found
-   * @throws {DssTimeoutError} when server does not respond in the specified timeframe
-   */
-  _batchedLookup(options: BatcherOptions) {
-    const {resource, lookupValue} = options;
-    const dataPath = LOOKUP_DATA_PATH;
-    const entitiesFoundPath = LOOKUP_FOUND_PATH;
-    const entitiesNotFoundPath = LOOKUP_NOT_FOUND_PATH;
-    const requestKey = LOOKUP_REQUEST_KEY;
-
-    this.batchers[resource] =
-      this.batchers[resource] ||
-      new DssBatcher({
-        resource,
-        dataPath,
-        entitiesFoundPath,
-        entitiesNotFoundPath,
-        requestKey,
-        parent: this,
-      });
-
-    return this.batchers[resource].request(lookupValue);
-  },
-
   /**
    * Retrieves detailed information about an entity
    * @param {Object} options
    * @param {UUID} options.id the id of the entity to lookup
-   * @returns {Promise} Resolves with the entity found or null if not found
-   * @throws {DssTimeoutError} when server does not respond in the specified timeframe
+   * @returns {Promise} Resolves with an array of entities found
    */
   lookupDetail(options: LookupDetailOptions) {
     const {id} = options;
 
-    const resource = `/lookup/orgid/${this.webex.internal.device.orgId}/identity/${id}/detail`;
-
     return this._request({
-      dataPath: LOOKUP_DATA_PATH,
-      foundPath: LOOKUP_FOUND_PATH,
-      resource,
-    }).then(({resultArray, foundArray}) => {
-      // TODO: find out what is actually returned!
-      if (foundArray[0] === id) {
-        return resultArray[0];
-      }
-
-      return null;
+      dataPath: 'lookupResult.entities',
+      resource: `/lookup/orgid/${this.webex.internal.device.orgId}/identity/${id}/detail`,
     });
   },
 
   /**
-   * Retrieves basic information about an entity within an organization
+   * Retrieves basic information about a list entities within an organization
    * @param {Object} options
-   * @param {UUID} options.id the id of the entity to lookup
-   * @param {UUID} [options.entityProviderType] the provider to query
-   * @param {Boolean} options.shouldBatch whether to batch the query, set to false for single immediate result (defaults to true)
-   * @returns {Promise} Resolves with the entity found or null if not found
-   * @throws {DssTimeoutError} when server does not respond in the specified timeframe
+   * @param {UUID} options.ids the id of the entity to lookup
+   * @param {UUID} options.entityProviderType the provider to query (optional)
+   * @returns {Promise} Resolves with an array of entities found
    */
   lookup(options: LookupOptions) {
-    const {id, entityProviderType, shouldBatch = true} = options;
+    const {ids, entityProviderType} = options;
 
     const resource = entityProviderType
       ? `/lookup/orgid/${this.webex.internal.device.orgId}/entityprovidertype/${entityProviderType}`
       : `/lookup/orgid/${this.webex.internal.device.orgId}/identities`;
 
-    if (shouldBatch) {
-      return this._batchedLookup({
-        resource,
-        lookupValue: id,
-      });
-    }
-
     return this._request({
-      dataPath: LOOKUP_DATA_PATH,
-      foundPath: LOOKUP_FOUND_PATH,
+      dataPath: 'lookupResult.entities',
       resource,
       params: {
-        [LOOKUP_REQUEST_KEY]: [id],
+        lookupValues: ids,
       },
-    }).then(({resultArray, foundArray}) => {
-      if (foundArray[0] === id) {
-        return resultArray[0];
-      }
-
-      return null;
     });
   },
 
   /**
-   * Retrieves basic information about an enitity within an organization
+   * Retrieves basic information about a list entities within an organization
    * @param {Object} options
-   * @param {UUID} options.email the email of the entity to lookup
-   * @returns {Promise} Resolves with the entity found or rejects if not found
-   * @throws {DssTimeoutError} when server does not respond in the specified timeframe
+   * @param {UUID} options.emails the emails of the entities to lookup
+   * @returns {Promise} Resolves with an array of entities found
    */
   lookupByEmail(options: LookupByEmailOptions) {
-    const {email} = options;
-    const resource = `/lookup/orgid/${this.webex.internal.device.orgId}/emails`;
+    const {emails} = options;
 
     return this._request({
-      dataPath: LOOKUP_DATA_PATH,
-      foundPath: LOOKUP_FOUND_PATH,
-      resource,
+      dataPath: 'lookupResult.entities',
+      resource: `/lookup/orgid/${this.webex.internal.device.orgId}/emails`,
       params: {
-        [LOOKUP_REQUEST_KEY]: [email],
+        lookupValues: emails,
       },
-    }).then(({resultArray, foundArray}) => {
-      if (foundArray[0] === email) {
-        return resultArray[0];
-      }
-
-      return null;
     });
   },
 
@@ -372,20 +244,19 @@ const DSS = WebexPlugin.extend({
    * @param {string[]} options.queryString A query string that will be transformed into a Directory search filter query. It is used to search the following fields: username, givenName, familyName, displayName and email
    * @param {number} options.resultSize The maximum number of results returned from each provider
    * @returns {Promise} Resolves with an array of entities found
-   * @throws {DssTimeoutError} when server does not respond in the specified timeframe
    */
   search(options: SearchOptions) {
     const {requestedTypes, resultSize, queryString} = options;
 
     return this._request({
-      dataPath: SEARCH_DATA_PATH,
+      dataPath: 'directoryEntities',
       resource: `/search/orgid/${this.webex.internal.device.orgId}/entities`,
       params: {
         queryString,
         resultSize,
         requestedTypes,
       },
-    }).then(({resultArray}) => resultArray);
+    });
   },
 
   /**

package/src/index.ts

@@ -1,8 +1,7 @@
 import {registerInternalPlugin} from '@webex/webex-core';
 
 import DSS from './dss';
-import config from './config';
 
-registerInternalPlugin('dss', DSS, {config});
+registerInternalPlugin('dss', DSS);
 
 export {default} from './dss';

package/src/types.ts

@@ -1,17 +1,3 @@
-export interface RequestOptions {
-  resource: string;
-  dataPath: string;
-  foundPath?: string;
-  notFoundPath?: string;
-  params?: Record<string, unknown>;
-}
-
-export interface RequestResult {
-  foundArray?: any[];
-  notFoundArray?: any[];
-  resultArray: any[];
-}
-
 export interface LookupDetailOptions {
   id: string;
 }
@@ -24,16 +10,14 @@ export enum EntityProviderType {
 }
 
 export interface LookupOptions {
-  id: string;
+  ids: string[];
   entityProviderType?: EntityProviderType;
-  shouldBatch?: boolean;
 }
 
 export interface LookupByEmailOptions {
-  email: string;
+  emails: string[];
 }
 
-// eslint-disable-next-line no-shadow
 export enum SearchType {
   PERSON = 'PERSON',
   CALLING_SERVICE = 'CALLING_SERVICE',
@@ -48,11 +32,6 @@ export interface SearchOptions {
   queryString: string;
 }
 
-export interface BatcherOptions {
-  resource: string;
-  lookupValue: string;
-}
-
 export interface SearchPlaceOptions {
   resultSize: number;
   queryString: string;