@or-sdk/contacts 3.5.7-beta.2204.0 → 3.5.7

package/src/api/bulkContactsCreateApi.ts

@@ -4,13 +4,8 @@ import BatchProcessApi from './batchProcessApi';
 import { REQUEST_PAYLOAD_MAX_BYTES } from '../constants';
 import { chunkArrByMaxSize, debouncePromise, getObjectSizeInBytes } from '../utils';
 import { v4 } from 'uuid';
-import {
-  BulkContactDto,
-  BulkCreateResultsDto,
-  BulkProgressDto,
-  CreateBulkResponseDto,
-} from '@onereach/types-contacts-api';
-import { BatchBulkCreateData, BulkCreateData } from '../types';
+import { BulkContactDto } from '@onereach/types-contacts-api';
+import { BatchBulkCreateData, BulkCreateData, BulkOptions, CreateBulkResults } from '../types';
 
 export default class BulkContactsCreateApi extends BaseWithPoling {
   constructor(
@@ -48,65 +43,37 @@ export default class BulkContactsCreateApi extends BaseWithPoling {
    * In the case if contactKey is not defined, it it will be automatically set to the index (as string)
    * of contact.
    */
-  public async bulkCreateContacts(
-    bulkName: string,
-    data: BulkCreateData
-  ): Promise<BulkCreateResultsDto> {
+  async bulkCreateContacts(
+    data: BulkCreateData,
+    options: BulkOptions = {},
+  ): Promise<CreateBulkResults> {
     const dataWithContactKeys = this.updateContactsWithContactKeys(data);
-
-    await this.indicesOff();
-    const results: BulkCreateResultsDto = {
+    const { batchSize = REQUEST_PAYLOAD_MAX_BYTES } = options;
+    await this.batchProcessApi.indicesOff();
+    let results: CreateBulkResults = {
       created: {},
       failed: {},
     };
-    await this.setBulkProgress(bulkName);
     try {
       const { contacts, ...rest } = dataWithContactKeys;
-      const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - getObjectSizeInBytes({ ...rest });
+      const contactsMaxSize = batchSize - getObjectSizeInBytes({ ...rest });
       const contactsChunks = chunkArrByMaxSize(contacts, contactsMaxSize);
-      await this.updateBulkProgress(bulkName, {
-        totalBatches: contactsChunks.length,
-        totalContacts: contacts.length,
-        completedBatches: 0,
-        completedContacts: 0,
-      });
+      const batchGroupId = v4();
 
       if (contactsChunks.length === 1) {
-        await this.createContactsInSingleBatch(dataWithContactKeys as BatchBulkCreateData, bulkName);
+        await this.createContactsInSingleBatch(dataWithContactKeys as BatchBulkCreateData, batchGroupId);
       } else {
-        await this.createContactsInMultiBatches(contactsChunks as BulkContactDto[][], rest, bulkName);
+        await this.createContactsInMultiBatches(contactsChunks as BulkContactDto[][], rest, batchGroupId);
       }
+
+      results = await this.getBulkCreateResults(batchGroupId);
     } finally {
-      const indicesOnBatchId = v4();
-      this.indicesOn(indicesOnBatchId);
-      await debouncePromise(() => this.polling(indicesOnBatchId), 3000);
+      await this.batchProcessApi.indicesOn();
     }
 
     return results;
   }
 
-  async getBulkProgress(bulkName: string): Promise<BulkProgressDto> {
-    return this.apiCall({
-      method: 'GET',
-      route: `${this.apiBasePath}/bulk-progress/${bulkName}`,
-    });
-  }
-
-  async setBulkProgress(bulkName: string): Promise<void> {
-    return this.apiCall({
-      method: 'POST',
-      route: `${this.apiBasePath}/bulk-progress/${bulkName}`,
-    });
-  }
-
-  async updateBulkProgress(bulkName: string, progress: BulkProgressDto): Promise<void> {
-    return this.apiCall({
-      method: 'PATCH',
-      route: `${this.apiBasePath}/bulk-progress/${bulkName}`,
-      data: progress,
-    });
-  }
-
   private updateContactsWithContactKeys(data: BulkCreateData): BatchBulkCreateData {
     const dataWithContactKeys = {
       ...data,
@@ -126,20 +93,6 @@ export default class BulkContactsCreateApi extends BaseWithPoling {
     return dataWithContactKeys;
   }
 
-  private async indicesOn(batchId: string): Promise<void> {
-    return this.apiCall({
-      method: 'POST',
-      route: `${this.apiBasePath}/indices-on/${batchId}`,
-    });
-  }
-
-  private async indicesOff(): Promise<void> {
-    return this.apiCall({
-      method: 'POST',
-      route: `${this.apiBasePath}/indices-off`,
-    });
-  }
-
   private checkContactKeysDuplications(contacts: BulkContactDto[]): void {
     contacts.map(({ contactKey }) => contactKey).forEach((key, index, array) => {
       if (index !== array.lastIndexOf(key)) {
@@ -148,32 +101,30 @@ export default class BulkContactsCreateApi extends BaseWithPoling {
     });
   }
 
-  public async getBulkCreateResults(batchGroupId: string): Promise<BulkCreateResultsDto> {
-    const { total, results: firstResults, size } = await this.callGetBulkResults(batchGroupId, 0);
-    let results = { ...firstResults };
-
-    if (total > size) {
-      for (let i = 1;i <= Math.ceil((total - size) / size);i ++) {
-        const { results: nextResults } = await this.callGetBulkResults(batchGroupId, i * 500);
-        results = {
-          created: {
-            ...results.created,
-            ...nextResults.created,
-          },
-          failed: {
-            ...results.failed,
-            ...nextResults.created,
-          },
-        };
-      }
-    }
-    return results;
-  }
-
-  private async callGetBulkResults(batchGroupId: string, skip: number): Promise<CreateBulkResponseDto> {
-    return await this.apiCall<CreateBulkResponseDto>({
-      method: 'GET',
-      route: `${this.apiBasePath}/bulk-results/${batchGroupId}/${skip}`,
+  private async getBulkCreateResults(batchGroupId: string): Promise<CreateBulkResults> {
+    const batchProcessesGroup = await this.batchProcessApi.getBatchProcessesGroup(batchGroupId);
+    return batchProcessesGroup.reduce<CreateBulkResults>((acc, batch) => {
+      const createdContacts = batch.results.reduce<Record<string, string>>((acc, result) => ({
+        ...acc,
+        ...JSON.parse(result),
+      }), {});
+      const failedContacts = batch.messages.reduce<Record<string, string>>((acc, message) => ({
+        ...acc,
+        ...JSON.parse(message),
+      }), {});
+      return {
+        created: {
+          ...acc.created,
+          ...createdContacts,
+        },
+        failed: {
+          ...acc.failed,
+          ...failedContacts,
+        },
+      };
+    }, {
+      created: {},
+      failed: {},
     });
   }
 
@@ -193,20 +144,6 @@ export default class BulkContactsCreateApi extends BaseWithPoling {
     });
     // giving time to 2 lambdas to wake up (1 - create Batch and 2 - ping batch status)
     await debouncePromise(() => this.polling(batchId), 3000);
-
-    const {
-      totalBatches,
-      totalContacts,
-      completedBatches,
-      completedContacts,
-    } = await this.getBulkProgress(batchGroupId);
-
-    await this.updateBulkProgress(batchGroupId, {
-      totalBatches,
-      totalContacts,
-      completedBatches: completedBatches + 1,
-      completedContacts: completedContacts + data.contacts.length,
-    });
   }
 
   private async createContactsInMultiBatches(

package/src/api/contactApi.ts

@@ -20,7 +20,7 @@ import {
 import { CalApiParams, List } from '@or-sdk/base';
 import BatchProcessApi from './batchProcessApi';
 import { getObjectSizeInBytes, chunkArrByMaxSize, debouncePromise } from '../utils';
-import { InitCreateBatchResponse, CreateContactsBatchResults } from '../types';
+import { InitCreateBatchResponse, CreateContactsBatchResults, BulkOptions } from '../types';
 import ContactBookApi from './contactBookApi';
 import { REQUEST_PAYLOAD_MAX_BYTES, CONTACTS_DELETE_MAX_AMOUNT } from '../constants';
 import { ApiError, CreateContactsBatchError } from '../apiError';
@@ -173,9 +173,13 @@ export default class ContactApi extends BaseWithPoling {
    *
    * @see constructor of packages/contacts/src/Contacts
    */
-  async bulkCreateContacts(data: CreateMultipleContactsDto): Promise<void> {
+  async bulkCreateContacts(
+    data: CreateMultipleContactsDto,
+    options: BulkOptions = {}
+  ): Promise<void> {
+    const { batchSize = REQUEST_PAYLOAD_MAX_BYTES } = options;
     const { contacts, ...rest } = data;
-    const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - getObjectSizeInBytes({ ...rest });
+    const contactsMaxSize = batchSize - getObjectSizeInBytes({ ...rest });
     const contactsChunks = chunkArrByMaxSize(contacts, contactsMaxSize);
 
     contactsChunks.length === 1
@@ -190,9 +194,13 @@ export default class ContactApi extends BaseWithPoling {
    *
    * @see batchProcessApi.trackBatchProcess
    */
-  async initCreateBatch(data: CreateMultipleContactsDto): Promise<InitCreateBatchResponse> {
+  async initCreateBatch(
+    data: CreateMultipleContactsDto,
+    options: BulkOptions = {}
+  ): Promise<InitCreateBatchResponse> {
+    const { batchSize = REQUEST_PAYLOAD_MAX_BYTES } = options;
     const { contacts, ...rest } = data;
-    const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - getObjectSizeInBytes({ ...rest });
+    const contactsMaxSize = batchSize - getObjectSizeInBytes({ ...rest });
     const contactsChunks = chunkArrByMaxSize(contacts, contactsMaxSize);
 
     const batchProcess = await this.apiCall<BatchProcessResponseDto>({

package/src/constants.ts

@@ -1,6 +1,6 @@
 export const CONTACTS_SERVICE_KEY = 'contacts-api';
 
-export const REQUEST_PAYLOAD_MAX_BYTES = 150000;
+export const REQUEST_PAYLOAD_MAX_BYTES = 4000000;
 
 export const FAILED_REQUEST_REPEATS = 3;
 

package/src/types.ts

@@ -81,3 +81,17 @@ export type BulkCreateData = Omit<BulkCreateRequestDto, 'batchId' | 'batchGroupI
 & { contacts: OptionalBy<BulkContactDto, 'contactKey'>[]; };
 
 export type BatchBulkCreateData = Omit<BulkCreateRequestDto, 'batchId' | 'batchGroupId'>;
+
+export type CreateBulkResults = {created: Record<string, string>; failed: Record<string, string>;};
+
+export type BulkOptions = {
+  /**
+   * Sets the limit in bytes for the JSON body size to be processed by a single bulk batch.
+   * Can be used for decreasing DB server load.
+   * Default is 4000000 bytes, or approximately 4mb.
+   *
+   * @see REQUEST_PAYLOAD_MAX_BYTES in packages/contacts/src/constants.ts
+   */
+  batchSize?: number;
+};
+