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

package/src/api/Migrations.ts

@@ -1,4 +1,7 @@
-import _ from 'lodash';
+import URI from 'urijs';
+
+import { DEFAULT_OMIT_FIELDS } from '../constants';
+import { ApiVersionOptions } from '../types';
 import {
   GetMigrationsOptions,
   GetMigrationsResponse,
@@ -12,8 +15,8 @@ import {
   SyncDefaultRecordsOptions,
   SyncDefaultRecordsResponse,
 } from '../types/migrations';
+
 import { HITLBase } from './HITLBase';
-import URI from 'urijs';
 
 export class Migrations extends HITLBase {
   protected static readonly MODULE_URL = 'migrations';
@@ -22,92 +25,136 @@ export class Migrations extends HITLBase {
   protected static MIGRATIONS_LOCK_URL = 'lock';
   protected static MIGRATIONS_STATUS_URL = 'status';
 
+  /**
+   * @description Get list of pending migrations
+   * @param options
+   */
   public static async getListOfMigrations(
-    options: GetMigrationsOptions = {}
+    { appVersion, ...options }: GetMigrationsOptions = {}
   ): Promise<GetMigrationsResponse> {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['appVersion']);
 
     return this.request({
       route,
-      params,
+      params: { appVersion },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Run migrations
+   * @param options
+   */
   public static async runAllMigrations(
-    options: RunMigrationsOptions = {}
+    { meta, ...options }: RunMigrationsOptions = {}
   ): Promise<RunMigrationsResponse> {
     const route = this.getBaseUrl(options);
-    const params = _.omit(options, ['version', 'meta']);
-    const data = _.pick(options, ['meta']);
+    const params = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       route,
       method: 'POST',
       params,
-      data,
+      data: { meta },
+      ...this.getBaseSettings(options),
     });
   }
 
-  public static async getRunMigrationsStatus(): Promise<GetRunMigrationsStatusResponse> {
+  /**
+   * @description Get status of running migrations
+   * @param options
+   */
+  public static async getRunMigrationsStatus(options: ApiVersionOptions = {}): Promise<GetRunMigrationsStatusResponse> {
     const baseUrl = this.getBaseUrl({});
     const route = new URI(baseUrl).segment(this.MIGRATIONS_STATUS_URL).href();
 
     return this.request({
       route,
+      ...this.getBaseSettings(options),
     });
   }
 
-  public static async deleteMigrationsTableLock() {
+  /**
+   * @description Delete migrations table lock (set during migration runs)
+   * @param options
+   */
+  public static async deleteMigrationsTableLock(options: ApiVersionOptions = {}) {
     const baseUrl = this.getBaseUrl({});
     const route = new URI(baseUrl).segment(this.MIGRATIONS_LOCK_URL).href();
 
     return this.request({
       route,
       method: 'DELETE',
+      ...this.getBaseSettings(options),
     });
   }
 
-  public static async getMigrationsInfo(): Promise<GetMigrationsInfoResponse> {
+  /**
+   * @description Get migrations info about compatibility with UI versions
+   * @param options
+   */
+  public static async getMigrationsInfo(options: ApiVersionOptions = {}): Promise<GetMigrationsInfoResponse> {
     const baseUrl = this.getBaseUrl({});
     const route = new URI(baseUrl).segment(this.MIGRATIONS_INFO_URL).href();
 
     return this.request({
       route,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Get default records for some tables (settings, filters, eventTemplates, rule_groups)
+   * @param options
+   */
   public static async getTableDefaultRecords(options: GetDefaultRecordsOptions): Promise<GetDefaultRecordsResponse> {
     const baseUrl = this.getBaseUrl({});
     const route = new URI(baseUrl).segment(this.DEFAULT_RECORDS_URL).href();
-    const params = _.omit(options, ['version']);
+    const params = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !['version'].includes(key))
+    );
 
     return this.request({
       route,
       method: 'GET',
       params,
+      ...this.getBaseSettings(options),
     });
   }
 
-  public static async createTableDefaultRecords(): Promise<CreateDefaultRecordsResponse> {
+  /**
+   * @description Add default records for some tables (settings, filters, event_templates, rule_groups)
+   * @param options
+   */
+  public static async createTableDefaultRecords(options: ApiVersionOptions = {}): Promise<CreateDefaultRecordsResponse> {
     const baseUrl = this.getBaseUrl({});
     const route = new URI(baseUrl).segment(this.DEFAULT_RECORDS_URL).href();
 
     return this.request({
       route,
       method: 'POST',
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Sync default records for some tables (settings, filters, eventTemplates, rule_groups)
+   * @param options
+   */
   public static async syncTableDefaultRecords(options: SyncDefaultRecordsOptions): Promise<SyncDefaultRecordsResponse> {
     const baseUrl = this.getBaseUrl({});
     const route = new URI(baseUrl).segment(this.DEFAULT_RECORDS_URL).href();
-    const params = _.omit(options, ['version']);
+    const params = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       route,
       method: 'PUT',
       params,
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/RuleGroups.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 RuleGroups extends HITLBase {
   protected static MODULE_URL = 'rule-groups';
 
+  /**
+   * @description Get/search Rule Groups
+   * @param options
+   */
   public static searchRuleGroups(
-    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 Rule Group
+   * @param options
+   */
   public static createRuleGroup(
-    options: CreateRuleGroupOptions
+    { name, rules, groupId, ...options }: CreateRuleGroupOptions
   ): Promise<RuleGroup> {
     const route = this.getBaseUrl(options);
-    const data = _.pick(options, ['name', 'rules']);
 
     return this.request({
       method: 'POST',
       route,
-      data,
+      data: {
+        name,
+        rules,
+        groupId,
+      },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Update Rule Group
+   * @param options
+   */
   public static updateRuleGroup(
-    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 Rule Group
+   * @param options
+   */
   public static deleteRuleGroup(
-    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/SessionEvents.ts

@@ -1,81 +1,130 @@
-import _ from 'lodash';
 import URI from 'urijs';
 
-import { HITLBase } from './HITLBase';
+import { DEFAULT_OMIT_FIELDS } from '../constants';
+import {
+  GetNewEventsCountOptions,
+  GetNewEventsCountResponse,
+  SaveLastReadEventOptions,
+} from '../types/read-events';
 import {
   GetSessionEventsOptions,
   GetSessionEventsResponse,
   AddEventsOptions,
   AddEventsResponse,
+  GetBulkSessionEventsOptions,
+  GetBulkSessionsEventsResponse,
 } from '../types/session-events';
-import {
-  GetNewEventsCountOptions,
-  GetNewEventsCountResponse,
-  SaveLastReadEventOptions,
-} from '../types/read-events';
+
+import { HITLBase } from './HITLBase';
 
 export class SessionEvents extends HITLBase {
   protected static MODULE_URL = 'session-events';
+  protected static GET_BULK_EVENTS_URL = 'bulk';
   protected static GET_EVENTS_COUNT_URL = 'get-new-events';
   protected static SAVE_READ_EVENT_URL = 'save-read-event';
 
+  /**
+   * @description Get Event list of a HitL Session
+   * @param options
+   */
   public static async getSessionEventsList(
     options: GetSessionEventsOptions
   ): Promise<GetSessionEventsResponse> {
     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 Events of multiple HitL Sessions
+   * @param options
+   */
+  public static async getBulkSessionEventsList(
+    options: GetBulkSessionEventsOptions
+  ): Promise<GetBulkSessionsEventsResponse> {
+    const baseUrl = this.getBaseUrl(options);
+    const route = new URI(baseUrl).segment(this.GET_BULK_EVENTS_URL).href();
+    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 Add new Events to HitL Session
+   * @param options
+   */
   public static addEvents(
-    options: AddEventsOptions
+    { sessionId, events, ...options }: AddEventsOptions
   ): Promise<AddEventsResponse> {
     const route = this.getBaseUrl(options);
-    const params = _.pick(options, ['sessionId']);
-    const data = _.pick(options, ['events']);
 
     return this.request({
       method: 'POST',
       route,
-      params,
-      data,
+      params: { sessionId },
+      data: { events },
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Get unread Events count for an Agent
+   * @param options
+   */
   public static async getNewEventsCount(
-    options: GetNewEventsCountOptions
+    // TODO: add userId to GetNewEventsCountOptions
+    { userId, ...options }: GetNewEventsCountOptions & { userId: string; }
   ): Promise<GetNewEventsCountResponse> {
     const baseUrl = this.getBaseUrl(options);
     const route = new URI(baseUrl).segment(this.GET_EVENTS_COUNT_URL).href();
-    const params = _.pick(options, ['userId']);
-    const data = _.omit(options, ['userId', 'version']);
+    const data = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       method: 'POST',
       route,
-      params,
+      params: { userId },
       data,
+      ...this.getBaseSettings(options),
     });
   }
 
+  /**
+   * @description Save last read Event info (event id and timestamp) for a Agent and HitL Session
+   * @param options
+   */
   public static async saveReadEventByUserId(
-    options: SaveLastReadEventOptions
+    // TODO: add userId to SaveLastReadEventOptions
+    { userId, ...options }: SaveLastReadEventOptions & { userId: string; }
   ): Promise<void> {
     const baseUrl = this.getBaseUrl(options);
     const route = new URI(baseUrl).segment(this.SAVE_READ_EVENT_URL).href();
-    const params = _.pick(options, ['userId']);
-    const data = _.omit(options, ['userId', 'version']);
+    const data = Object.fromEntries(
+      Object.entries(options).filter(([key]) => !DEFAULT_OMIT_FIELDS.includes(key))
+    );
 
     return this.request({
       method: 'POST',
       route,
-      params,
+      params: { userId },
       data,
+      ...this.getBaseSettings(options),
     });
   }
 }

package/src/api/SessionRelations.ts

@@ -1,6 +1,4 @@
-import _ from 'lodash';
-
-import { HITLBase } from './HITLBase';
+import { DEFAULT_OMIT_FIELDS } from '../constants';
 import {
   GetSessionRelationsOptions,
   GetSessionRelationsResponse,
@@ -9,44 +7,69 @@ import {
   DeleteSessionRelationsOptions,
 } from '../types/session-relations';
 
+import { HITLBase } from './HITLBase';
+
 export class SessionRelations extends HITLBase {
   protected static MODULE_URL = 'session-relations';
 
+  /**
+   * @description Get a list of HitL Session Relations
+   * @param options
+   */
   public static getSessionRelations(
     options: GetSessionRelationsOptions
   ): Promise<GetSessionRelationsResponse> {
     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),
     });
   }
 
-  public static createSessionRelations(options: CreateSessionRelationsOptions): Promise<CreateSessionRelationsResponse> {
+  /**
+   * @description Create HitL Session Relations
+   * @param options
+   */
+
+  public static createSessionRelations(
+    options: CreateSessionRelationsOptions,
+  ): Promise<CreateSessionRelationsResponse> {
     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 Delete HitL Session Relations
+   * @param options
+   */
   public static deleteSessionRelations(
     options: DeleteSessionRelationsOptions
   ) {
     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: 'DELETE',
       route,
       data,
+      ...this.getBaseSettings(options),
     });
   }
 }