@or-sdk/contacts 3.5.5 → 3.5.6

package/src/api/batchProcessApi.ts

@@ -1,7 +1,10 @@
 import { TrackBatchProcessResponse } from '../types';
 import { BaseApi } from './baseApi';
 
-import { BatchProcessResponseDto, BatchProcessStatus } from '@onereach/types-contacts-api';
+import {
+  BatchProcessResponseDto,
+  BatchProcessStatus,
+} from '@onereach/types-contacts-api';
 
 export default class BatchProcessApi extends BaseApi {
   private readonly apiBasePath = 'batch-process';
@@ -43,4 +46,25 @@ export default class BatchProcessApi extends BaseApi {
     return result;
   }
 
+  async getBatchProcessesGroup(groupId: string): Promise<BatchProcessResponseDto[]> {
+    return this.apiCall({
+      method: 'GET',
+      route: `${this.apiBasePath}/group/${groupId}`,
+    });
+  }
+
+  async indicesOn(): Promise<void> {
+    return this.apiCall({
+      method: 'POST',
+      route: `${this.apiBasePath}/indices-on`,
+    });
+  }
+
+  async indicesOff(): Promise<void> {
+    return this.apiCall({
+      method: 'POST',
+      route: `${this.apiBasePath}/indices-off`,
+    });
+  }
+
 }

package/src/api/bulkContactsCreateApi.ts

@@ -0,0 +1,167 @@
+import { CalApiParams } from '@or-sdk/base';
+import BaseWithPoling from './baseWithPolingApi';
+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';
+
+export default class BulkContactsCreateApi extends BaseWithPoling {
+  constructor(
+    protected readonly apiCall: <T>(params: CalApiParams) => Promise<T>,
+    protected batchProcessApi: BatchProcessApi,
+  ) {
+    super(apiCall, batchProcessApi);
+  }
+
+  private readonly apiBasePath = 'bulk-create';
+
+  /**
+   * Inserts multiple contacts into DB.
+   * Returns the following structure:
+   *
+   * ```
+   * {
+   *   created: {
+   *      contactKey(1): insertedContactId(1),
+   *      ...
+   *      contactKey(n): insertedContactId(n),
+   *   },
+   *   failed: {
+   *      contactKey(m): failure description(m)
+   *      ...
+   *      contactKey(m): failure description(l)
+   *   }
+   * }
+   * ```
+   *
+   * So this method always succeeds even if it fails to insert all passed contacts - in this case
+   * the `created` property is going to be an empty object.
+   * contactKey here is going to be a string uniquely (in the scope of passed contacts) identifying
+   * the appropriated contact.
+   * 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
+  ): Promise<CreateBulkResults> {
+    const dataWithContactKeys = this.updateContactsWithContactKeys(data);
+
+    await this.batchProcessApi.indicesOff();
+    let results: CreateBulkResults = {
+      created: {},
+      failed: {},
+    };
+    try {
+      const { contacts, ...rest } = dataWithContactKeys;
+      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);
+      } else {
+        await this.createContactsInMultiBatches(contactsChunks as BulkContactDto[][], rest, batchGroupId);
+      }
+
+      results = await this.getBulkCreateResults(batchGroupId);
+    } finally {
+      await this.batchProcessApi.indicesOn();
+    }
+
+    return results;
+  }
+
+  private updateContactsWithContactKeys(data: BulkCreateData): BatchBulkCreateData {
+    const dataWithContactKeys = {
+      ...data,
+      contacts: data.contacts.map((c, idx) => {
+        if (c.contactKey !== undefined) {
+          return c;
+        }
+        return {
+          ...c,
+          contactKey: `${idx}`,
+        };
+      }) as BulkContactDto[],
+    };
+
+    this.checkContactKeysDuplications(dataWithContactKeys.contacts);
+
+    return dataWithContactKeys;
+  }
+
+  private checkContactKeysDuplications(contacts: BulkContactDto[]): void {
+    contacts.map(({ contactKey }) => contactKey).forEach((key, index, array) => {
+      if (index !== array.lastIndexOf(key)) {
+        throw new Error(`The ${key} contactKey is assigned to more than 1 contact...`);
+      }
+    });
+  }
+
+  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: {},
+    });
+  }
+
+  private async createContactsInSingleBatch(
+    data: BatchBulkCreateData,
+    batchGroupId: string
+  ): Promise<void> {
+    const batchId = v4();
+    this.apiCall({
+      method: 'POST',
+      route: `${this.apiBasePath}/bulk`,
+      data: {
+        ...data,
+        batchId,
+        batchGroupId,
+      },
+    });
+    // giving time to 2 lambdas to wake up (1 - create Batch and 2 - ping batch status)
+    await debouncePromise(() => this.polling(batchId), 3000);
+  }
+
+  private async createContactsInMultiBatches(
+    contactsChunks: BulkContactDto[][],
+    data: Omit<BulkCreateData, 'contacts'>,
+    batchGroupId: string,
+  ): Promise<void> {
+    const batchPromises = contactsChunks
+      .map((chunkContacts) => async () => this.createContactsInSingleBatch({
+        contacts: chunkContacts,
+        ...data,
+      }, batchGroupId));
+
+    const promisesBatchSize = 4;
+
+    for (let i = 0;i < batchPromises.length;i += promisesBatchSize) {
+      const batch = batchPromises.slice(i, i + promisesBatchSize);
+      await Promise.all(batch.map((p) => p()));
+    }
+  }
+
+}

package/src/api/contactApi.ts

@@ -2,7 +2,6 @@ import { v4 } from 'uuid';
 
 import {
   BatchProcessResponseDto,
-  BatchProcessStatus,
   ContactParamsDto,
   ContactRequestDto,
   ContactResponseDto,
@@ -19,22 +18,22 @@ import {
   UpdateContactDto,
 } from '@onereach/types-contacts-api';
 import { CalApiParams, List } from '@or-sdk/base';
-import { BaseApi } from './baseApi';
 import BatchProcessApi from './batchProcessApi';
 import { getObjectSizeInBytes, chunkArrByMaxSize, debouncePromise } from '../utils';
 import { InitCreateBatchResponse, CreateContactsBatchResults } from '../types';
 import ContactBookApi from './contactBookApi';
-import { REQUEST_PAYLOAD_MAX_BYTES, FAILED_REQUEST_REPEATS, CONTACTS_DELETE_MAX_AMOUNT } from '../constants';
+import { REQUEST_PAYLOAD_MAX_BYTES, CONTACTS_DELETE_MAX_AMOUNT } from '../constants';
 import { ApiError, CreateContactsBatchError } from '../apiError';
 import { DeleteContactsData } from '../types';
+import BaseWithPoling from './baseWithPolingApi';
 
-export default class ContactApi extends BaseApi {
+export default class ContactApi extends BaseWithPoling {
   constructor(
     protected readonly apiCall: <T>(params: CalApiParams) => Promise<T>,
-    private batchProcessApi: BatchProcessApi,
+    protected batchProcessApi: BatchProcessApi,
     private bookServiceApi: ContactBookApi
   ) {
-    super(apiCall);
+    super(apiCall, batchProcessApi);
   }
 
   private readonly apiBasePath = 'contact';
@@ -368,38 +367,4 @@ export default class ContactApi extends BaseApi {
     };
   }
 
-  /**
-   * Pols specific batch process until status of it isn't turned from 'pending to something else.
-   */
-  private async polling(batchId: string, repeats = 0): Promise<BatchProcessResponseDto> {
-    let batchProcess: BatchProcessResponseDto;
-
-    try {
-      batchProcess = await debouncePromise(() => this.batchProcessApi.getBatchProcess(batchId), 1000);
-    } catch (e) {
-      if (
-        repeats < FAILED_REQUEST_REPEATS
-        && 'statusCode' in (e as object)
-        && (e as unknown as ApiError).statusCode === 410
-      ) {
-        return await debouncePromise(() => this.polling(batchId, repeats + 1), 2000);
-      }
-      if (repeats < FAILED_REQUEST_REPEATS) {
-        return this.polling(batchId, repeats + 1);
-      }
-      throw new CreateContactsBatchError((e as unknown as Error).message, batchId);
-    }
-
-    if (batchProcess.status === BatchProcessStatus.failed) {
-      throw new CreateContactsBatchError(
-        'Could not complete batch process',
-        batchId,
-        batchProcess.messages
-      );
-    }
-
-    return batchProcess.status === BatchProcessStatus.pending
-      ? this.polling(batchId)
-      : batchProcess;
-  }
 }

