@meltwater/conversations-api-services 1.1.24 → 1.2.2

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

@@ -5,7 +5,6 @@ import OAuth from 'oauth-1.0a';
 import crypto from 'crypto';
 import axios from 'axios';
 import fs from 'fs';
-import Twit from '@meltwater/social-twit';
 const TWITTER_API_CONFIG = {
   v1_1: {
     base_url: 'https://api.twitter.com/1.1'
@@ -112,6 +111,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
+ */
+export 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) {
+    loggerError(logger, `Error getting authenticated user info`, e);
+    throw e;
+  }
+}
 export function addOAuthToToken(token, TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET) {
   if (!token.oauth) {
     token.oauth = OAuth({
@@ -207,7 +228,7 @@ export 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) {
@@ -270,12 +291,20 @@ export async function unRetweet(token, sourceId, externalId, logger) {
 }
 export 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=' + removePrefix(externalId),
+      uri: `https://api.x.com/2/users/${userId}/likes`,
+      payload: {
+        tweet_id: 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 {
       loggerInfo(logger, 'Twitter Error in like user statusCode non 200 ', {
@@ -290,12 +319,17 @@ export async function like(token, externalId, logger) {
 }
 export 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=' + removePrefix(externalId),
+      uri: `https://api.x.com/2/users/${userId}/likes/${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;
@@ -307,16 +341,20 @@ export async function unLike(token, externalId, logger) {
 }
 export 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: removePrefix(profileId),
-        follow: true
+        target_user_id: removePrefix(profileId)
       },
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.following !== undefined) {
+    if (response.data.data?.following !== undefined) {
       return true;
     } else {
       return false;
@@ -327,15 +365,17 @@ export async function followUser(token, profileId, logger) {
 }
 export 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: removePrefix(profileId)
-      },
+      uri: `https://api.x.com/2/users/${userId}/following/${removePrefix(profileId)}`,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
       logger
     });
-    if (response.data.following !== undefined) {
+    if (response.data.data?.following !== undefined) {
       return true;
     } else {
       return false;
@@ -346,26 +386,34 @@ export async function unFollowUser(token, profileId, logger) {
 }
 export 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: 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 === 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) {
     loggerDebug(logger, `Error in getting user follow status: ${profileId}`, error);
     if (error.message != 'Bad Request') {
@@ -377,16 +425,58 @@ export async function userFollowStatus(token, profileId, logger) {
 }
 export async function getBrandUserRelationship(token, profileId, brandProfileId, logger) {
   try {
-    let {
-      data: {
-        relationship
-      } = {}
-    } = await getRequest({
-      token,
-      uri: `friendships/show.json?source_id=${brandProfileId}&target_id=${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 === removePrefix(profileId));
+      }
+    } catch (e) {
+      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 === removePrefix(profileId));
+      }
+    } catch (e) {
+      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: removePrefix(profileId),
+        following: userFollowsBrand,
+        followed_by: brandFollowsUser
+      }
+    };
   } catch (error) {
     loggerDebug(logger, `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`, error);
   }
@@ -418,34 +508,21 @@ export async function reply(token, text, attachment, inReplyToId, removeInReplyT
   return publishTweet(token, payload, query, false, logger);
 }
 export 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/${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: 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);
 }
 export async function retweetWithComment(token, text, attachment, logger) {
   let mediaId;
@@ -464,6 +541,84 @@ export async function retweetWithComment(token, text, attachment, logger) {
   let query = 'https://api.twitter.com/2/tweets';
   return publishTweet(token, payload, query, false, logger);
 }
+
+/**
+ * Normalizes Twitter API responses to ensure consistent structure across v1.1 and v2
+ * This is critical for backward compatibility - consumers expect certain fields to exist
+ *
+ * @param {Object} response - The response object to normalize
+ * @param {string} responseType - Type of response: 'dm' for direct messages, 'tweet' for tweets
+ * @param {Object} logger - Logger instance for debugging
+ * @param {Object} fullResponse - Full API response including includes (for extracting author_id from expansions)
+ * @returns {Object} Normalized response with consistent field structure
+ */
+function normalizeTwitterResponse(response, responseType, logger) {
+  let fullResponse = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  if (!response || !response.data) {
+    return response;
+  }
+  loggerDebug(logger, `Normalizing Twitter API response (${responseType})`, {
+    beforeNormalization: JSON.stringify(response.data)
+  });
+
+  // Handle Twitter API v2 Direct Message responses
+  // v2 DM structure: { dm_event_id, dm_conversation_id }
+  // v1.1 expected structure: { id, author_id }
+  if (responseType === 'dm' && response.data.dm_event_id) {
+    const normalizedData = {
+      ...response.data,
+      // Add v1.1-compatible fields for backward compatibility
+      id: response.data.dm_event_id,
+      // Note: author_id is intentionally not set here. The caller (twitterApi.client.js)
+      // will set the correct author_id from the original document since dm_conversation_id
+      // doesn't reliably indicate the sender (it's just "user1-user2" format)
+      author_id: null
+    };
+    loggerInfo(logger, `Normalized Twitter API v2 DM response to v1.1 format`, {
+      dm_event_id: response.data.dm_event_id,
+      normalized_id: normalizedData.id,
+      dm_conversation_id: response.data.dm_conversation_id,
+      normalized_author_id: normalizedData.author_id
+    });
+    return {
+      ...response,
+      data: normalizedData
+    };
+  }
+
+  // Handle Twitter API v2 Tweet responses
+  // v2 has 'id' field but author_id is in expansions (includes.users)
+  if (responseType === 'tweet' && response.data.id) {
+    const normalizedData = {
+      ...response.data
+    };
+
+    // If author_id is missing but we have includes.users from expansions
+    if (!normalizedData.author_id && fullResponse?.includes?.users?.[0]?.id) {
+      normalizedData.author_id = fullResponse.includes.users[0].id;
+      loggerInfo(logger, `Added author_id to tweet response from expansions`, {
+        tweet_id: normalizedData.id,
+        author_id: normalizedData.author_id
+      });
+    } else if (normalizedData.author_id) {
+      loggerDebug(logger, `Twitter v2 tweet response already has 'author_id'`, {
+        id: response.data.id,
+        author_id: normalizedData.author_id
+      });
+    } else {
+      loggerWarn(logger, `Twitter v2 tweet response missing author_id and no expansions available`, {
+        id: response.data.id,
+        hasIncludes: !!fullResponse?.includes,
+        hasUsers: !!fullResponse?.includes?.users
+      });
+    }
+    return {
+      ...response,
+      data: normalizedData
+    };
+  }
+  return response;
+}
 async function publishTweet(token, payload, query, isDirectMessage, logger) {
   try {
     let nativeResponse = await postRequest({
@@ -498,12 +653,50 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
     loggerDebug(logger, `Twitter the data response is`, {
       response: JSON.stringify(response)
     });
-    return response;
+
+    // Normalize the response to ensure backward compatibility with v1.1 structure
+    // Pass full nativeResponse to extract author_id from expansions if needed
+    const normalizedResponse = normalizeTwitterResponse(response, 'tweet', logger, nativeResponse.data // Full response with includes.users for author_id
+    );
+    return normalizedResponse;
   } catch (err) {
     loggerError(logger, `Twitter publish exception details`, err);
     throw err;
   }
 }
+async function publishDirectMessage(token, payload, query, logger) {
+  try {
+    let nativeResponse = await postRequest({
+      token,
+      uri: query,
+      payload,
+      convertPayloadToUri: false,
+      attachUrlPrefix: false
+    });
+    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
+    };
+    loggerDebug(logger, `Twitter DM response is`, {
+      response: JSON.stringify(response)
+    });
+
+    // Normalize the response to ensure backward compatibility with v1.1 structure
+    // This is CRITICAL - v2 DM responses have dm_event_id instead of id
+    const normalizedResponse = normalizeTwitterResponse(response, 'dm', logger);
+    return normalizedResponse;
+  } catch (err) {
+    loggerError(logger, `Twitter DM exception details`, err);
+    throw err;
+  }
+}
 async function postRequest(_ref2) {
   let {
     token,
@@ -662,32 +855,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 Twit({
-      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.statSync(filePath);
+    const fileSize = fileStats.size;
+    const fileData = fs.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) {
+    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.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);
+    loggerDebug(logger, 'Media uploaded successfully (simple)', {
+      media_id: result.body.media_id_string
+    });
+    return result.body.media_id_string;
+  } catch (e) {
+    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;
+    loggerDebug(logger, 'Media upload INIT successful', {
+      mediaId
+    });
+
+    // Step 2: APPEND (upload in chunks)
+    const chunkSize = 5 * 1024 * 1024; // 5MB chunks
+    const fileBuffer = fs.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);
+      loggerDebug(logger, `Media chunk ${segmentIndex} uploaded`, {
+        mediaId,
+        segmentIndex
       });
-    } catch (e) {
-      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);
+    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) {
+    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.post(url).set('Authorization', Authorization).send(params);
+    return result.body;
+  } catch (e) {
+    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') {
+      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;
+    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 {
@@ -699,5 +1037,4 @@ function removeMedia(file, logger) {
   } catch (e) {
     loggerError(logger, `failed trying to remove media ${file} it may have already been removed`);
   }
-}
-;
+}