@or-sdk/contacts 3.2.2-beta.1762.0 → 3.2.2-beta.1768.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.2-beta.1762.0",
+  "version": "3.2.2-beta.1768.0",
   "name": "@or-sdk/contacts",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -24,7 +24,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@onereach/types-contacts-api": "4.7.2-beta.2230.0",
+    "@onereach/types-contacts-api": "4.7.2-beta.2237.0",
     "@or-sdk/base": "^0.28.3"
   }
 }

package/src/Contacts.ts

@@ -52,7 +52,7 @@ export class Contacts extends Base {
     this.batchProcessApi = new BatchProcessApi(apiCall);
     this.contactBookApi = new ContactBookApi(apiCall);
     this.migrationsApi = new MigrationsApi(apiCall);
-    this.contactApi = new ContactApi(apiCall, this.batchProcessApi);
+    this.contactApi = new ContactApi(apiCall, this.batchProcessApi, this.contactBookApi);
     this.fieldSchemaApi = new FieldSchemaApi(apiCall);
     this.schemaPresetApi = new SchemaPresetApi(apiCall);
     this.filterApi = new FilterApi(apiCall);

package/src/api/batchProcessApi.ts

@@ -1,7 +1,8 @@
-import { TrackBatchProcessResponse } from '../types';
 import { BaseApi } from './baseApi';
 
-import { BatchProcessResponseDto, BatchProcessStatus, PendingBatchesResponseDto } from '@onereach/types-contacts-api';
+import {
+  BatchProcessResponseDto,
+} from '@onereach/types-contacts-api';
 
 export default class BatchProcessApi extends BaseApi {
   private readonly apiBasePath = 'batch-process';
@@ -12,43 +13,4 @@ export default class BatchProcessApi extends BaseApi {
       route: `${this.apiBasePath}/${id}`,
     });
   }
-
-  /**
-   * Returns the count of pending batch processes and their ids.
-   */
-  getPendingBatchProcesses(): Promise<PendingBatchesResponseDto> {
-    return this.apiCall({
-      method: 'GET',
-      route: `${this.apiBasePath}/pending-batches`,
-    });
-  }
-
-  /**
-   * Provides information about create contacts batch process: its status, errors if
-   * the status is failed, and created contacts ids if the status is success.
-   */
-  async trackBatchProcess(id: string): Promise<TrackBatchProcessResponse> {
-    const batchProcess = await this.getBatchProcess(id);
-
-    let result: TrackBatchProcessResponse = {
-      status: batchProcess.status,
-    };
-
-    if (batchProcess.status === BatchProcessStatus.success) {
-      result = {
-        ...result,
-        contactsIds: batchProcess.results.flatMap<string>(i => JSON.parse(i)),
-      };
-    }
-
-    if (batchProcess.status === BatchProcessStatus.failed) {
-      result = {
-        ...result,
-        errors: batchProcess.messages,
-      };
-    }
-
-    return result;
-  }
-
 }

package/src/api/contactApi.ts