package/src/types.ts

@@ -1,6 +1,8 @@
 import { Token } from '@or-sdk/base';
 import {
   BatchProcessStatus,
+  BulkContactDto,
+  BulkCreateRequestDto,
   ContactBookParamsDto,
   CreateFieldSchemaDto,
   DeleteContactMultiParamsDto,
@@ -39,6 +41,12 @@ export type ContactsConfig = {
    * make many requests, for example for bulk operations.
    */
   withKeepAliveAgents?: boolean;
+
+  /**
+   * If true, the API error details like request url, params and body,
+   * will be outputted to console
+   */
+  withApiErrorLog?: boolean;
 };
 
 export interface ContactBookParams extends AdaptedListParams<ContactBookParamsDto> {
@@ -68,3 +76,11 @@ export type TrackBatchProcessResponse = {
 };
 
 export type CreateFieldSchemaParams = CreateFieldSchemaDto & {presetIds?: string[];};
+
+export type BulkCreateData = Omit<BulkCreateRequestDto, 'batchId' | 'batchGroupId' | 'contacts'>
+& { contacts: OptionalBy<BulkContactDto, 'contactKey'>[]; };
+
+export type BatchBulkCreateData = Omit<BulkCreateRequestDto, 'batchId' | 'batchGroupId'>;
+
+export type CreateBulkResults = {created: Record<string, string>; failed: Record<string, string>;};
+