@meltwater/conversations-api-services 1.3.2 → 1.4.0

package/src/data-access/http/twitter.native.js

@@ -2,9 +2,9 @@ import superagent from 'superagent';
 import { removePrefix } from '../../lib/externalId.helpers.js';
 import {
     loggerDebug,
-    loggerError,
     loggerInfo,
     loggerWarn,
+    MeltwaterAttributes,
 } from '../../lib/logger.helpers.js';
 import OAuth from 'oauth-1.0a';
 import crypto from 'crypto';
@@ -88,10 +88,15 @@ async function makeTwitterV2Request(
                     source: 'v1.1',
                 };
             } catch (fallbackError) {
-                loggerError(
+                loggerInfo(
                     logger,
-                    `Both v2 and v1.1 APIs failed for ${v2Endpoint}`,
-                    fallbackError
+                    `Failed to call twitter api - makeTwitterV2Request`,
+                    {
+                        [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                            v2Endpoint,
+                            error: fallbackError?.message,
+                        }),
+                    }
                 );
             }
         }
@@ -141,17 +146,25 @@ function normalizeUsersData(users, apiVersion = 'v1.1') {
  * @returns {Promise<Object>} User data from v2 API
  */
 export async function getAuthenticatedUser(token, logger) {
+    const apiUrl = 'https://api.x.com/2/users/me';
     try {
         const result = await getRequest({
             token,
-            uri: 'https://api.x.com/2/users/me',
+            uri: apiUrl,
             attachUrlPrefix: false,
             convertPayloadToUri: false,
             logger,
         });
         return result.data;
     } catch (e) {
-        loggerError(logger, `Error getting authenticated user info`, e);
+        loggerInfo(logger, `Failed to call twitter api - getAuthenticatedUser`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                status: e?.response?.status,
+                responseBody: e?.response?.body,
+                error: e?.response?.body?.errors?.[0]?.message ?? e?.message,
+            }),
+        });
         throw e;
     }
 }
@@ -208,8 +221,12 @@ export async function getUserInfoFromHandles(token, handles, logger) {
         const normalizedData = normalizeUsersData(result.data, result.source);
         return normalizedData || [];
     } catch (e) {
-        loggerError(logger, `Unexpected error in getUserInfoFromHandles`, e);
-        return [];
+        loggerInfo(logger, `Failed to call twitter api - getUserInfoFromHandles`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                error: e?.message,
+            }),
+        });
+        throw e;
     }
 }
 
@@ -242,13 +259,13 @@ export async function getUserInfoFromHandle(token, handleId, logger) {
             );
         }
     } catch (e) {
-        loggerError(
-            logger,
-            `Error in getUserInfoFromHandle with handleId: ${JSON.stringify(
-                handleId
-            )}`,
-            e
-        );
+        loggerInfo(logger, `Failed to call twitter api - getUserInfoFromHandle`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                handleId,
+                error: e?.message,
+            }),
+        });
+        throw e;
     }
 }
 
@@ -265,7 +282,12 @@ export async function getDirectMessageImage(token, imageUrl, logger) {
             contentType: result.contentType,
         };
     } catch (e) {
-        loggerError(logger, `Error getting image`, e);
+        loggerInfo(logger, `Failed to call twitter api - getDirectMessageImage`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                imageUrl,
+                error: e?.message,
+            }),
+        });
         throw e;
     }
 }
@@ -288,7 +310,13 @@ export async function getCurrentInfo(token, externalId, logger) {
         result.data.retweeted = !!result.data.current_user_retweet;
         return result.data.data[0].public_metrics;
     } catch (error) {
-        loggerDebug(logger, 'Error in twitter getCurrentInfo', error);
+        loggerInfo(logger, `Failed to call twitter api - getCurrentInfo`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 }
 
@@ -306,7 +334,13 @@ export async function getMentionHandleInfo(token, externalId, logger) {
         });
         return result.data;
     } catch (error) {
-        loggerDebug(logger, 'Error in twitter getMentionHandleInfo', error);
+        loggerInfo(logger, `Failed to call twitter api - getMentionHandleInfo`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 }
 
@@ -332,7 +366,14 @@ export async function retweet(token, sourceId, externalId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger, `Error in retweet user: ${sourceId}`, error);
+        loggerInfo(logger, `Failed to call twitter api - retweet`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                sourceId,
+                externalId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 }
 
@@ -355,16 +396,20 @@ export async function unRetweet(token, sourceId, externalId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger, `Error in unretweet user: ${sourceId}`, error, {
-            [MeltwaterAttributes.SOCIALEXTERNALID]: externalId,
+        loggerInfo(logger, `Failed to call twitter api - unRetweet`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                sourceId,
+                externalId,
+                error: error?.message,
+            }),
         });
