@or-sdk/contacts 3.5.7-beta.2189.0 → 3.5.7-beta.2196.0

package/src/api/bulkContactsCreateApi.ts

@@ -4,8 +4,13 @@ import BatchProcessApi from './batchProcessApi';
 import { REQUEST_PAYLOAD_MAX_BYTES } from '../constants';
 import { chunkArrByMaxSize, debouncePromise, getObjectSizeInBytes } from '../utils';
 import { v4 } from 'uuid';
-import { BulkContactDto } from '@onereach/types-contacts-api';
-import { BatchBulkCreateData, BulkCreateData, CreateBulkResults } from '../types';
+import {
+  BulkContactDto,
+  BulkCreateResultsDto,
+  BulkProgressDto,
+  CreateBulkResponseDto,
+} from '@onereach/types-contacts-api';
+import { BatchBulkCreateData, BulkCreateData } from '../types';
 
 export default class BulkContactsCreateApi extends BaseWithPoling {
   constructor(
@@ -43,37 +48,69 @@ 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.
    */
-  async bulkCreateContacts(
-    data: BulkCreateData,
-    options: {bulkSize?: number;} = {},
-  ): Promise<CreateBulkResults> {
+  public async bulkCreateContacts(
+    bulkName: string,
+    data: BulkCreateData
+  ): Promise<BulkCreateResultsDto> {
     const dataWithContactKeys = this.updateContactsWithContactKeys(data);
-    const { bulkSize = REQUEST_PAYLOAD_MAX_BYTES } = options;
-    await this.batchProcessApi.indicesOff();
-    let results: CreateBulkResults = {
+
+    await this.indicesOff();
+    let results: BulkCreateResultsDto = {
       created: {},
       failed: {},
     };
+    // eslint-disable-next-line no-console
+    console.log('SET BULK PROGRESS');
+    await this.setBulkProgress(bulkName);
+    // eslint-disable-next-line no-console
+    console.log('OK');
     try {
       const { contacts, ...rest } = dataWithContactKeys;
-      const contactsMaxSize = bulkSize - getObjectSizeInBytes({ ...rest });
+      const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - getObjectSizeInBytes({ ...rest });
       const contactsChunks = chunkArrByMaxSize(contacts, contactsMaxSize);
-      const batchGroupId = v4();
 
       if (contactsChunks.length === 1) {
-        await this.createContactsInSingleBatch(dataWithContactKeys as BatchBulkCreateData, batchGroupId);
+        await this.createContactsInSingleBatch(dataWithContactKeys as BatchBulkCreateData, bulkName);
       } else {
-        await this.createContactsInMultiBatches(contactsChunks as BulkContactDto[][], rest, batchGroupId);
+        await this.createContactsInMultiBatches(contactsChunks as BulkContactDto[][], rest, bulkName);
       }
 
-      results = await this.getBulkCreateResults(batchGroupId);
+      // eslint-disable-next-line no-console
+      console.log('GET BULK RESULTS');
+      results = await this.getBulkCreateResults(bulkName);
+      // eslint-disable-next-line no-console
+      console.log('OK');
     } finally {
-      await this.batchProcessApi.indicesOn();
+      const indicesOnBatchId = v4();
+      this.indicesOn(indicesOnBatchId);
+      await debouncePromise(() => this.polling(indicesOnBatchId), 3000);
     }
 
     return results;
   }
 
+  async getBulkProgress(bulkName: string): Promise<BulkProgressDto> {
+    return this.apiCall({
+      method: 'GET',
+      route: `${this.apiBasePath}/bulk-progress/${bulkName}`,
+    });
+  }
+
+  private async setBulkProgress(bulkName: string): Promise<void> {
+    return this.apiCall({
+      method: 'POST',
+      route: `${this.apiBasePath}/bulk-progress/${bulkName}`,
+    });
+  }
+
+  private 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,
@@ -93,6 +130,20 @@ 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)) {
@@ -101,30 +152,32 @@ export default class BulkContactsCreateApi extends BaseWithPoling {
     });
   }
 
-  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: {},
+  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}`,
     });
   }
 
@@ -144,6 +197,27 @@ 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);
+
+    // eslint-disable-next-line no-console
+    console.log('GET TEMP BULK PROGRESS');
+    const {
+      totalBatches,
+      totalContacts,
+      completedBatches,
+      completedContacts,
+    } = await this.getBulkProgress(batchGroupId);
+    // eslint-disable-next-line no-console
+    console.log('OK');
+    // eslint-disable-next-line no-console
+    console.log('UPDATE TEMP BULK PROGRESS');
+    await this.updateBulkProgress(batchGroupId, {
+      totalBatches,
+      totalContacts,
+      completedBatches: completedBatches + 1,
+      completedContacts: completedContacts + data.contacts.length,
+    });
+    // eslint-disable-next-line no-console
+    console.log('OK');
   }
 
   private async createContactsInMultiBatches(

package/src/api/contactApi.ts

@@ -173,13 +173,9 @@ export default class ContactApi extends BaseWithPoling {
    *
    * @see constructor of packages/contacts/src/Contacts
    */
-  async bulkCreateContacts(
-    data: CreateMultipleContactsDto,
-    options: {bulkSize?: number;} = {}
-  ): Promise<void> {
-    const { bulkSize = REQUEST_PAYLOAD_MAX_BYTES } = options;
+  async bulkCreateContacts(data: CreateMultipleContactsDto): Promise<void> {
     const { contacts, ...rest } = data;
-    const contactsMaxSize = bulkSize - getObjectSizeInBytes({ ...rest });
+    const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - getObjectSizeInBytes({ ...rest });
     const contactsChunks = chunkArrByMaxSize(contacts, contactsMaxSize);
 
     contactsChunks.length === 1
@@ -194,13 +190,9 @@ export default class ContactApi extends BaseWithPoling {
    *
    * @see batchProcessApi.trackBatchProcess
    */
-  async initCreateBatch(
-    data: CreateMultipleContactsDto,
-    options: {bulkSize?: number;} = {}
-  ): Promise<InitCreateBatchResponse> {
-    const { bulkSize = REQUEST_PAYLOAD_MAX_BYTES } = options;
+  async initCreateBatch(data: CreateMultipleContactsDto): Promise<InitCreateBatchResponse> {
     const { contacts, ...rest } = data;
-    const contactsMaxSize = bulkSize - getObjectSizeInBytes({ ...rest });
+    const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - 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 = 4000000;
+export const REQUEST_PAYLOAD_MAX_BYTES = 150000;
 
 export const FAILED_REQUEST_REPEATS = 3;
 

package/src/types.ts

@@ -81,6 +81,3 @@ 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>;};
-