@meltwater/conversations-api-services 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltwater/conversations-api-services",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Repository to contain all conversations api services shared across our services",
   "type": "module",
   "main": "src/data-access/index.js",

package/src/data-access/http/facebookApi.client.js

@@ -107,7 +107,7 @@ export class FacebookApiClient {
         );
         logger.info(
             `Native Facebook API Publish Comment Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -147,7 +147,7 @@ export class FacebookApiClient {
         );
         logger.info(
             `Native Facebook API Publish Private Message Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -162,23 +162,21 @@ export class FacebookApiClient {
                 .query({ access_token: accessToken, ...queryParams })
                 .send(payload);
         } catch (err) {
+            let errorText = '';
             if (
                 err &&
                 err.response &&
                 err.response.body &&
                 err.response.body.error
             ) {
-                logger.error(
-                    `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`
-                );
+                errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
             } else {
-                logger.error(
-                    `Failed to call facebook api for documentId ${documentId}`,
-                    err
-                );
+                errorText = `Failed to call facebook api for documentId ${documentId}`;
+                logger.error(errorText, err);
             }
 
-            throw err;
+            throw new Error(errorText);
         }
 
         if (response.status !== 200) {
@@ -206,23 +204,21 @@ export class FacebookApiClient {
                 .query({ access_token: accessToken })
                 .send(payload);
         } catch (err) {
+            let errorText = '';
             if (
                 err &&
                 err.response &&
                 err.response.body &&
                 err.response.body.error
             ) {
-                logger.error(
-                    `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`
-                );
+                errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
             } else {
-                logger.error(
-                    `Failed to call facebook api for documentId ${documentId}`,
-                    err
-                );
+                errorText = `Failed to call facebook api for documentId ${documentId}`;
+                logger.error(errorText, err);
             }
 
-            throw err;
+            throw new Error(errorText);
         }
 
         if (response.status !== 200) {
@@ -250,23 +246,21 @@ export class FacebookApiClient {
                 .query({ access_token: accessToken })
                 .send(payload);
         } catch (err) {
+            let errorText = '';
             if (
                 err &&
                 err.response &&
                 err.response.body &&
                 err.response.body.error
             ) {
-                logger.error(
-                    `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`
-                );
+                errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
             } else {
-                logger.error(
-                    `Failed to call facebook api for documentId ${documentId}`,
-                    err
-                );
+                errorText = `Failed to call facebook api for documentId ${documentId}`;
+                logger.error(errorText, err);
             }
 
-            throw err;
+            throw new Error(errorText);
         }
 
         if (response.status !== 200) {
@@ -380,13 +374,6 @@ export class FacebookApiClient {
             );
         }
 
-        //sendNotification -> needs to wait for temp document to reach user
-        setTimeout(() => {
-            PushRepository.publish(
-                `${companyId}-${documentId}`,
-                updatedDocument
-            );
-        }, 5000);
         return apiResponse;
     }
 
@@ -458,7 +445,6 @@ export class FacebookApiClient {
         } = document;
 
         let banResponse;
-        let notificationPayload = document;
         let authorId = authors[0].authorInfo.externalId;
 
         try {
@@ -491,30 +477,9 @@ export class FacebookApiClient {
                 `finished banning in facebook for ${authorId} on company ${companyId} `,
                 { banResponse }
             );
-
-            notificationPayload.banStatus = {
-                code: banResponse.success === true ? 200 : 500,
-                message:
-                    banResponse.success === true ? 'Success' : 'Failed to Ban',
-            };
-            logger.debug(
-                `Notification payload for ${authorId} on company ${companyId} `,
-                notificationPayload
-            );
         } catch (error) {
             logger.error(`${authorId} - error recieved - ${error.code}`, error);
-            // message failed ot send, mark as such
-            notificationPayload.banStatus = {
-                code: 405,
-                message: 'Exception Occurred',
-            };
         }
-        setTimeout(() => {
-            PushRepository.publish(
-                `${companyId}-${authorId}`,
-                notificationPayload
-            );
-        }, 5000);
     }
 
     async toggleLike(document) {
@@ -579,7 +544,7 @@ export class FacebookApiClient {
 
         logger.info(
             `Native Facebook API Like Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -601,7 +566,7 @@ export class FacebookApiClient {
 
         logger.info(
             `Native Facebook API Unlike Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -624,7 +589,7 @@ export class FacebookApiClient {
 
         logger.info(
             `Native Facebook API Hide Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -647,7 +612,7 @@ export class FacebookApiClient {
 
         logger.info(
             `Native Facebook API Unhide Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -683,7 +648,7 @@ export class FacebookApiClient {
         }
         logger.info(
             `Native Facebook API is User Banned Response was invalid for userId ${userId} ${credentialId}`,
-            { responseBody: response }
+            { status: response.status, ok: response.ok }
         );
         return false;
     }
@@ -706,7 +671,7 @@ export class FacebookApiClient {
 
         logger.info(
             `Native Facebook API Hide Response for externalAuthorId ${authorId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -729,7 +694,7 @@ export class FacebookApiClient {
 
         logger.info(
             `Native Facebook API Unban Response for externalAuthorId ${authorId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }

package/src/data-access/http/instagramApi.client.js

@@ -3,9 +3,6 @@ import logger from '../../lib/logger.js';
 import { removePrefix } from '../../lib/externalId.helpers.js';
 import assert from 'assert';
 import { CredentialsApiClient } from '../http/credentialsApi.client.js';
-// import { messagesRepository } from '@data-access/mongo/repository/messages.js';
-// import PushRepository from '@data-access/redis/repository/push.repository.js';
-// import { DOCUMENT_STATUS } from '@data-access/mongo/query.helpers.js';
 
 const INSTAGRAM_URL = 'https://graph.facebook.com';
 export class InstagramApiClient {
@@ -47,22 +44,22 @@ export class InstagramApiClient {
                 .query(queryStringArgs)
                 .send(data);
         } catch (err) {
+            let errorText = '';
             if (
                 err &&
                 err.response &&
                 err.response.body &&
                 err.response.body.error
             ) {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`
-                );
+                errorText =
+                    'Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}';
+                logger.error(errorText);
             } else {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}`,
-                    err
-                );
+                errorText =
+                    'Failed to call instagram api for documentId ${documentId}';
+                logger.error(errorText, err);
             }
-            throw err;
+            throw new Error(errorText);
         }
 
         if (response.status !== 200) {
@@ -100,7 +97,7 @@ export class InstagramApiClient {
 
             logger.info(
                 `Native Instagram API getPost Response for documentId ${documentId}`,
-                { responseBody: response.body }
+                { status: response.status, ok: response.ok }
             );
             return response.body;
         } catch (err) {
@@ -127,22 +124,20 @@ export class InstagramApiClient {
                 .query({ message: text })
                 .send();
         } catch (err) {
+            let errorText = '';
             if (
                 err &&
                 err.response &&
                 err.response.body &&
                 err.response.body.error
             ) {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`
-                );
+                errorText = `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
             } else {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}`,
-                    err
-                );
+                errorText = `Failed to call instagram api for documentId ${documentId}`;
+                logger.error(errorText, err);
             }
-            throw err;
+            throw new Error(errorText);
         }
 
         if (response.status !== 200) {
@@ -173,18 +168,15 @@ export class InstagramApiClient {
                 .query({ hide: hideStatus })
                 .send();
         } catch (err) {
+            let errorText = '';
             if (err && err.response && err.response.body) {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}`,
-                    err.response.body.error
-                );
+                errorText = `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText, err.response.body.error);
             } else {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}`,
-                    err
-                );
+                errorText = `Failed to call instagram api for documentId ${documentId}`;
+                logger.error(errorText, err);
             }
-            throw err;
+            throw new Error(errorText);
         }
 
         if (response.status !== 200) {
@@ -215,18 +207,15 @@ export class InstagramApiClient {
                 .query({ fields: fields })
                 .send();
         } catch (err) {
+            let errorText = '';
             if (err && err.response && err.response.body) {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}`,
-                    err.response.body.error
-                );
+                errorText = `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText, err.response.body.error);
             } else {
-                logger.error(
-                    `Failed to call instagram api for documentId ${documentId}`,
-                    err
-                );
+                errorText = `Failed to call instagram api for documentId ${documentId}`;
+                logger.error(errorText, err);
             }
-            throw err;
+            throw new Error(errorText);
         }
 
         if (response.status !== 200) {
@@ -278,7 +267,7 @@ export class InstagramApiClient {
 
         logger.info(
             `Native Intagram API Publish Comment Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -327,7 +316,7 @@ export class InstagramApiClient {
 
         logger.info(
             `Native Instagram API Publish Reply Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -413,51 +402,10 @@ export class InstagramApiClient {
                 default:
                     throw new Error('Unsupported discussion type');
             }
-
-            if (apiResponse) {
-                let findQuery = { documentId };
-                findQuery['systemData.policies.storage.privateTo'] = companyId;
-                let updateObj = {};
-                updateObj['systemData.status'] = DOCUMENT_STATUS.SUCCESS;
-                // update with the new id from instagram reply/comment or direct message
-                updateObj['metaData.externalId'] =
-                    apiResponse.id || `${apiResponse.message_id}`;
-                updateObj.documentId = Buffer.from(
-                    `${updateObj['metaData.externalId']}`
-                ).toString('base64');
-                updatedDocument = await messagesRepository.updateOne(
-                    findQuery,
-                    updateObj
-                );
-            } else {
-                throw new Error(
-                    'Invalid response from instagram publish endpoints'
-                );
-            }
         } catch (err) {
             logger.error(documentId + ' - exception details ' + err, err);
-            let findQuery = { documentId };
-            findQuery['systemData.policies.storage.privateTo'] = companyId;
-
-            let updateQuery = {};
-            updateQuery['systemData.status'] = DOCUMENT_STATUS.FAILED;
-            updateQuery['systemData.error'] =
-                err && err.response && err.response.error
-                    ? err.response.error
-                    : err;
-            updatedDocument = await messagesRepository.updateOne(
-                findQuery,
-                updateQuery
-            );
         }
 
-        //sendNotification -> needs to wait for temp document to reach user
-        setTimeout(() => {
-            PushRepository.publish(
-                `${companyId}-${documentId}`,
-                updatedDocument
-            );
-        }, 5000);
         return apiResponse;
     }
 
@@ -479,7 +427,7 @@ export class InstagramApiClient {
 
         logger.info(
             `Native Instagram API Hide Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -502,7 +450,7 @@ export class InstagramApiClient {
 
         logger.info(
             `Native Instagram API Unhide Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }
@@ -541,7 +489,7 @@ export class InstagramApiClient {
 
         logger.info(
             `Native Instagram API Publish Private Message Response for documentId ${documentId}`,
-            { responseBody: response.body }
+            { status: response.status, ok: response.ok }
         );
         return response.body;
     }

package/src/data-access/http/linkedInApi.client.js

@@ -1,13 +1,10 @@
 import superagent from 'superagent';
 import configuration from '../../lib/configuration.js';
-// import { DOCUMENT_STATUS } from '@data-access/mongo/query.helpers.js';
-// import { messagesRepository } from '@data-access/mongo/repository/messages.js';
-// import PushRepositoryfrom from '@data-access/redis/repository/push.repository.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
 
 export class LinkedInApiClient {
-    constructor({ services }) {
-        this.tokenService = services.token;
-        this.logger = services.logger;
+    constructor() {
+        this.credentialsAPI = new CredentialsApiClient();
     }
 
     async likeMessage(document) {
@@ -43,12 +40,12 @@ export class LinkedInApiClient {
               )}?actor=${fixedEncodeURIComponent(payload.actor)}`;
 
         try {
-            let credential = await this.tokenService.getByCredentialId(
+            let credential = await this.credentialsAPI.getToken(
                 credentialId,
                 companyId
             );
             if (!likedByUser) {
-                this.logger.debug(`${documentId} - trying Delete `, {
+                logger.debug(`${documentId} - trying Delete `, {
                     query,
                     payload,
                 });
@@ -63,7 +60,7 @@ export class LinkedInApiClient {
                         'LinkedIn-Version': '202305',
                     });
             } else {
-                this.logger.debug(`${documentId} - sending to linkedin `, {
+                logger.debug(`${documentId} - sending to linkedin `, {
                     query,
                     payload,
                 });
@@ -80,7 +77,7 @@ export class LinkedInApiClient {
                     .send(payload);
             }
 
-            this.logger.info(
+            logger.info(
                 `Native Linkedin API Like Comment Response for documentId ${documentId}`,
                 {
                     ok: response.ok,
@@ -90,7 +87,7 @@ export class LinkedInApiClient {
                 }
             );
         } catch (err) {
-            this.logger.error(documentId + ' - exception details', {
+            logger.error(documentId + ' - exception details', {
                 err,
             });
             throw err;
@@ -125,12 +122,12 @@ export class LinkedInApiClient {
         )}/comments/${commentId}?actor=${fixedEncodeURIComponent(actorURN)}`;
 
         try {
-            let credential = await this.tokenService.getByCredentialId(
+            let credential = await this.credentialsAPI.getToken(
                 credentialId,
                 companyId
             );
 
-            this.logger.debug(`${documentId} - trying Delete `, {
+            logger.debug(`${documentId} - trying Delete `, {
                 query,
             });
             response = await superagent
@@ -144,23 +141,22 @@ export class LinkedInApiClient {
                     'LinkedIn-Version': '202305',
                 });
 
-            this.logger.info(
+            logger.info(
                 `Native Linkedin API Delete Comment Response for documentId ${documentId}`,
                 { status: response.status, ok: response.ok }
             );
         } catch (err) {
+            let errorText = '';
             if (err && err.response && err.response.text) {
-                this.logger.error(
-                    `Call to linkedin api with documentId ${documentId} failed`,
-                    { message: JSON.parse(err.response.text) }
-                );
+                errorText = `Call to linkedin api with documentId ${documentId} failed`;
+                logger.error(errorText, {
+                    message: JSON.parse(err.response.text),
+                });
             } else {
-                this.logger.error(
-                    `Call to linkedin api with documentId ${documentId} failed`,
-                    err
-                );
+                errorText = `Call to linkedin api with documentId ${documentId} failed`;
+                logger.error(errorText, err);
             }
-            throw err;
+            throw new Error(errorText);
         }
         return response;
     }
@@ -222,7 +218,7 @@ export class LinkedInApiClient {
         // data-listener -> linkedin_api.client sendComment
         let response, updatedDocument;
         try {
-            let credential = await this.tokenService.getByCredentialId(
+            let credential = await this.credentialsAPI.getToken(
                 credentialId,
                 companyId
             );
@@ -244,52 +240,13 @@ export class LinkedInApiClient {
                 status: 200,
                 message: JSON.parse(response.text),
             };
-
-            //markMessageAsSuccess
-            let findQuery = { documentId };
-            findQuery['systemData.policies.storage.privateTo'] = companyId;
-            let updateQuery = {};
-            const { $URN: externalId, actor } = response.message;
-
-            updateQuery['systemData.status'] = DOCUMENT_STATUS.SUCCESS;
-            updateQuery['authors[0].authorInfo.externalId'] = actor;
-            updateQuery['metaData.externalId'] = externalId;
-            updateQuery.documentId = Buffer.from(`${externalId}`).toString(
-                'base64'
-            );
-
-            updatedDocument = await messagesRepository.updateOne(
-                findQuery,
-                updateQuery
-            );
         } catch (err) {
-            this.logger.error(
+            logger.error(
                 documentId + ' - exception linkedin publish ' + err,
                 err
             );
-
-            let findQuery = { documentId };
-            findQuery['systemData.policies.storage.privateTo'] = companyId;
-            let updateQuery = {};
-            updateQuery['systemData.status'] = DOCUMENT_STATUS.FAILED;
-            updateQuery['systemData.error'] =
-                err && err.response && err.response.error
-                    ? err.response.error
-                    : err;
-            updatedDocument = await messagesRepository.updateOne(
-                findQuery,
-                updateQuery
-            );
         }
 
-        //sendNotification -> needs to wait for temp document to reach user
-        setTimeout(() => {
-            PushRepository.publish(
-                `${companyId}-${documentId}`,
-                updatedDocument
-            );
-        }, 5000);
-
         return response;
     }
 
@@ -310,7 +267,7 @@ export class LinkedInApiClient {
 
         let response;
         try {
-            let credential = await this.tokenService.getByCredentialId(
+            let credential = await this.credentialsAPI.getToken(
                 credentialId,
                 companyId
             );
@@ -334,7 +291,7 @@ export class LinkedInApiClient {
             };
             return response;
         } catch (err) {
-            this.logger.error(
+            logger.error(
                 documentId + ' - exception linkedin media register ' + err,
                 err
             );
@@ -362,16 +319,14 @@ export class LinkedInApiClient {
                 })
                 .then((result) => result.body);
         } catch (error) {
-            this.logger.error(
+            logger.error(
                 `Failed requesting LinkedIn API for profileId ${urn}`,
                 error
             );
             return;
         }
 
-        this.logger.info(
-            `Finished requesting LinkedIn API for profileId ${urn}`
-        );
+        logger.info(`Finished requesting LinkedIn API for profileId ${urn}`);
 
         return profile;
     }
@@ -397,13 +352,13 @@ export class LinkedInApiClient {
                 })
                 .then((result) => result.body);
         } catch (error) {
-            this.logger.error(
+            logger.error(
                 `Failed requesting LinkedIn API for organizationId ${urn}`,
                 error
             );
         }
 
-        this.logger.info(
+        logger.info(
             `Finished requesting LinkedIn API for organizationId ${urn}`
         );
 
@@ -429,14 +384,14 @@ export class LinkedInApiClient {
                     'LinkedIn-Version': '202305',
                 });
         } catch (error) {
-            this.logger.error('Error in getAllStats ' + error, error);
+            logger.error('Error in getAllStats ' + error, error);
         }
 
         let { commentSummary, reactionSummaries } = response.body || {};
         if (commentSummary && reactionSummaries) {
             return { commentSummary, reactionSummaries };
         } else {
-            this.logger.error(
+            logger.error(
                 `Invalid response getting all Linkedin Stats for externalId = ${externalId} ` +
                     response,
                 response
@@ -457,14 +412,14 @@ export class LinkedInApiClient {
                 reactionSummaries,
             };
         } catch (error) {
-            this.logger.error('Error in getSocialStats: ' + error, error);
+            logger.error('Error in getSocialStats: ' + error, error);
         }
     }
 
     async getImageMedia(mediaId, credentialId, companyId) {
         let response = {};
 
-        let credential = await this.tokenService.getByCredentialId(
+        let credential = await this.credentialsAPI.getToken(
             credentialId,
             companyId
         );
@@ -492,14 +447,14 @@ export class LinkedInApiClient {
                     'LinkedIn-Version': '202305',
                 });
         } catch (error) {
-            this.logger.error('Error in getImageMedia ' + error, error);
+            logger.error('Error in getImageMedia ' + error, error);
         }
 
         let { downloadUrl } = response.body || {};
         if (downloadUrl) {
             return { downloadUrl };
         } else {
-            this.logger.error(
+            logger.error(
                 `Invalid response getting Linkedin media for mediaId = ${mediaId} ` +
                     response,
                 response
@@ -512,7 +467,7 @@ export class LinkedInApiClient {
         let response = {};
         let tempValue;
 
-        let credential = await this.tokenService.getByCredentialId(
+        let credential = await this.credentialsAPI.getToken(
             credentialId,
             companyId
         );
@@ -548,14 +503,14 @@ export class LinkedInApiClient {
                     'LinkedIn-Version': '202305',
                 });
         } catch (error) {
-            this.logger.error('Error in getVideoMedia ' + error, error);
+            logger.error('Error in getVideoMedia ' + error, error);
         }
 
         let { thumbnail, downloadUrl } = response.body || {};
         if (downloadUrl) {
             return { thumbnail, downloadUrl };
         } else {
-            this.logger.error(
+            logger.error(
                 `Invalid response getting Linkedin media for mediaId = ${mediaId} ` +
                     response,
                 response
@@ -596,7 +551,7 @@ export class LinkedInApiClient {
 
             return {};
         } catch (error) {
-            this.logger.error('Error in getMedia: ' + error, error);
+            logger.error('Error in getMedia: ' + error, error);
         }
     }
 
@@ -608,7 +563,7 @@ export class LinkedInApiClient {
     ) {
         let result;
         try {
-            let credential = await this.tokenService.getByCredentialId(
+            let credential = await this.credentialsAPI.getToken(
                 credentialId,
                 companyId
             );
@@ -630,7 +585,7 @@ export class LinkedInApiClient {
                 })
                 .then((result) => result.body);
         } catch (error) {
-            this.logger.error('Error in getLikesByUser: ' + error, error);
+            logger.error('Error in getLikesByUser: ' + error, error);
             return false;
         }
         return true;
@@ -639,7 +594,7 @@ export class LinkedInApiClient {
     async uploadMedia(query) {
         const { socialAccountId, url, token, data } = query;
 
-        this.logger.info(
+        logger.info(
             `Starting to upload media to linkedin for ${socialAccountId}`,
             { url: query.url }
         );
@@ -657,7 +612,7 @@ export class LinkedInApiClient {
             })
             .send(data)
             .catch((err) => {
-                this.logger.error(err);
+                logger.error(err);
                 throw err;
             });
     }

package/src/data-access/http/tiktokApi.client.js

@@ -0,0 +1,477 @@
+import superagent from 'superagent';
+import configuration from '../../lib/configuration.js';
+import logger from '../../lib/logger.js';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+
+export class TikTokApiClient {
+    constructor() {
+        this.tiktokURL = configuration.get('TIKTOK_API_URL');
+        this.credentialsAPI = new CredentialsApiClient();
+    }
+
+    async getAuthorization(document) {
+        const {
+            documentId,
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = document;
+
+        try {
+            const credential = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+            return `${credential.token}`;
+        } catch (error) {
+            logger.error(
+                `${documentId} - error getting tiktok token - ${error.code}`,
+                error
+            );
+        }
+    }
+
+    async sendPost({
+        paramString = '',
+        headers = {},
+        document,
+        postData = undefined,
+    }) {
+        let response = {};
+        try {
+            response = await superagent
+                .post(this.tiktokURL + paramString)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .set('Access-Token', await this.getAuthorization(document))
+                .send(postData);
+        } catch (err) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call tiktok api for paramString ${paramString}`;
+                logger.error(errorText, err);
+            }
+
+            throw new Error(errorText);
+        }
+
+        return response;
+    }
+
+    // assumes batch calls are using the same credential
+    async sendRequest({ paramString = '', headers = {}, document }) {
+        let response = {};
+        try {
+            response = await superagent
+                .get(this.tiktokURL + paramString)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .set('Access-Token', await this.getAuthorization(document))
+                .send();
+        } catch (err) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call tiktok api for paramString ${paramString}`;
+                logger.error(errorText, err);
+            }
+
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call tiktok api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call tiktok api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+
+        return response.body;
+    }
+
+    async getChannelInfoForDocuments(documents) {
+        const channelInfo = await this.getStatsForDocuments(
+            documents,
+            'metaData.authors.0.authorInfo.externalId',
+            {
+                og: ['video/list/'],
+            }
+        );
+        return channelInfo;
+    }
+
+    async getStatsForDocuments(
+        documents,
+        externalIdFrom = 'metaData.externalId',
+        paramsByType = {
+            og: ['video/list/'],
+        }
+    ) {
+        // for batching separate og and comment/reply requests per credential
+        const documentsByTypeAndCredentials = documents.reduce(
+            (retObj, document, index) => {
+                const paramArray =
+                    paramsByType[document.metaData.discussionType];
+                if (paramArray) {
+                    paramArray.forEach((paramString) => {
+                        let discussionTypeBucket =
+                            retObj[
+                                `${paramString}${document.systemData.connectionsCredential}`
+                            ];
+                        if (!discussionTypeBucket) {
+                            discussionTypeBucket = {
+                                paramString,
+                                document,
+                                externalIds: [],
+                                externalIdToDocumentIndex: {},
+                            };
+                            retObj[
+                                `${paramString}${document.systemData.connectionsCredential}`
+                            ] = discussionTypeBucket;
+                        }
+                        const externalIdTrimmed = removePrefix(
+                            // javascript weirdness to get around '.' notation
+                            externalIdFrom
+                                .split('.')
+                                .reduce((a, b) => a[b], document)
+                        );
+                        discussionTypeBucket.externalIds.push(
+                            externalIdTrimmed
+                        );
+                        discussionTypeBucket.externalIdToDocumentIndex[
+                            externalIdTrimmed
+                        ] = index;
+                    });
+                }
+                return retObj;
+            },
+            {}
+        );
+
+        const sortedResults = Array(documents.length).fill();
+        await Promise.all(
+            Object.values(documentsByTypeAndCredentials).map(
+                async (documentsByTypeAndCredential) => {
+                    if (documentsByTypeAndCredential.externalIds.length) {
+                        const {
+                            metaData: {
+                                inReplyTo: { profileId: business_id },
+                            },
+                        } = documentsByTypeAndCredential.document;
+                        const trimmedBusinessId = removePrefix(business_id);
+                        const requestResult = await this.sendRequest({
+                            paramString: `${
+                                documentsByTypeAndCredential.paramString
+                            }?business_id=${trimmedBusinessId}&fields=["item_id","create_time","thumbnail_url","share_url","embed_url","caption","video_views","likes","comments","shares"]&filters=${JSON.stringify(
+                                {
+                                    video_ids:
+                                        documentsByTypeAndCredential.externalIds,
+                                }
+                            )}`,
+                            document: documentsByTypeAndCredential.document,
+                        });
+                        requestResult.data.videos.forEach(
+                            ({
+                                item_id,
+                                create_time,
+                                thumbnail_url,
+                                share_url,
+                                embed_url,
+                                caption,
+                                video_views,
+                                likes,
+                                comments,
+                                shares,
+                                ...args
+                            }) => {
+                                const documentIndex =
+                                    documentsByTypeAndCredential
+                                        .externalIdToDocumentIndex[item_id];
+                                sortedResults[documentIndex] = {
+                                    ...sortedResults[documentIndex],
+                                    item_id,
+                                    create_time,
+                                    thumbnail_url,
+                                    externalId:
+                                        documents[documentIndex].metaData
+                                            .externalId,
+                                    share_url,
+                                    embed_url,
+                                    caption,
+                                    video_views,
+                                    likes,
+                                    comments,
+                                    shares,
+                                };
+                            }
+                        );
+                    }
+                }
+            )
+        );
+        return sortedResults;
+    }
+
+    async publish(message, videoId, markMessageAsCompleteDocumentId) {
+        const {
+            metaData: { discussionType },
+        } = message;
+        let publishedMessage;
+
+        switch (discussionType) {
+            case 'qt':
+                publishedMessage = await this.insertComment(message);
+                break;
+            case 're':
+                publishedMessage = await this.insertReply(
+                    videoId,
+                    message,
+                    markMessageAsCompleteDocumentId
+                );
+                break;
+        }
+
+        return publishedMessage;
+    }
+
+    async insertComment(document) {
+        const {
+            body: {
+                content: { text: text },
+            },
+            metaData: {
+                source: { id: business_id },
+                inReplyTo: { id: video_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/create/',
+                postData: {
+                    business_id,
+                    video_id,
+                    text,
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async insertReply(videoId, document, markMessageAsCompleteDocumentId) {
+        const {
+            body: {
+                content: { text: text },
+            },
+            metaData: {
+                inReplyTo: { id: comment_id, profileId: business_id },
+            },
+        } = document;
+
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/reply/create/',
+                postData: {
+                    business_id: document.metaData.source.id,
+                    comment_id: markMessageAsCompleteDocumentId || comment_id,
+                    video_id: removePrefix(videoId),
+                    text,
+                },
+                document,
+            })) || {};
+
+        return publishedMessage;
+    }
+
+    async toggleLike(document) {
+        const {
+            enrichments: {
+                socialScores: { tt_liked_by_user: likedByUser },
+            },
+        } = document;
+
+        try {
+            let likeResponse = await (!likedByUser
+                ? this.like(document)
+                : this.unlike(document));
+            return likeResponse;
+        } catch (error) {
+            logger.error(`${document} - error recieved - ${error.code}`, error);
+            throw error;
+        }
+    }
+
+    async toggleHide(document) {
+        const {
+            documentId,
+            appData: { hidden: hiddenOnNative },
+        } = document;
+
+        let response;
+        try {
+            if (hiddenOnNative) {
+                response = await this.hide(document);
+            } else {
+                response = await this.unhide(document);
+            }
+            logger.info(
+                `Native Tiktok API Hide Response for documentId ${documentId}`,
+                { status: response.status, ok: response.ok }
+            );
+
+            if (response.message === 'OK') {
+                return response;
+            }
+        } catch (error) {
+            logger.error(
+                `${documentId} - error recieved - ${error.code}`,
+                error
+            );
+        }
+    }
+
+    async like(document) {
+        const {
+            metaData: {
+                externalId: comment_id,
+                source: { id: sourceId },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/like/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    action: 'LIKE',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async unlike(document) {
+        const {
+            metaData: {
+                inReplyTo: { id: comment_id },
+                source: { id: sourceId },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/like/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    action: 'unlike',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async hide(document) {
+        const {
+            metaData: {
+                externalId: comment_id,
+                source: { id: sourceId },
+                inReplyTo: { id: video_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/hide/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    video_id: removePrefix(video_id),
+                    action: 'HIDE',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async unhide(document) {
+        const {
+            metaData: {
+                externalId: comment_id,
+                source: { id: sourceId },
+                inReplyTo: { id: video_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/hide/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    video_id: removePrefix(video_id),
+                    action: 'UNHIDE',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async deleteComment(document) {
+        const {
+            metaData: {
+                inReplyTo: { id: comment_id, profileId: business_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/delete/',
+                postData: {
+                    business_id,
+                    comment_id,
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async getProfile(business_id, document) {
+        const fields = '["username", "display_name", "profile_image"]';
+        const profile =
+            (await this.sendRequest({
+                paramString: `get/?business_id=${business_id}&fields=${fields}`,
+                document,
+            })) || {};
+        return profile;
+    }
+
+    async getPostData(business_id, video_id, document) {
+        const fields =
+            '["item_id", "thumbnail_url", "create_time", "username", "display_name", "profile_image"]';
+        const video_ids = `["${video_id}"]`;
+        const profile =
+            (await this.sendRequest({
+                paramString: `video/list?business_id=${business_id}&fields=${fields}&filters={"video_ids":${video_ids}}`,
+                document,
+            })) || {};
+        return profile;
+    }
+}

package/src/data-access/index.js

@@ -10,6 +10,7 @@ import { InstagramApiClient } from './http/instagramApi.client.js';
 import { InstagramVideoClient } from './http/InstagramVideoClient.js';
 import { IRClient } from './http/ir.client.js';
 import { LinkedInApiClient } from './http/linkedInApi.client.js';
+import { TikTokApiClient } from './http/tiktokApi.client.js';
 import { MasfClient } from './http/masf.client.js';
 import { WarpZoneApiClient } from './http/WarpZoneApi.client.js';
 
@@ -26,6 +27,7 @@ export {
     InstagramVideoClient,
     IRClient,
     LinkedInApiClient,
+    TikTokApiClient,
     MasfClient,
     WarpZoneApiClient,
 };