+        throw error;
     }
 }
 
-export async function like(token, externalId, logger) {
+export async function like(token, externalId, logger, authenticatedUser = null) {
     try {
-        // Get the authenticated user's ID first
-        const userInfo = await getAuthenticatedUser(token, logger);
+        const userInfo = authenticatedUser ?? await getAuthenticatedUser(token, logger);
         const userId = userInfo.data.id;
 
         let response = await postRequest({
@@ -394,15 +439,19 @@ export async function like(token, externalId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger, `Twitter Error in like user: ${externalId}`, error);
+        loggerInfo(logger, `Failed to call twitter api - like`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                error: error?.message,
+            }),
+        });
         throw error;
     }
 }
 
-export async function unLike(token, externalId, logger) {
+export async function unLike(token, externalId, logger, authenticatedUser = null) {
     try {
-        // Get the authenticated user's ID first
-        const userInfo = await getAuthenticatedUser(token, logger);
+        const userInfo = authenticatedUser ?? await getAuthenticatedUser(token, logger);
         const userId = userInfo.data.id;
 
         let response = await deleteRequest({
@@ -424,15 +473,19 @@ export async function unLike(token, externalId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger, `Error in unlike user: ${externalId}`, error);
+        loggerInfo(logger, `Failed to call twitter api - unLike`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                error: error?.message,
+            }),
+        });
         throw error;
     }
 }
 
-export async function followUser(token, profileId, logger) {
+export async function followUser(token, profileId, logger, authenticatedUser = null) {
     try {
-        // Get the authenticated user's ID first
-        const userInfo = await getAuthenticatedUser(token, logger);
+        const userInfo = authenticatedUser ?? await getAuthenticatedUser(token, logger);
         const userId = userInfo.data.id;
 
         let response = await postRequest({
@@ -452,14 +505,19 @@ export async function followUser(token, profileId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger, `Error in following user: ${profileId}`, error);
+        loggerInfo(logger, `Failed to call twitter api - followUser`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                profileId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 }
 
-export async function unFollowUser(token, profileId, logger) {
+export async function unFollowUser(token, profileId, logger, authenticatedUser = null) {
     try {
-        // Get the authenticated user's ID first
-        const userInfo = await getAuthenticatedUser(token, logger);
+        const userInfo = authenticatedUser ?? await getAuthenticatedUser(token, logger);
         const userId = userInfo.data.id;
 
         let response = await deleteRequest({
@@ -478,14 +536,19 @@ export async function unFollowUser(token, profileId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger, `Error in unfollowing user: ${profileId}`, error);
+        loggerInfo(logger, `Failed to call twitter api - unFollowUser`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                profileId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 }
 
-export async function userFollowStatus(token, profileId, logger) {
+export async function userFollowStatus(token, profileId, logger, authenticatedUser = null) {
     try {
-        // Get the authenticated user's ID first
-        const userInfo = await getAuthenticatedUser(token, logger);
+        const userInfo = authenticatedUser ?? await getAuthenticatedUser(token, logger);
         const userId = userInfo.data.id;
 
         // Check if authenticated user is following the target user
@@ -528,7 +591,7 @@ export async function userFollowStatus(token, profileId, logger) {
             // if we hit a minor rate limit here, we wait for 5 seconds before attempting again, usually long enough to continue
             await new Promise((r) => setTimeout(r, 5000));
 
-            return userFollowStatus(token, profileId, logger);
+            return userFollowStatus(token, profileId, logger, authenticatedUser);
         }
     }
 }
@@ -601,11 +664,14 @@ export async function getBrandUserRelationship(
             },
         };
     } catch (error) {
-        loggerDebug(
-            logger,
-            `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`,
-            error
-        );
+        loggerInfo(logger, `Failed to call twitter api - getBrandUserRelationship`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                profileId,
+                brandProfileId,
+                error: error?.message,
+            }),
+        });
+        throw error;
     }
 }
 
@@ -888,7 +954,6 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
 
         return normalizedResponse;
     } catch (err) {
-        loggerError(logger, `Twitter publish exception details`, err);
         throw err;
     }
 }
@@ -936,7 +1001,6 @@ async function publishDirectMessage(token, payload, query, logger) {
 
         return normalizedResponse;
     } catch (err) {
-        loggerError(logger, `Twitter DM send failed`, err);
         throw err;
     }
 }
@@ -1081,10 +1145,14 @@ async function doRequest({
                 );
                 return reject(e);
             }
-            loggerError(logger, `Error in twitter doRequest`, e, {
-                url,
-                convertPayloadToUri,
-                payload: JSON.stringify(payload),
+            loggerInfo(logger, `Failed to call twitter api - doRequest`, {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    url,
+                    convertPayloadToUri,
+                    payload: JSON.stringify(payload),
+                    status: e?.response?.status,
+                    error: e?.response?.body?.errors?.[0]?.message ?? e?.message,
+                }),
             });
             reject(e);
         }
@@ -1173,7 +1241,6 @@ async function uploadMedia(attachment, token, discussionType, logger) {
             return mediaIdString;
         }
     } catch (e) {
-        loggerError(logger, `Failed uploading media`, e);
         if (filePath) {
             removeMedia(filePath, logger);
         }
@@ -1217,7 +1284,13 @@ async function simpleMediaUpload(fileData, mimeType, mediaCategory, token, logge
 
         return result.body.media_id_string;
     } catch (e) {
-        loggerError(logger, 'Error in simple media upload', e);
+        loggerInfo(logger, `Failed to call twitter api - simpleMediaUpload`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                mimeType,
+                mediaCategory,
+                error: e?.message,
+            }),
+        });
         throw e;
     }
 }
