@or-sdk/hitl 0.35.0-beta.2816.0 → 0.35.0

package/src/api/ContactRuleGroups.ts

@@ -1,5 +1,4 @@
-import _ from 'lodash';
-
+import { DEFAULT_OMIT_FIELDS } from '../constants';
 import {
   SearchRuleGroupsOptions,
   SearchRuleGroupsResponse,
@@ -8,61 +7,88 @@ import {
   UpdateRuleGroupOptions,
   DeleteRuleGroupOptions,
 } from '../types/rule-groups';
+
 import { HITLBase } from './HITLBase';
 
 export class ContactRuleGroups extends HITLBase {
   protected static MODULE_URL = 'contact-rule-groups';
 
+  /**
+   * @description Get/search Contact Rule Groups
+   * @param options
+   */
   public static searchContactRuleGroups(
-    options: SearchRuleGroupsOptions = {}
+    { groupIdList, ...options }: SearchRuleGroupsOptions = {}
   ): Promise<SearchRuleGroupsResponse | RuleGroup> {
     const route = this.getBaseUrl(options);
-    const params = _.omit(options, ['version', 'groupIdList', 'accountId']);
-    const data = _.pick(options, 'groupIdList');
+    const params = Object.fromEntries(
+      Object.entries(options).filter(([key]) => ![...DEFAULT_OMIT_FIELDS, 'accountId'].includes(key))
+    );
 
     return this.request({
       route,
       params,
-      data,
+      data: { groupIdList },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Create Contact Rule Group
+   * @param options
+   */
   public static createContactRuleGroup(
-    options: CreateRuleGroupOptions
+    { groupId, name, rules, ...options }: CreateRuleGroupOptions
   ): Promise<RuleGroup> {
     const route = this.getBaseUrl(options);
-    const data = _.pick(options, ['name', 'rules']);
 
     return this.request({
       method: 'POST',
       route,
-      data,
+      data: {
+        groupId,
+        name,
+        rules,
+      },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Update Contact Rule Group
+   * @param options
+   */
   public static updateContactRuleGroup(
-    options: UpdateRuleGroupOptions
+    { groupId, name, rules, ...options }: UpdateRuleGroupOptions
   ): Promise<RuleGroup> {
     const route = this.getBaseUrl(options);
-    const data = _.pick(options, ['groupId', 'name', 'rules']);
 
     return this.request({
       method: 'PUT',
       route,
-      data,
+      data: {
+        groupId,
+        name,
+        rules,
+      },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Delete Contact Rule Group
+   * @param options
+   */
   public static deleteContactRuleGroup(
-    options: DeleteRuleGroupOptions
+    { groupId, ...options }: DeleteRuleGroupOptions
   ): Promise<void> {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['groupId']);
 
     return this.request({
       method: 'DELETE',
       route,
-      params,
+      params: { groupId },
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/Contacts.ts

@@ -1,7 +1,15 @@
 import { SearchContactsOptions, SearchContactsResponse } from '../types/contacts';
+
 import { HITLBase } from './HITLBase';
 export class Contacts extends HITLBase {
   protected static MODULE_URL = 'contacts';
+
+  /**
+   * @description Search contacts limited by Agent's Contact Rule Groups
+   * (filters out Contact records not "visible" to a given Agent, according
+   * to the Contact Rule Groups the Agent is a member of)
+   * @param options
+   */
   public static async searchContacts(
     options: SearchContactsOptions
   ): Promise<SearchContactsResponse> {
@@ -11,6 +19,7 @@ export class Contacts extends HITLBase {
       method: 'POST',
       route,
       data: options,
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/ContactsMeta.ts

@@ -1,27 +1,37 @@
-import _ from 'lodash';
 import URI from 'urijs';
 
+import { DEFAULT_OMIT_FIELDS } from '../constants';
 import {
   SearchContactsMetaOptions,
   SearchContactsMetaResponse,
 } from '../types/contacts-meta';
+
 import { HITLBase } from './HITLBase';
 
 export class ContactsMeta extends HITLBase {
   protected static MODULE_URL = 'contacts-meta';
   protected static SEARCH_URL = 'search';
 
+  /**
+   * @description Get HitL specific Contacts parameters (meta info):
+   * a list of Contact record fields visible in CRM card,
+   * identifier to conversation trigger map, etc.
+   * @param options
+   */
   public static async searchContactsMeta(
     options: SearchContactsMetaOptions
   ): Promise<SearchContactsMetaResponse> {
     const baseUrl = this.getBaseUrl(options);
     const route = new URI(baseUrl).segment(this.SEARCH_URL).href();
-    const data = _.omit(options, ['version']);
+    const data = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       method: 'POST',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/EventTemplates.ts

@@ -1,5 +1,4 @@
-import _ from 'lodash';
-
+import { DEFAULT_OMIT_FIELDS } from '../constants';
 import {
   GetEventTemplatesOptions,
   GetEventTemplatesResponse,
@@ -8,60 +7,83 @@ import {
   DeleteEventTemplateOptions,
   EventTemplate,
 } from '../types/event-templates';
+
 import { HITLBase } from './HITLBase';
 
 export class EventTemplates extends HITLBase {
   protected static readonly MODULE_URL = 'event-templates';
 
+  /**
+   * @description Get Event templates
+   * @param options
+   */
   public static async getEventTemplates(
-    options: GetEventTemplatesOptions = {}
+    { templateId, ...options }: GetEventTemplatesOptions = {}
   ): Promise<GetEventTemplatesResponse | EventTemplate> {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['templateId']);
 
     return this.request({
       method: 'GET',
       route,
-      params,
+      params: { templateId },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Create Event template
+   * @param options
+   */
   public static async createEventTemplate(
     options: CreateEventTemplateOptions
   ): Promise<EventTemplate> {
     const route = this.getBaseUrl(options);
-    const data = _.omit(options, ['version']);
+    const data = Object.fromEntries(
+      Object.entries(options).filter(([key]) => ![...DEFAULT_OMIT_FIELDS, 'templateId'].includes(key))
+    );
 
     return this.request({
       method: 'POST',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Update Event template
+   * @param options
+   */
   public static async updateEventTemplate(
     options: UpdateEventTemplateOptions
   ): Promise<EventTemplate> {
     const route = this.getBaseUrl(options);
-    const data = _.omit(options, ['version']);
+    const data = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       method: 'PUT',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Delete Event template
+   * @param options
+   */
   public static async deleteEventTemplate(
-    options: DeleteEventTemplateOptions
+    { templateId, ...options }: DeleteEventTemplateOptions
   ): Promise<void> {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['templateId']);
 
     return this.request({
       method: 'DELETE',
       route,
-      params,
+      params: { templateId },
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/Filters.ts

@@ -1,7 +1,5 @@
-import _ from 'lodash';
 import URI from 'urijs';
 
-import { HITLBase } from './HITLBase';
 import {
   FilterV1,
   Filter,
@@ -23,6 +21,8 @@ import {
   BulkUpdateFiltersResponse,
 } from '../types/filters';
 
+import { HITLBase } from './HITLBase';
+
 export class Filters extends HITLBase {
   protected static MODULE_URL = 'filters';
   protected static BULK_URL = 'bulk';
@@ -35,106 +35,145 @@ export class Filters extends HITLBase {
     'ruleTags',
     'tags',
   ];
-  protected static FILTER_VERSION_FIELD = 'filterVersion';
+  protected static FILTER_VERSION_FIELD = 'filterVersion' as const;
 
+  /**
+   * @description Get Conversation view filters list
+   * @param options
+   */
   public static getFilters(options: GetFiltersOptionsV1): Promise<GetFiltersResponseV1>;
   public static getFilters(options: GetFiltersOptions): Promise<GetFiltersResponse>;
   public static getFilters(
-    options: GetFiltersOptions = {}
+    { id, agentId, ignoreRuleTags, ...options }: GetFiltersOptions = {}
   ) {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['id', 'agentId', 'ignoreRuleTags']);
 
     return this.request({
       method: 'GET',
       route,
-      params,
+      params: {
+        id,
+        agentId,
+        ignoreRuleTags,
+      },
+      ...this.getBaseSettings(options),
     });
   }
 
+
+  /**
+   * @description Bulk get Conversation view filters list ignoring userId for personal filters
+   * @param options
+   */
   public static bulkGetFilters(options: BulkGetFiltersOptionsV1): Promise<GetFiltersResponseV1>;
   public static bulkGetFilters(options: BulkGetFiltersOptions): Promise<GetFiltersResponse>;
   public static bulkGetFilters(
-    options: BulkGetFiltersOptions = {}
+    { ignoreRuleTags, ...options }: BulkGetFiltersOptions = {}
   ) {
     const baseUrl = this.getBaseUrl(options);
     const route = new URI(baseUrl).segment(this.BULK_URL).href();
-    const params = _.pick(options, ['ignoreRuleTags']);
 
     return this.request({
       method: 'GET',
       route,
-      params,
+      params: { ignoreRuleTags },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Create Conversation view filter
+   * @param options
+   */
   public static createFilter(options: CreateFilterOptionsV1): Promise<FilterV1>;
   public static createFilter(options: CreateFilterOptions): Promise<Filter>;
-  public static createFilter(options: CreateFilterOptions) {
+  public static createFilter({ isCommon, agentId, ...options }: CreateFilterOptions) {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['isCommon', 'agentId']);
     const data = {
-      ..._.pick(options, this.DEFAULT_FIELDS),
-      version: _.get(options, this.FILTER_VERSION_FIELD),
+      ...Object.fromEntries(
+        Object.entries(options).filter(([key]) => this.DEFAULT_FIELDS.includes(key))
+      ),
+      version: options[this.FILTER_VERSION_FIELD],
     };
 
     return this.request({
       method: 'POST',
       route,
-      params,
+      params: {
+        isCommon,
+        agentId,
+      },
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Update Conversation view filter
+   * @param options
+   */
   public static updateFilter(options: UpdateFilterOptionsV1): Promise<FilterV1>;
   public static updateFilter(options: UpdateFilterOptions): Promise<Filter>;
   public static updateFilter(options: UpdateFilterOptions) {
     const route = this.getBaseUrl(options);
     const data = {
-      ..._.pick(options, ['id', ...this.DEFAULT_FIELDS]),
-      version: _.get(options, this.FILTER_VERSION_FIELD),
+      ...Object.fromEntries(
+        Object.entries(options).filter(([key]) => [...this.DEFAULT_FIELDS, 'id'].includes(key))
+      ),
+      version: options[this.FILTER_VERSION_FIELD],
     };
 
     return this.request({
       method: 'PUT',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Bulk update Conversation view filters ignoring userId for personal filters
+   * @param options
+   */
   public static bulkUpdateFilters(options: BulkUpdateFiltersOptionsV1): Promise<BulkUpdateFiltersResponseV1>;
   public static bulkUpdateFilters(options: BulkUpdateFiltersOptions): Promise<BulkUpdateFiltersResponse>;
-  public static bulkUpdateFilters(options: BulkUpdateFiltersOptionsV1) {
+  // TODO: added ` & { filterVersion?: string; }` hack to make it build
+  public static bulkUpdateFilters(options: BulkUpdateFiltersOptionsV1 & { filterVersion?: string; }) {
     const baseUrl = this.getBaseUrl(options);
     const route = new URI(baseUrl).segment(this.BULK_URL).href();
     const data = {
-      filters: options?.filters.map(filter =>
-        ({
-          ..._.pick(filter, ['id', ...this.DEFAULT_FIELDS]),
-          version: _.get(options, this.FILTER_VERSION_FIELD),
-        })
-      ),
+      filters: options?.filters.map(filter => {
+        return {
+          ...Object.fromEntries(
+            Object.entries(filter).filter(([key]) => [...this.DEFAULT_FIELDS, 'id'].includes(key))
+          ),
+          version: options[this.FILTER_VERSION_FIELD],
+        };
+      }),
     };
 
     return this.request({
       method: 'PUT',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Delete Conversation view filter
+   * @param options
+   */
   public static deleteFilter(options: DeleteFilterOptionsV1): Promise<GetFiltersResponseV1 | FilterV1>;
   public static deleteFilter(options: DeleteFilterOptions): Promise<GetFiltersResponse | Filter>;
-  public static deleteFilter(
-    options: DeleteFilterOptions
-  ) {
+  public static deleteFilter({ id, ...options }: DeleteFilterOptions) {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['id']);
 
     return this.request({
       method: 'DELETE',
       route,
-      params,
+      params: { id },
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/HITLBase.ts

@@ -37,4 +37,8 @@ export class HITLBase {
     };
     return this.format(this.BASE_URL, content);
   }
+
+  protected static getBaseSettings({ timeout }: BaseUrlOptions = {}) {
+    return { timeout };
+  }
 }

package/src/api/Helpers.ts

@@ -2,12 +2,17 @@ import URI from 'urijs';
 
 import { ApiVersionOptions } from '../types';
 import { CleanUpDuplicatesResponse } from '../types/helpers';
+
 import { HITLBase } from './HITLBase';
 
 export class Helpers extends HITLBase {
   protected static MODULE_URL = 'helpers';
   protected static CLEAN_CONTACTS = 'clean-contact-duplicates';
 
+  /**
+   * @description Delete Contact duplicates (Tables-based contacts v1)
+   * @param options
+   */
   public static async deleteContactDuplicates(
     options: ApiVersionOptions
   ): Promise<CleanUpDuplicatesResponse> {
@@ -17,6 +22,7 @@ export class Helpers extends HITLBase {
     return this.request({
       method: 'DELETE',
       route,
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/Listeners.ts

@@ -1,7 +1,6 @@
-import _ from 'lodash';
 import URI from 'urijs';
 
-import { HITLBase } from './HITLBase';
+import { DEFAULT_OMIT_FIELDS } from '../constants';
 import {
   Listener,
   GetListenersOptions,
@@ -12,72 +11,109 @@ import {
   DeleteListenersOptions,
 } from '../types/listeners';
 
+import { HITLBase } from './HITLBase';
+
+/**
+ * HitL events Listener is an object describing a real-time Evnets callback -
+ * either an active WebSocket in Agent UI, flow event subscription callback or a
+ * mobile application push notification "callbacks"
+ */
 export class Listeners extends HITLBase {
   protected static MODULE_URL = 'listeners';
 
+  /**
+   * @description Get a list of HitL event listeners
+   * @param options
+   */
   public static async getListeners(
     options: GetListenersOptions = {}
   ): Promise<GetListenersResponse> {
     const route = this.getBaseUrl(options);
-    const params = _.omit(options, ['version']);
+    const params = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       method: 'GET',
       route,
       params,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Get HitL event listeners by id
+   * @param options
+   */
   public static async getListenerById(
-    options: GetListenerByIdOptions
+    { agentId, callbackId, ...options }: GetListenerByIdOptions
   ): Promise<GetListenersResponse> {
     const baseUrl = this.getBaseUrl(options);
-    const route = new URI(baseUrl).segment(options.callbackId).href();
-    const params = _.pick(options, ['agentId']);
+    const route = new URI(baseUrl).segment(callbackId).href();
 
     return this.request({
       method: 'GET',
       route,
-      params,
+      params: { agentId },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Create HitL event listener
+   * @param options
+   */
   public static async createListener(
     options: CreateListenersOptions
   ): Promise<Listener> {
     const route = this.getBaseUrl(options);
-    const data = _.omit(options, ['version']);
+    const data = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       method: 'POST',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Update HitL event listener
+   * @param options
+   */
   public static async updateListener(
-    options: UpdateListenersOptions
+    { callbackId, ...options }: UpdateListenersOptions
   ): Promise<Listener> {
     const baseUrl = this.getBaseUrl(options);
-    const route = new URI(baseUrl).segment(options.callbackId).href();
-    const data = _.omit(options, ['callbackId', 'version']);
+    const route = new URI(baseUrl).segment(callbackId).href();
+    const data = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       method: 'PUT',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Delete HitL event listener
+   * @param options
+   */
   public static async deleteListener(
-    options: DeleteListenersOptions
+    { callbackId, ...options }: DeleteListenersOptions
   ): Promise<void> {
     const baseUrl = this.getBaseUrl(options);
-    const route = new URI(baseUrl).segment(options.callbackId).href();
+    const route = new URI(baseUrl).segment(callbackId).href();
 
     return this.request({
       method: 'DELETE',
       route,
+      ...this.getBaseSettings(options),
     });
   }
 }