@@ -1,6 +1,5 @@
 import {
   BatchProcessResponseDto,
-  BatchProcessStatus,
   ContactParamsDto,
   ContactRequestDto,
   ContactResponseDto,
@@ -19,15 +18,17 @@ import {
 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 { getObjectSizeInBytes, chunkArrByMaxSize } from '../utils';
 import { REQUEST_PAYLOAD_MAX_BYTES, FAILED_REQUEST_REPEATS, CONTACTS_DELETE_MAX_AMOUNT } from '../constants';
-import { CreateContactsBatchError } from '../apiError';
+import { ApiError } from '../apiError';
+import { DeleteContactsData } from '../types';
 
 export default class ContactApi extends BaseApi {
   constructor(
     protected readonly apiCall: <T>(params: CalApiParams) => Promise<T>,
-    private batchProcessApi: BatchProcessApi
+    private batchProcessApi: BatchProcessApi,
+    private bookServiceApi: ContactBookApi
   ) {
     super(apiCall);
   }
@@ -90,8 +91,8 @@ export default class ContactApi extends BaseApi {
    * @description Delete Contact
    * @param data
    */
-  deleteMulti(data: DeleteContactMultiParamsDto): Promise<void> {
-    if ((Array.isArray(data.ids) && data.ids.length > CONTACTS_DELETE_MAX_AMOUNT) || data.all) {
+  deleteMulti(data: DeleteContactsData): Promise<void> {
+    if ((Array.isArray(data.ids) && data.ids.length >= CONTACTS_DELETE_MAX_AMOUNT) || data.all) {
       return this.bulkDeleteContacts(data);
     }
     return this.apiCall({
@@ -101,6 +102,35 @@ export default class ContactApi extends BaseApi {
     });
   }
 
+  /**
+   * @description Delete all contacts from a book
+   */
+  async deleteContactsByBook(bookId: string): Promise<void> {
+    const contacts = await this.listContact({ contact_book: bookId });
+    return this.bulkDeleteContacts({
+      ids: contacts.items.map(({ id }) => id),
+      contact_book: bookId,
+    });
+  }
+
+  async initDeleteBookContactsBulk(bookId: string) {
+    const { contactsCount } = await this.bookServiceApi.getContactBook(bookId);
+    const contacts = await this.listContact({
+      contact_book: bookId,
+      size: CONTACTS_DELETE_MAX_AMOUNT,
+    });
+
+    const batchProcess = await this.runSingleDeleteContactsBulk({
+      ids: contacts.items.map(({ id }) => id),
+      contact_book: bookId,
+    });
+
+    return {
+      batchId: batchProcess.id,
+      totalBatches: Math.floor(contactsCount / 50),
+    };
+  }
+
   /**
    * @description Create Contact
    * @param data
@@ -115,61 +145,18 @@ export default class ContactApi extends BaseApi {
 
   /**
    * @description Create Contacts either in single or in multi batch(es), depending on payload size
+   * @param data
    */
-  async bulkCreateContacts(data: CreateMultipleContactsDto): Promise<string[]> {
-    // eslint-disable-next-line no-console
-    console.log('contacts: ', data.contacts.length);
-    const { contacts, ...rest } = data;
-    const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - getObjectSizeInBytes({ ...rest });
-    const contactsChunks = chunkArrByMaxSize(contacts, contactsMaxSize);
-
-    contactsChunks.forEach((chunk, idx) => {
-      // eslint-disable-next-line no-console
-      console.log('size of ', idx, ' chunk', ' is ', getObjectSizeInBytes(chunk));
-    });
-    // eslint-disable-next-line no-console
-    console.log('chunks: ', contactsChunks.length);
-    const results = contactsChunks.length === 1
-      ? [await this.createContactsInSingleBatch(data)]
-      : await this.createContactsInMultiBatches(contactsChunks, rest);
-
-    return results.reduce<string[]>((acc, { contactsIds }) => ([...acc, ...contactsIds]), []);
-  }
-
-  /**
-   * Breaks the contacts to chunks of maximum allowed size (200 KB) and launches create batch
-   * only for the first chunk.
-   * Returns batch id in response by which the batch can be tracked using batch process API.
-   * Note: since create contact batch is a very expensive operations from terms of consuming
-   * DB connections, it is highly recommended to check amount of pending (running) batches
-   * prior to this method execution, and if the amount is greater of 2 the batch initiation
-   * should be deferred.
-   *
-   * @see batchProcessApi.trackBatchProcess
-   * @see batchProcessApi.getPendingBatchProcesses
-   */
-  async initCreateBatch(data: CreateMultipleContactsDto): Promise<InitCreateBatchResponse> {
+  async bulkCreateContacts(data: CreateMultipleContactsDto): Promise<ContactResponseDto[]> {
     const { contacts, ...rest } = data;
     const contactsMaxSize = REQUEST_PAYLOAD_MAX_BYTES - getObjectSizeInBytes({ ...rest });
     const contactsChunks = chunkArrByMaxSize(contacts, contactsMaxSize);
 
-    const batchProcess = await this.apiCall<BatchProcessResponseDto>({
-      method: 'POST',
-      route: `${this.apiBasePath}/bulk`,
-      data: {
-        contacts: contactsChunks[0],
-        ...rest,
-      },
-    });
-
-    return {
-      totalChunks: contactsChunks.length,
-      firstChunkSize: contactsChunks[0].length,
-      batchId: batchProcess.id,
-    };
+    return contactsChunks.length === 1
+      ? this.createContactsInSingleBatch(data)
+      : this.createContactsInMultiBatches(contactsChunks, rest);
   }
 
-
   /**
    * @description Merge two Contacts into one
    * @param id Contact id TO which the data will be merged
@@ -233,99 +220,102 @@ export default class ContactApi extends BaseApi {
     });
   }
 
-  private async bulkDeleteContacts(data: DeleteContactMultiParamsDto): Promise<void> {
-    const batchProcess = await this.apiCall<BatchProcessResponseDto>({
-      method: 'DELETE',
-      route: `${this.apiBasePath}/bulk`,
-      data,
+  private async getSafelyContactsList(
+    contactIds: string[],
+    bookId: string | undefined,
+    repeats?: number
+  ): Promise<List<ContactResponseDto>> {
+    const contacts = await this.listContact({
+      contactIds,
+      ...(bookId && { contact_book: bookId }),
+    }).catch((e) => {
+      repeats = repeats || 0;
+      if (repeats < FAILED_REQUEST_REPEATS) {
+        return this.getSafelyContactsList(contactIds, bookId, repeats + 1);
+      }
+      throw new Error(e);
     });
-    await this.polling(batchProcess.id);
+    return contacts;
   }
 
-  private async createContactsInMultiBatches(
-    contactsChunks: ContactRequestDto[][],
-    data: Omit<CreateMultipleContactsDto, 'contacts'>
-  ): Promise<CreateContactsBatchResults[]> {
-    const batchPromises = contactsChunks
-      .map((chunkContacts) => async () => this.createContactsInSingleBatch({
-        contacts: chunkContacts,
-        ...data,
-      }));
-
-    const promisesBatchSize = 2;
-    const results: CreateContactsBatchResults[] = [];
-
-    for (let i = 0;i < batchPromises.length;i += promisesBatchSize) {
-      const s = performance.now();
-      try {
-        const chunk = batchPromises.slice(i, i + promisesBatchSize);
-        const chunkResults = await Promise.all(chunk.map((p) => p()));
-        results.push(...chunkResults);
-      } catch (e) {
-        if (e instanceof CreateContactsBatchError) {
-          e.processedBatchIds = results.map(({ batchId }) => batchId);
-        }
-        throw e;
+  private async bulkDeleteContacts(data: DeleteContactsData): Promise<void> {
+    const { ids, contact_book, all } = data;
+    if (all) {
+      if (!contact_book) {
+        throw new ApiError(400, 'contact_book should be provided in case if "all" is true');
       }
-
-      const e = performance.now();
-      // eslint-disable-next-line no-console
-      console.log('awaiting ', promisesBatchSize, ' batches: ', (e - s) / 1000, 's');
+      return await this.deleteContactsByBook(contact_book);
+    }
+    if (!ids) {
+      throw new ApiError(400, 'Provide either "contact_book" or "all"');
     }
+    const batchSize = CONTACTS_DELETE_MAX_AMOUNT;
+    for (let i = 0;i < ids.length;i += batchSize) {
+      const chunk = ids.slice(i, i + batchSize);
+      await this.runSingleDeleteContactsBulk({
+        ids: chunk,
+        contact_book,
+      });
+    }
+  }
 
-    return results;
+  private async runSingleDeleteContactsBulk(
+    data: DeleteContactMultiParamsDto,
+    withPoling = true
+  ): Promise<BatchProcessResponseDto> {
+    const batchProcess = await this.apiCall<BatchProcessResponseDto>({
+      method: 'DELETE',
+      route: `${this.apiBasePath}/bulk`,
+      data,
+    });
+    if (withPoling) {
+      const result = await this.polling(batchProcess.id);
+      return result;
+    }
+    return batchProcess;
   }
 
-  private async createContactsInSingleBatch(data: CreateMultipleContactsDto): Promise<CreateContactsBatchResults> {
-    const s = performance.now();
+  private async createContactsInSingleBatch(data: CreateMultipleContactsDto): Promise<ContactResponseDto[]> {
     const batchProcess = await this.apiCall<BatchProcessResponseDto>({
       method: 'POST',
       route: `${this.apiBasePath}/bulk`,
       data,
     });
     const batchProcessResult = await this.polling(batchProcess.id);
-    const e = performance.now();
-    // eslint-disable-next-line no-console
-    console.log('single batch time: ', (e - s) / 1000, 's');
-    return {
-      batchId: batchProcess.id,
-      contactsIds: batchProcessResult.results.flatMap<string>(i => JSON.parse(i)),
-    };
+    const contactIds = batchProcessResult.results.flatMap<string>(i => JSON.parse(i));
+    const importedContacts = await this.getSafelyContactsList(contactIds, data.contact_book);
+    return importedContacts.items;
+  }
+
+  private async createContactsInMultiBatches(
+    contactsChunks: ContactRequestDto[][],
+    data: Omit<CreateMultipleContactsDto, 'contacts'>
+  ): Promise<ContactResponseDto[]> {
+    const batchPromises = contactsChunks.map((chunkContacts) => async () => this.createContactsInSingleBatch({
+      contacts: chunkContacts,
+      ...data,
+    }));
+
+    const results: ContactResponseDto[] = [];
+    for (const fn of batchPromises) {
+      const singleBatchResults = await fn();
+      results.push(...singleBatchResults);
+    }
+    return results;
   }
 
   /**
    * 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);
-      // eslint-disable-next-line no-console
-      const counter = batchCounters[batchId] || 0;
-      // eslint-disable-next-line no-console
-      console.log('polling counter of ', batchId, ' = ', counter, ' | status = ', batchProcess.status);
-      batchCounters[batchId] = counter + 1;
-
-    } catch (e) {
+  private async polling(batchId: string, repeats?: number): Promise<BatchProcessResponseDto> {
+    const batchProcessState = await this.batchProcessApi.getBatchProcess(batchId).catch((e) => {
+      repeats = repeats || 0;
       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;
+      throw new Error(e);
+    });
+    // value 'pending' is used because of https://onereach.atlassian.net/browse/CU-562
+    return batchProcessState.status === 'pending' ? this.polling(batchId) : batchProcessState;
   }
 }
-
-const batchCounters: Record<string, number> = {};

package/src/apiError.ts

@@ -11,14 +11,3 @@ export class ApiError extends Error {
     super(message);
   }
 }
-
-export class CreateContactsBatchError extends Error {
-  constructor(
-    message: string,
-    public readonly failedBatchId: string,
-    public readonly batchMessages?: string[],
-    public processedBatchIds?: string[],
-  ) {
-    super(message);
-  }
-}

package/src/constants.ts

@@ -1,13 +1,7 @@
 export const CONTACTS_SERVICE_KEY = 'contacts-api';
 
-export const REQUEST_PAYLOAD_MAX_BYTES = 150000;
+export const REQUEST_PAYLOAD_MAX_BYTES = 128000;
 
 export const FAILED_REQUEST_REPEATS = 3;
 
-/**
- * 5 selected experimentally
- * Since contacts deleting assumes cascading on related field values and deleting
- * relations in contact_book_contact table, it results in huge amount of queries
- * which sent simultaneously might kill connection to the DB.
- */
-export const CONTACTS_DELETE_MAX_AMOUNT = 5;
+export const CONTACTS_DELETE_MAX_AMOUNT = 50;

package/src/types.ts

@@ -1,5 +1,5 @@
 import { Token } from '@or-sdk/base';
-import { BatchProcessStatus, ContactBookParamsDto, ListApiParams, OrderParams } from '@onereach/types-contacts-api';
+import { ContactBookParamsDto, ListApiParams, OrderParams, DeleteContactMultiParamsDto } from '@onereach/types-contacts-api';
 import { OrderOptions, PaginationOptions } from '@or-sdk/base';
 export * from '@onereach/types-contacts-api';
 
@@ -31,19 +31,4 @@ export interface ContactBookParams extends AdaptedListParams<ContactBookParamsDt
 export type AdaptedListParams<T extends ListApiParams & OrderParams> =
   Omit<T, 'order' | 'skip' | 'take'> & Partial<PaginationOptions & OrderOptions>;
 
-export type CreateContactsBatchResults ={
-  batchId: string;
-  contactsIds: string[];
-};
-
-export type InitCreateBatchResponse = {
-  totalChunks: number;
-  firstChunkSize: number;
-  batchId: string;
-};
-
-export type TrackBatchProcessResponse = {
-  status: BatchProcessStatus;
-  errors?: string[];
-  contactsIds?: string[];
-};
+export type DeleteContactsData = DeleteContactMultiParamsDto & { all?: boolean;};

package/src/utils.ts

@@ -43,19 +43,3 @@ export const chunkArrByMaxSize = <T>(arr: T[], maxSize: number): T[][] => {
     ...chunkArrByMaxSize(arr.slice(mid), maxSize),
   ];
 };
-
-export function debouncePromise<T>(
-  caller: () => Promise<T>,
-  delay: number,
-  reject?: (value: string | T | PromiseLike<T>) => void
-): Promise<T> {
-  let timeout: NodeJS.Timeout | null = null;
-
-  return new Promise<T>((res) => {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(() => caller().then((x) => res(x)).catch((err) => reject && reject(err)), delay);
-  });
-}
-