@@ -1299,7 +1372,6 @@ async function chunkedMediaUpload(
 
         return mediaId;
     } catch (e) {
-        loggerError(logger, 'Error in chunked media upload', e);
         throw e;
     }
 }
@@ -1359,11 +1431,12 @@ async function mediaUploadRequest(params, token, logger) {
         const result = await request;
         return result.body;
     } catch (e) {
-        loggerError(
-            logger,
-            `Media upload request failed for command: ${params.command}`,
-            e
-        );
+        loggerInfo(logger, `Failed to call twitter api - mediaUploadRequest`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                command: params.command,
+                error: e?.message,
+            }),
+        });
         throw e;
     }
 }
@@ -1421,13 +1494,20 @@ function removeMedia(file, logger) {
     try {
         fs.unlink(file, function (err) {
             if (err) {
-                loggerError(logger, `Failed removing ${file}`, err);
+                loggerInfo(logger, `Failed to call twitter api - removeMedia`, {
+                    [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                        file,
+                        error: err?.message,
+                    }),
+                });
             }
         });
     } catch (e) {
-        loggerError(
-            logger,
-            `failed trying to remove media ${file} it may have already been removed`
-        );
+        loggerInfo(logger, `Failed to call twitter api - removeMedia`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                file,
+                error: e?.message,
+            }),
+        });
     }
 }

package/src/data-access/http/youtube.native.js

@@ -1,6 +1,6 @@
 import superagent from 'superagent';
 import { removePrefix } from '../../lib/externalId.helpers.js';
-import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+import { loggerInfo, MeltwaterAttributes } from '../../lib/logger.helpers.js';
 
 const YOUTUBE_API_URL = "https://www.googleapis.com/youtube/v3/"
 
@@ -20,22 +20,12 @@ async function sendPost(
             .set('Authorization', `Bearer ${token}`)
             .send(postData);
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(logger,
-                `Failed to call youtube api for paramString ${paramString}: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(logger,
-                `Failed to call youtube api for paramString ${paramString}`,
-                err
-            );
-        }
-
+        loggerInfo(logger, 'Failed to call youtube api - sendPost', {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                paramString,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
 
@@ -56,33 +46,24 @@ export async function sendRequest(
             .set('Authorization', `Bearer ${token}`)
             .send();
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError( logger,
-                `Failed to call youtube api for paramString ${paramString}: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError( logger,
-                `Failed to call youtube api for paramString ${paramString}`,
-                err
-            );
-        }
-
+        loggerInfo(logger, 'Failed to call youtube api - sendRequest', {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                paramString,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger,
-            `Failed to call facebook api`,
-            { responseBody: JSON.stringify(response.body) }
-        );
-        let error = new Error(
-            `Failed to call facebook api`
-        );
+        loggerInfo(logger, 'Failed to call youtube api - sendRequest', {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                paramString,
+                status: response.status,
+                body: response.body,
+            }),
+        });
+        let error = new Error(`Failed to call youtube api`);
         error.code = response.status;
         throw error;
     }

