@meltwater/conversations-api-services 1.1.24 → 1.2.1

package/dist/cjs/data-access/http/twitter.native.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.addOAuthToToken = addOAuthToToken;
 exports.followUser = followUser;
+exports.getAuthenticatedUser = getAuthenticatedUser;
 exports.getBrandUserRelationship = getBrandUserRelationship;
 exports.getCurrentInfo = getCurrentInfo;
 exports.getDirectMessageImage = getDirectMessageImage;
@@ -27,7 +28,6 @@ var _oauth = _interopRequireDefault(require("oauth-1.0a"));
 var _crypto = _interopRequireDefault(require("crypto"));
 var _axios = _interopRequireDefault(require("axios"));
 var _fs = _interopRequireDefault(require("fs"));
-var _socialTwit = _interopRequireDefault(require("@meltwater/social-twit"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const TWITTER_API_CONFIG = {
   v1_1: {
@@ -135,6 +135,28 @@ function normalizeUsersData(users) {
   }
   return normalizeUserData(users, apiVersion);
 }
+
+/**
+ * Get authenticated user information using Twitter API v2
+ * @param {Object} token - OAuth token object
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} User data from v2 API
+ */
+async function getAuthenticatedUser(token, logger) {
+  try {
+    const result = await getRequest({
+      token,
+      uri: 'https://api.x.com/2/users/me',
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
+      logger
+    });
+    return result.data;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting authenticated user info`, e);
+    throw e;
+  }
+}
 function addOAuthToToken(token, TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET) {
   if (!token.oauth) {
     token.oauth = (0, _oauth.default)({
@@ -230,7 +252,7 @@ async function getCurrentInfo(token, externalId, logger) {
     });
 
     // this makes it so 'retweeted' is only true on a retweet that isn't a comment
-    // sometimes 'retweeted' is true if user retweeted with comment, sometimes not :sadness:
+    // sometimes 'retweeted' is true if user retweeted with comment, sometimes not
     result.data.retweeted = !!result.data.current_user_retweet;
     return result.data.data[0].public_metrics;
   } catch (error) {
@@ -293,12 +315,20 @@ async function unRetweet(token, sourceId, externalId, logger) {
 }
 async function like(token, externalId, logger) {
   try {
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
     let response = await postRequest({
       token,
-      uri: 'favorites/create.json?id=' + (0, _externalIdHelpers.removePrefix)(externalId),
+      uri: `https://api.x.com/2/users/${userId}/likes`,
+      payload: {
+        tweet_id: (0, _externalIdHelpers.removePrefix)(externalId)
+      },
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+    if (response.data.data?.liked !== undefined && response.resp.statusCode === 200) {
       return true;
     } else {
       (0, _loggerHelpers.loggerInfo)(logger, 'Twitter Error in like user statusCode non 200 ', {
@@ -313,12 +343,17 @@ async function like(token, externalId, logger) {
 }
 async function unLike(token, externalId, logger) {
   try {
-    let response = await postRequest({
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
+    let response = await deleteRequest({
       token,
-      uri: 'favorites/destroy.json?id=' + (0, _externalIdHelpers.removePrefix)(externalId),
+      uri: `https://api.x.com/2/users/${userId}/likes/${(0, _externalIdHelpers.removePrefix)(externalId)}`,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+    if (response.data.data?.liked !== undefined && response.resp.statusCode === 200) {
       return true;
     } else {
       return false;
@@ -330,16 +365,20 @@ async function unLike(token, externalId, logger) {
 }
 async function followUser(token, profileId, logger) {
   try {
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
     let response = await postRequest({
       token,
-      uri: 'friendships/create.json',
+      uri: `https://api.x.com/2/users/${userId}/following`,
       payload: {
-        user_id: (0, _externalIdHelpers.removePrefix)(profileId),
-        follow: true
+        target_user_id: (0, _externalIdHelpers.removePrefix)(profileId)
       },
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.following !== undefined) {
+    if (response.data.data?.following !== undefined) {
       return true;
     } else {
       return false;
@@ -350,15 +389,17 @@ async function followUser(token, profileId, logger) {
 }
 async function unFollowUser(token, profileId, logger) {
   try {
-    let response = await postRequest({
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
+    let response = await deleteRequest({
       token,
-      uri: 'friendships/destroy.json',
-      payload: {
-        user_id: (0, _externalIdHelpers.removePrefix)(profileId)
-      },
+      uri: `https://api.x.com/2/users/${userId}/following/${(0, _externalIdHelpers.removePrefix)(profileId)}`,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.following !== undefined) {
+    if (response.data.data?.following !== undefined) {
       return true;
     } else {
       return false;
@@ -369,26 +410,34 @@ async function unFollowUser(token, profileId, logger) {
 }
 async function userFollowStatus(token, profileId, logger) {
   try {
+    // Get the authenticated user's ID first
+    const userInfo = await getAuthenticatedUser(token, logger);
+    const userId = userInfo.data.id;
+
+    // Check if authenticated user is following the target user
+    // We need to check the following list with pagination support
     let response = await getRequest({
       token,
-      uri: 'friendships/lookup.json',
+      uri: `https://api.x.com/2/users/${userId}/following`,
       payload: {
-        user_id: (0, _externalIdHelpers.removePrefix)(profileId)
+        max_results: 1000 // Max allowed per request
       },
+      attachUrlPrefix: false,
+      convertPayloadToUri: true,
       logger
     });
-    if (response.data.length > 0) {
-      if (response.data[0].connections.length > 0) {
-        for (var i = 0; i < response.data[0].connections.length; i++) {
-          if (response.data[0].connections[i] === 'following') {
-            return true;
-          }
-        }
-        return false;
-      } else {
-        return false;
+    if (response.data?.data) {
+      // Check if the profileId is in the following list
+      const isFollowing = response.data.data.some(user => user.id === (0, _externalIdHelpers.removePrefix)(profileId));
+      if (isFollowing) {
+        return true;
       }
+
+      // If not found and there's a next page, we might need to paginate
+      // For now, return false if not in first page
+      return false;
     }
+    return false;
   } catch (error) {
     (0, _loggerHelpers.loggerDebug)(logger, `Error in getting user follow status: ${profileId}`, error);
     if (error.message != 'Bad Request') {
@@ -400,16 +449,58 @@ async function userFollowStatus(token, profileId, logger) {
 }
 async function getBrandUserRelationship(token, profileId, brandProfileId, logger) {
   try {
-    let {
-      data: {
-        relationship
-      } = {}
-    } = await getRequest({
-      token,
-      uri: `friendships/show.json?source_id=${brandProfileId}&target_id=${(0, _externalIdHelpers.removePrefix)(profileId)}`,
-      logger
-    });
-    return relationship;
+    // In v2 API, we need to make separate calls to check following/followers status
+    // Check if brand follows user
+    let brandFollowsUser = false;
+    let userFollowsBrand = false;
+    try {
+      const followingResponse = await getRequest({
+        token,
+        uri: `https://api.x.com/2/users/${brandProfileId}/following`,
+        payload: {
+          max_results: 1000
+        },
+        attachUrlPrefix: false,
+        convertPayloadToUri: true,
+        logger
+      });
+      if (followingResponse.data?.data) {
+        brandFollowsUser = followingResponse.data.data.some(user => user.id === (0, _externalIdHelpers.removePrefix)(profileId));
+      }
+    } catch (e) {
+      (0, _loggerHelpers.loggerWarn)(logger, 'Error checking if brand follows user', e);
+    }
+    try {
+      const followersResponse = await getRequest({
+        token,
+        uri: `https://api.x.com/2/users/${brandProfileId}/followers`,
+        payload: {
+          max_results: 1000
+        },
+        attachUrlPrefix: false,
+        convertPayloadToUri: true,
+        logger
+      });
+      if (followersResponse.data?.data) {
+        userFollowsBrand = followersResponse.data.data.some(user => user.id === (0, _externalIdHelpers.removePrefix)(profileId));
+      }
+    } catch (e) {
+      (0, _loggerHelpers.loggerWarn)(logger, 'Error checking if user follows brand', e);
+    }
+
+    // Build a relationship object similar to v1.1 format
+    return {
+      source: {
+        id_str: brandProfileId,
+        following: brandFollowsUser,
+        followed_by: userFollowsBrand
+      },
+      target: {
+        id_str: (0, _externalIdHelpers.removePrefix)(profileId),
+        following: userFollowsBrand,
+        followed_by: brandFollowsUser
+      }
+    };
   } catch (error) {
     (0, _loggerHelpers.loggerDebug)(logger, `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`, error);
   }
@@ -441,34 +532,21 @@ async function reply(token, text, attachment, inReplyToId, removeInReplyToId, lo
   return publishTweet(token, payload, query, false, logger);
 }
 async function privateMessage(token, text, attachment, profileId, logger) {
-  let query = 'direct_messages/events/new.json';
+  let query = `https://api.x.com/2/dm_conversations/with/${(0, _externalIdHelpers.removePrefix)(profileId)}/messages`;
   let mediaId;
   if (attachment) {
     // discussionType only matters if DM or Not
     mediaId = await uploadMedia(attachment, token, 'dm', logger);
   }
   const payload = {
-    event: {
-      type: 'message_create',
-      message_create: {
-        target: {
-          recipient_id: (0, _externalIdHelpers.removePrefix)(profileId)
-        },
-        message_data: {
-          text: text || ' ',
-          ...(attachment && {
-            attachment: {
-              type: 'media',
-              media: {
-                id: mediaId
-              }
-            }
-          })
-        }
-      }
-    }
+    text: text || ' ',
+    ...(attachment && {
+      attachments: [{
+        media_id: mediaId
+      }]
+    })
   };
-  return publishTweet(token, payload, query, true, logger);
+  return publishDirectMessage(token, payload, query, logger);
 }
 async function retweetWithComment(token, text, attachment, logger) {
   let mediaId;
@@ -527,6 +605,35 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
     throw err;
   }
 }
+async function publishDirectMessage(token, payload, query, logger) {
+  try {
+    let nativeResponse = await postRequest({
+      token,
+      uri: query,
+      payload,
+      convertPayloadToUri: false,
+      attachUrlPrefix: false
+    });
+    (0, _loggerHelpers.loggerInfo)(logger, `finished sending DM via Twitter API v2`, {
+      data: JSON.stringify(nativeResponse.data)
+    });
+    const response = nativeResponse.resp ? {
+      statusCode: nativeResponse.resp.statusCode,
+      statusMessage: nativeResponse.resp.statusCode === 201 || nativeResponse.resp.statusCode === 200 ? 'Success' : 'Unknown Failure',
+      data: nativeResponse.data.data
+    } : {
+      statusCode: nativeResponse.statusCode,
+      statusMessage: nativeResponse.message
+    };
+    (0, _loggerHelpers.loggerDebug)(logger, `Twitter DM response is`, {
+      response: JSON.stringify(response)
+    });
+    return response;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Twitter DM exception details`, err);
+    throw err;
+  }
+}
 async function postRequest(_ref2) {
   let {
     token,
@@ -685,32 +792,177 @@ function generateFilePath(mimeType, dirname) {
 }
 // local
 async function uploadMedia(attachment, token, discussionType, logger) {
-  return new Promise(async (resolve, reject) => {
-    let filePath = generateFilePath(attachment.mimeType, attachment.__dirname);
+  let filePath;
+  try {
+    filePath = generateFilePath(attachment.mimeType, attachment.__dirname);
     await downloadImage(attachment.url, filePath);
-    const T = new _socialTwit.default({
-      consumer_key: token.consumer_key,
-      consumer_secret: token.consumer_secret,
-      access_token: token.token,
-      access_token_secret: token.tokenSecret
+    const mediaCategory = discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+    const fileStats = _fs.default.statSync(filePath);
+    const fileSize = fileStats.size;
+    const fileData = _fs.default.readFileSync(filePath);
+
+    // For small files, use simple upload
+    if (fileSize < 5000000) {
+      // 5MB
+      const mediaIdString = await simpleMediaUpload(fileData, attachment.mimeType, token, logger);
+      removeMedia(filePath, logger);
+      return mediaIdString;
+    } else {
+      // For large files, use chunked upload
+      const mediaIdString = await chunkedMediaUpload(filePath, fileSize, attachment.mimeType, mediaCategory, token, logger);
+      removeMedia(filePath, logger);
+      return mediaIdString;
+    }
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed uploading media`, e);
+    if (filePath) {
+      removeMedia(filePath, logger);
+    }
+    throw e;
+  }
+}
+
+// Simple upload for small media files
+async function simpleMediaUpload(fileData, mimeType, token, logger) {
+  try {
+    const base64Data = fileData.toString('base64');
+    const mediaType = mimeType.split('/')[0]; // 'image', 'video', etc.
+
+    const url = 'https://upload.twitter.com/1.1/media/upload.json';
+    const {
+      Authorization
+    } = token.oauth.toHeader(token.oauth.authorize({
+      url,
+      method: 'post',
+      data: {}
+    }, {
+      key: token.token,
+      secret: token.tokenSecret
+    }));
+    const result = await _superagent.default.post(url).set('Authorization', Authorization).send({
+      media_data: base64Data,
+      media_type: mimeType
     });
-    let mediaCategory = discussionType === 'dm' ? 'dm' : 'tweet';
-    try {
-      T.postMediaChunked({
-        file_path: filePath
-      }, mediaCategory, function (err, data, response) {
-        if (err) {
-          reject(err);
-        }
-        resolve(data.media_id_string);
-        removeMedia(filePath, logger);
+    (0, _loggerHelpers.loggerDebug)(logger, 'Media uploaded successfully (simple)', {
+      media_id: result.body.media_id_string
+    });
+    return result.body.media_id_string;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in simple media upload', e);
+    throw e;
+  }
+}
+
+// Chunked upload for large media files
+async function chunkedMediaUpload(filePath, fileSize, mimeType, mediaCategory, token, logger) {
+  try {
+    const mediaType = mimeType.split('/')[0];
+
+    // Step 1: INIT
+    const initResponse = await mediaUploadRequest({
+      command: 'INIT',
+      total_bytes: fileSize,
+      media_type: mimeType,
+      media_category: mediaCategory
+    }, token, logger);
+    const mediaId = initResponse.media_id_string;
+    (0, _loggerHelpers.loggerDebug)(logger, 'Media upload INIT successful', {
+      mediaId
+    });
+
+    // Step 2: APPEND (upload in chunks)
+    const chunkSize = 5 * 1024 * 1024; // 5MB chunks
+    const fileBuffer = _fs.default.readFileSync(filePath);
+    let segmentIndex = 0;
+    for (let offset = 0; offset < fileSize; offset += chunkSize) {
+      const chunk = fileBuffer.slice(offset, Math.min(offset + chunkSize, fileSize));
+      const base64Chunk = chunk.toString('base64');
+      await mediaUploadRequest({
+        command: 'APPEND',
+        media_id: mediaId,
+        media_data: base64Chunk,
+        segment_index: segmentIndex
+      }, token, logger);
+      (0, _loggerHelpers.loggerDebug)(logger, `Media chunk ${segmentIndex} uploaded`, {
+        mediaId,
+        segmentIndex
       });
-    } catch (e) {
-      (0, _loggerHelpers.loggerError)(logger, `Failed posting media`, e);
-      // this is just a safety precaution
-      removeMedia(filePath, logger);
+      segmentIndex++;
     }
-  });
+
+    // Step 3: FINALIZE
+    const finalizeResponse = await mediaUploadRequest({
+      command: 'FINALIZE',
+      media_id: mediaId
+    }, token, logger);
+    (0, _loggerHelpers.loggerDebug)(logger, 'Media upload FINALIZE successful', {
+      mediaId
+    });
+
+    // Step 4: Check processing status if needed
+    if (finalizeResponse.processing_info) {
+      await waitForMediaProcessing(mediaId, token, logger);
+    }
+    return mediaId;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in chunked media upload', e);
+    throw e;
+  }
+}
+
+// Make a media upload request
+async function mediaUploadRequest(params, token, logger) {
+  const url = 'https://upload.twitter.com/1.1/media/upload.json';
+  const {
+    Authorization
+  } = token.oauth.toHeader(token.oauth.authorize({
+    url,
+    method: 'post',
+    data: {}
+  }, {
+    key: token.token,
+    secret: token.tokenSecret
+  }));
+  try {
+    const result = await _superagent.default.post(url).set('Authorization', Authorization).send(params);
+    return result.body;
+  } catch (e) {
+    (0, _loggerHelpers.loggerError)(logger, `Media upload request failed for command: ${params.command}`, e);
+    throw e;
+  }
+}
+
+// Wait for media processing to complete
+async function waitForMediaProcessing(mediaId, token, logger) {
+  let maxAttempts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 20;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const statusResponse = await mediaUploadRequest({
+      command: 'STATUS',
+      media_id: mediaId
+    }, token, logger);
+    if (!statusResponse.processing_info) {
+      return; // Processing complete
+    }
+    const state = statusResponse.processing_info.state;
+    if (state === 'succeeded') {
+      (0, _loggerHelpers.loggerDebug)(logger, 'Media processing succeeded', {
+        mediaId
+      });
+      return;
+    }
+    if (state === 'failed') {
+      throw new Error(`Media processing failed: ${statusResponse.processing_info.error?.message || 'Unknown error'}`);
+    }
+
+    // Still processing, wait before checking again
+    const waitTime = statusResponse.processing_info.check_after_secs || 1;
+    (0, _loggerHelpers.loggerDebug)(logger, `Media still processing, waiting ${waitTime}s`, {
+      mediaId,
+      state
+    });
+    await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+  }
+  throw new Error('Media processing timeout');
 }
 function removeMedia(file, logger) {
   try {
@@ -722,5 +974,4 @@ function removeMedia(file, logger) {
   } catch (e) {
     (0, _loggerHelpers.loggerError)(logger, `failed trying to remove media ${file} it may have already been removed`);
   }
-}
-;
+}