package/dist/cjs/lib/hiddenComment.helper.js

@@ -1,119 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _logger = _interopRequireDefault(require("../lib/logger.js"));
-var _irClien = require("../data-access/http/ir.clien.jst");
-var _xrunes = _interopRequireDefault(require("@meltwater/xrunes"));
-var _xrunesCore = _interopRequireDefault(require("@meltwater/xrunes-core"));
-var _loggerHelpers = require("../lib/logger.helpers.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class HiddenCommentHelper {
-  constructor(_ref) {
-    let {
-      company,
-      user,
-      traceId
-    } = _ref;
-    this.irClient = new _irClien.IRClient({
-      company,
-      user,
-      traceId
-    });
-    this.xRunes = new _xrunes.default();
-    this.xRunes.registerLibrary(_xrunesCore.default);
-  }
-  shouldHandle(message) {
-    return message.metaData.discussionType === 'qt';
-  }
-  async hideChildren(message, markHidden) {
-    let {
-      body: {
-        publishDate: {
-          date: publishDate
-        } = {}
-      } = {},
-      metaData: {
-        externalId,
-        source: {
-          socialOriginType
-        } = {}
-      } = {},
-      systemData: {
-        connectionsCredential: credentialId,
-        policies: {
-          storage: {
-            privateTo: companyId
-          } = {}
-        } = {}
-      } = {}
-    } = message;
-    let operation;
-    let query = {
-      type: 'x:match',
-      matchQuery: {
-        type: 'all',
-        allQueries: [{
-          type: 'x:dateRange',
-          field: 'body.publishDate.date',
-          from: publishDate
-        }, {
-          type: 'term',
-          field: 'metaData.inReplyTo.externalId',
-          value: externalId
-        }]
-      }
-    };
-    if (markHidden) {
-      operation = 'addToSet';
-      query.notMatchQuery = {
-        type: 'term',
-        field: 'metaData.applicationTags',
-        value: 'parentHidden'
-      };
-    } else {
-      operation = 'removeFromSet';
-      query.matchQuery.allQueries.push({
-        type: 'term',
-        field: 'metaData.applicationTags',
-        value: 'parentHidden'
-      });
-    }
-    let runes = {
-      query,
-      transformers: [{
-        type: 'idml',
-        script: `action = "update" target = "revision" revisionGroup = "${companyId}" documentId = id operations = [{"operation": "${operation}", "value": ["parentHidden"], "fieldPath": "metaData.applicationTags"}]`
-      }],
-      overlayGroups: [companyId],
-      fields: ['id'],
-      outputConfiguration: {
-        type: 's3',
-        region: 'eu-west-1',
-        roleArn: process.env.EXPORT_API_ROLE_ARN,
-        externalId: process.env.EXPORT_API_EXTERNAL_ID,
-        s3BucketName: process.env.EXPORT_API_S3_BUCKET,
-        s3KeyPrefix: process.env.EXPORT_API_S3_PREFIX,
-        // the property is optional, the trailing / isn't
-        batchSize: 1000 // the property is optional, must be >= 100 and <= 20000. Default is 20000
-      },
-      metaData: {
-        companyId
-      }
-    };
-    runes.query = await this.xRunes.render(runes.query);
-    _logger.default.debug(`export api query: ${JSON.stringify(runes.query)}`, {
-      [_loggerHelpers.MeltwaterAttributes.COMPANYID]: companyId,
-      [_loggerHelpers.MeltwaterAttributes.CREDENTIALID]: credentialId
-    });
-    let results = await this.irClient.export(runes);
-    _logger.default.debug(`export api result: ${JSON.stringify(results)}`, {
-      [_loggerHelpers.MeltwaterAttributes.COMPANYID]: companyId,
-      [_loggerHelpers.MeltwaterAttributes.CREDENTIALID]: credentialId
-    });
-    return results;
-  }
-}
-var _default = exports.default = HiddenCommentHelper;