@meltwater/conversations-api-services 1.1.24 → 1.2.2

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

@@ -1,11 +1,15 @@
 import superagent from 'superagent';
 import { removePrefix } from '../../lib/externalId.helpers.js';
-import { loggerDebug, loggerError, loggerInfo, loggerWarn } from '../../lib/logger.helpers.js';
+import {
+    loggerDebug,
+    loggerError,
+    loggerInfo,
+    loggerWarn,
+} from '../../lib/logger.helpers.js';
 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: {
@@ -13,74 +17,104 @@ const TWITTER_API_CONFIG = {
     },
     v2: {
         base_url: 'https://api.x.com/2',
-        default_user_fields: 'id,name,username,profile_image_url,public_metrics,description,created_at,verified,protected'
-    }
+        default_user_fields:
+            'id,name,username,profile_image_url,public_metrics,description,created_at,verified,protected',
+    },
 };
 
 // Helper function to create v2 API URLs with consistent field selection
 function createTwitterV2Url(endpoint, additionalParams = {}) {
     const baseUrl = `${TWITTER_API_CONFIG.v2.base_url}/${endpoint}`;
-    const defaultFields = { 'user.fields': TWITTER_API_CONFIG.v2.default_user_fields };
+    const defaultFields = {
+        'user.fields': TWITTER_API_CONFIG.v2.default_user_fields,
+    };
     const allParams = { ...defaultFields, ...additionalParams };
-    
+
     const queryString = Object.entries(allParams)
-        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .map(
+            ([key, value]) =>
+                `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+        )
         .join('&');
-    
+
     return queryString ? `${baseUrl}?${queryString}` : baseUrl;
 }
 
 // Helper function to make v2 API requests with fallback to v1.1
-async function makeTwitterV2Request(v2Endpoint, v1FallbackQuery, token, logger, requestOptions = {}) {
+async function makeTwitterV2Request(
+    v2Endpoint,
+    v1FallbackQuery,
+    token,
+    logger,
+    requestOptions = {}
+) {
     // Try v2 API first - it supports OAuth 1.0a for user lookup endpoints and has better rate limits!
     try {
         const v2Url = createTwitterV2Url(v2Endpoint, requestOptions.v2Params);
-        
+
         const result = await getRequest({
             token,
             uri: v2Url,
             attachUrlPrefix: false,
             convertPayloadToUri: false,
-            logger
+            logger,
         });
         return { success: true, data: result.data?.data, source: 'v2' };
     } catch (e) {
-        loggerWarn(logger, `Twitter API v2 request failed for ${v2Endpoint}, falling back to v1.1`, e);
-        
+        loggerWarn(
+            logger,
+            `Twitter API v2 request failed for ${v2Endpoint}, falling back to v1.1`,
+            e
+        );
+
         // Fallback to v1.1 if v2 fails
         if (v1FallbackQuery && requestOptions.enableFallback !== false) {
             try {
-                loggerInfo(logger, `Falling back to v1.1 API for ${v2Endpoint}`);
-                const fallbackResult = await (requestOptions.fallbackMethod === 'post' ? postRequest : getRequest)({
+                loggerInfo(
+                    logger,
+                    `Falling back to v1.1 API for ${v2Endpoint}`
+                );
+                const fallbackResult = await (requestOptions.fallbackMethod ===
+                    'post'
+                    ? postRequest
+                    : getRequest)({
                     token,
                     uri: v1FallbackQuery,
-                    logger
+                    logger,
                 });
-                return { success: true, data: fallbackResult.data, source: 'v1.1' };
+                return {
+                    success: true,
+                    data: fallbackResult.data,
+                    source: 'v1.1',
+                };
             } catch (fallbackError) {
-                loggerError(logger, `Both v2 and v1.1 APIs failed for ${v2Endpoint}`, fallbackError);
+                loggerError(
+                    logger,
+                    `Both v2 and v1.1 APIs failed for ${v2Endpoint}`,
+                    fallbackError
+                );
             }
         }
-        
+
         return { success: false, error: e, source: 'failed' };
     }
 }
 
 function normalizeUserData(user, apiVersion = 'v1.1') {
     if (!user) return user;
-    
+
     const normalized = { ...user };
-    
+
     if (apiVersion === 'v2') {
         normalized.screen_name = user.username;
-        normalized.id_str = user.id; 
-        normalized.profile_image_url_https = user.profile_image_url; 
+        normalized.id_str = user.id;
+        normalized.profile_image_url_https = user.profile_image_url;
     } else {
         normalized.username = user.screen_name;
         normalized.id = user.id_str;
         normalized.profile_image_url = user.profile_image_url_https;
     }
-    
+
     return normalized;
 }
 
@@ -92,18 +126,42 @@ function normalizeUserData(user, apiVersion = 'v1.1') {
  */
 function normalizeUsersData(users, apiVersion = 'v1.1') {
     if (!users) return users;
-    
+
     if (Array.isArray(users)) {
-        return users.map(user => normalizeUserData(user, apiVersion));
+        return users.map((user) => normalizeUserData(user, apiVersion));
     }
-    
+
     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){
+export function addOAuthToToken(
+    token,
+    TWITTER_CONSUMER_KEY,
+    TWITTER_CONSUMER_SECRET
+) {
+    if (!token.oauth) {
         token.oauth = OAuth({
             consumer: {
                 key: TWITTER_CONSUMER_KEY,
@@ -120,17 +178,20 @@ export function addOAuthToToken(token, TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SE
         token.consumer_key = TWITTER_CONSUMER_KEY;
         token.consumer_secret = TWITTER_CONSUMER_SECRET;
     }
-    return token
+    return token;
 }
 
 export async function getUserInfoFromHandles(token, handles, logger) {
     try {
         const handlesJoin = handles.join(',');
-        if(!handlesJoin.length){
-            loggerWarn(logger,`No handles provided to twitterNative getUserInfoFromHandles`);
+        if (!handlesJoin.length) {
+            loggerWarn(
+                logger,
+                `No handles provided to twitterNative getUserInfoFromHandles`
+            );
             return [];
         }
-        
+
         // Use Twitter API v2 for much better rate limits (900 req/15min vs v1.1 limits)
         // v2 API supports up to 100 usernames per request vs v1.1's limit
         const result = await makeTwitterV2Request(
@@ -140,10 +201,10 @@ export async function getUserInfoFromHandles(token, handles, logger) {
             logger,
             {
                 v2Params: { usernames: handlesJoin },
-                fallbackMethod: 'post'
+                fallbackMethod: 'post',
             }
         );
-        
+
         const normalizedData = normalizeUsersData(result.data, result.source);
         return normalizedData || [];
     } catch (e) {
@@ -155,7 +216,12 @@ export async function getUserInfoFromHandles(token, handles, logger) {
 export async function getUserInfoFromHandle(token, handleId, logger) {
     try {
         if (!handleId) {
-            loggerWarn(logger, `Invalid handleId provided to getUserInfoFromHandle: ${JSON.stringify(handleId)}`);
+            loggerWarn(
+                logger,
+                `Invalid handleId provided to getUserInfoFromHandle: ${JSON.stringify(
+                    handleId
+                )}`
+            );
             throw new Error(`Invalid handleId: ${handleId}`);
         }
         // Use Twitter API v2 for much better rate limits (900 req/15min vs v1.1 limits)
@@ -165,15 +231,24 @@ export async function getUserInfoFromHandle(token, handleId, logger) {
             token,
             logger
         );
-        
+
         if (result.success) {
             // Normalize the user data to ensure both screen_name and username are present
             return normalizeUserData(result.data, result.source);
         } else {
-            throw result.error || new Error('Failed to get user info from both APIs');
+            throw (
+                result.error ||
+                new Error('Failed to get user info from both APIs')
+            );
         }
     } catch (e) {
-        loggerError(logger, `Error in getUserInfoFromHandle with handleId: ${JSON.stringify(handleId)}`, e);
+        loggerError(
+            logger,
+            `Error in getUserInfoFromHandle with handleId: ${JSON.stringify(
+                handleId
+            )}`,
+            e
+        );
     }
 }
 
@@ -190,7 +265,7 @@ export async function getDirectMessageImage(token, imageUrl, logger) {
             contentType: result.contentType,
         };
     } catch (e) {
-        loggerError(logger,`Error getting image`, e);
+        loggerError(logger, `Error getting image`, e);
         throw e;
     }
 }
@@ -209,11 +284,11 @@ 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) {
-        loggerDebug(logger,'Error in twitter getCurrentInfo', error);
+        loggerDebug(logger, 'Error in twitter getCurrentInfo', error);
     }
 }
 
@@ -231,7 +306,7 @@ export async function getMentionHandleInfo(token, externalId, logger) {
         });
         return result.data;
     } catch (error) {
-        loggerDebug(logger,'Error in twitter getMentionHandleInfo', error);
+        loggerDebug(logger, 'Error in twitter getMentionHandleInfo', error);
     }
 }
 
@@ -245,7 +320,7 @@ export async function retweet(token, sourceId, externalId, logger) {
             payload: { tweet_id: removePrefix(externalId) },
             attachUrlPrefix: false,
             convertPayloadToUri: false,
-            logger
+            logger,
         });
 
         if (
@@ -257,7 +332,7 @@ export async function retweet(token, sourceId, externalId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger,`Error in retweet user: ${sourceId}`, error);
+        loggerDebug(logger, `Error in retweet user: ${sourceId}`, error);
     }
 }
 
@@ -268,7 +343,7 @@ export async function unRetweet(token, sourceId, externalId, logger) {
             uri: `https://api.twitter.com/2/users/${sourceId}/retweets/${removePrefix(
                 externalId
             )}`,
-            logger
+            logger,
         });
 
         if (
@@ -280,47 +355,68 @@ export async function unRetweet(token, sourceId, externalId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger,`Error in unretweet user: ${sourceId}`, error, {
+        loggerDebug(logger, `Error in unretweet user: ${sourceId}`, error, {
             [MeltwaterAttributes.SOCIALEXTERNALID]: externalId,
         });
     }
 }
 
-export async function like(token,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.data.data?.liked !== undefined &&
             response.resp.statusCode === 200
         ) {
             return true;
         } else {
-            loggerInfo(logger,'Twitter Error in like user statusCode non 200 ', {
-                response: JSON.stringify(response),
-            });
+            loggerInfo(
+                logger,
+                'Twitter Error in like user statusCode non 200 ',
+                {
+                    response: JSON.stringify(response),
+                }
+            );
             return false;
         }
     } catch (error) {
-        loggerDebug(logger,`Twitter Error in like user: ${externalId}`, error);
+        loggerDebug(logger, `Twitter Error in like user: ${externalId}`, error);
         throw error;
     }
 }
 
 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.data.data?.liked !== undefined &&
             response.resp.statusCode === 200
         ) {
             return true;
@@ -328,84 +424,102 @@ export async function unLike(token, externalId, logger) {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger,`Error in unlike user: ${externalId}`, error);
+        loggerDebug(logger, `Error in unlike user: ${externalId}`, error);
         throw error;
     }
 }
 
 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),
             },
-            logger
+            attachUrlPrefix: false,
+            convertPayloadToUri: false,
+            logger,
         });
 
-        if (response.data.following !== undefined) {
+        if (response.data.data?.following !== undefined) {
             return true;
         } else {
             return false;
         }
     } catch (error) {
-        loggerDebug(logger,`Error in following user: ${profileId}`, error);
+        loggerDebug(logger, `Error in following user: ${profileId}`, error);
     }
 }
 
 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),
-            },
-            logger
+            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;
         }
     } catch (error) {
-        loggerDebug(logger,`Error in unfollowing user: ${profileId}`, error);
+        loggerDebug(logger, `Error in unfollowing user: ${profileId}`, error);
     }
 }
 
 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
             },
-            logger
+            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;
-                    }
-                }
+        if (response.data?.data) {
+            // Check if the profileId is in the following list
+            const isFollowing = response.data.data.some(
+                (user) => user.id === removePrefix(profileId)
+            );
 
-                return false;
-            } else {
-                return false;
+            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,
+        loggerDebug(
+            logger,
             `Error in getting user follow status: ${profileId}`,
             error
         );
@@ -419,27 +533,90 @@ export async function userFollowStatus(token, profileId, logger) {
     }
 }
 
-export async function getBrandUserRelationship(token, profileId, brandProfileId, 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,
-        });
+        // 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);
+        }
 
-        return relationship;
+        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,
+        loggerDebug(
+            logger,
             `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`,
             error
         );
     }
 }
 
-export async function reply(token, text, attachment, inReplyToId, removeInReplyToId, logger){
-
+export async function reply(
+    token,
+    text,
+    attachment,
+    inReplyToId,
+    removeInReplyToId,
+    logger
+) {
     let mediaId;
     if (attachment) {
         // discussionType only matters if DM or Not
@@ -456,50 +633,48 @@ export async function reply(token, text, attachment, inReplyToId, removeInReplyT
             in_reply_to_tweet_id: removePrefix(inReplyToId),
         },
     };
-    if (removeInReplyToId.length){
+    if (removeInReplyToId.length) {
         const filteredIds = removeInReplyToId
             .map(removePrefix)
-            .filter(id => id && id.trim().length > 0);
+            .filter((id) => id && id.trim().length > 0);
         if (filteredIds.length > 0) {
             payload.reply.exclude_reply_user_ids = filteredIds;
         }
     }
 
     let query = 'https://api.twitter.com/2/tweets';
-    return publishTweet(token,payload,query, false,logger);
+    return publishTweet(token, payload, query, false, logger);
 }
 
-export async function privateMessage(token, text, attachment, profileId,logger){
-    let query = 'direct_messages/events/new.json';
+export async function privateMessage(
+    token,
+    text,
+    attachment,
+    profileId,
+    logger
+) {
+    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){
-
+export async function retweetWithComment(token, text, attachment, logger) {
     let mediaId;
     if (attachment) {
         // discussionType only matters if DM or Not
@@ -515,7 +690,112 @@ export async function retweetWithComment(token, text, attachment,logger){
     };
 
     let query = 'https://api.twitter.com/2/tweets';
-    return publishTweet(token,payload,query, false,logger);
+    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,
+    fullResponse = 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) {
@@ -528,10 +808,7 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
             attachUrlPrefix: isDirectMessage,
         });
 
-        if (
-            !isDirectMessage &&
-            nativeResponse.resp.statusCode === 201
-        ) {
+        if (!isDirectMessage && nativeResponse.resp.statusCode === 201) {
             const uri = `https://api.twitter.com/2/tweets?ids=${nativeResponse.data.data.id}&tweet.fields=public_metrics&expansions=author_id`;
 
             nativeResponse = await getRequest({
@@ -540,14 +817,13 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
                 payload,
                 attachUrlPrefix: false,
                 convertPayloadToUri: false,
-                logger
+                logger,
             });
         }
 
-        loggerInfo(logger,
-            `finished fetching twitterAPI nativeResponse `,
-            { data: JSON.stringify(nativeResponse.data) }
-        );
+        loggerInfo(logger, `finished fetching twitterAPI nativeResponse `, {
+            data: JSON.stringify(nativeResponse.data),
+        });
 
         const response = nativeResponse.resp
             ? {
@@ -564,19 +840,74 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
                   statusCode: nativeResponse.statusCode,
                   statusMessage: nativeResponse.message,
               };
-        loggerDebug(logger,`Twitter the data response is`, {
+
+        loggerDebug(logger, `Twitter the data response is`, {
             response: JSON.stringify(response),
         });
-        return response;
-    } catch (err) {
-        loggerError(logger,
-            `Twitter publish exception details`,
-            err
+
+        // 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({
     token,
@@ -584,7 +915,7 @@ async function postRequest({
     payload,
     attachUrlPrefix = true,
     convertPayloadToUri = true,
-    logger
+    logger,
 }) {
     return doRequest({
         requestMethod: 'post',
@@ -593,7 +924,7 @@ async function postRequest({
         payload,
         uri,
         attachUrlPrefix,
-        logger
+        logger,
     });
 }
 
@@ -603,7 +934,7 @@ async function getRequest({
     payload,
     attachUrlPrefix = true,
     convertPayloadToUri = true,
-    logger
+    logger,
 }) {
     return doRequest({
         requestMethod: 'get',
@@ -612,7 +943,7 @@ async function getRequest({
         uri,
         attachUrlPrefix,
         convertPayloadToUri,
-        logger
+        logger,
     });
 }
 
@@ -622,7 +953,7 @@ async function deleteRequest({
     payload,
     attachUrlPrefix = false,
     convertPayloadToUri = false,
-    logger
+    logger,
 }) {
     return doRequest({
         requestMethod: 'delete',
@@ -631,7 +962,7 @@ async function deleteRequest({
         payload,
         uri,
         attachUrlPrefix,
-        logger
+        logger,
     });
 }
 
@@ -648,7 +979,7 @@ async function doRequest({
     payload,
     attachUrlPrefix = true,
     convertPayloadToUri = true,
-    logger
+    logger,
 }) {
     if (payload && convertPayloadToUri) {
         uri =
@@ -687,12 +1018,10 @@ async function doRequest({
                       .post(url)
                       .set('Authorization', Authorization)
                       .send(
-                          payload && !convertPayloadToUri
-                              ? payload
-                              : undefined
+                          payload && !convertPayloadToUri ? payload : undefined
                       )
                 : superagent.del(url).set('Authorization', Authorization));
-            loggerDebug(logger,'Twitter Native Response ', {
+            loggerDebug(logger, 'Twitter Native Response ', {
                 native: {
                     //data: result.body,
                     contentType: result.headers['content-type'],
@@ -708,15 +1037,19 @@ async function doRequest({
                 resp: { ...result },
             });
         } catch (e) {
-            if(e.response.status == 503){
-                loggerWarn(logger,`Twitter API 503 error - Service Unavailable`,{
-                    url,
-                    convertPayloadToUri,
-                    payload: JSON.stringify(payload),
-                });
+            if (e.response.status == 503) {
+                loggerWarn(
+                    logger,
+                    `Twitter API 503 error - Service Unavailable`,
+                    {
+                        url,
+                        convertPayloadToUri,
+                        payload: JSON.stringify(payload),
+                    }
+                );
                 return reject(e);
             }
-            loggerError(logger,`Error in twitter doRequest`, e, {
+            loggerError(logger, `Error in twitter doRequest`, e, {
                 url,
                 convertPayloadToUri,
                 payload: JSON.stringify(payload),
@@ -726,7 +1059,7 @@ async function doRequest({
     });
 }
 
-    // local
+// local
 async function downloadImage(url, fileName) {
     const writer = fs.createWriteStream(fileName);
     const response = await axios({
@@ -744,7 +1077,7 @@ async function downloadImage(url, fileName) {
     });
 }
 
-    // local
+// local
 function generateFilePath(mimeType, dirname) {
     let dir = `${dirname}/temporaryTwitterMedia`;
     if (!fs.existsSync(dir)) {
@@ -757,49 +1090,269 @@ function generateFilePath(mimeType, dirname) {
     }
     return `${dir}/${randomFileName}.${fileExtension}`;
 }
-    // local
+// 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,
-        });
-        let mediaCategory = discussionType === 'dm' ? 'dm' : 'tweet';
-        
-        try {
-            T.postMediaChunked(
-                { file_path: filePath },
+
+        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,
-                function (err, data, response) {
-                    if (err) {
-                        reject(err);
-                    }
-                    resolve(data.media_id_string);
-                    removeMedia(filePath, logger);
-                }
+                token,
+                logger
             );
-        } catch (e) {
-            loggerError(logger,`Failed posting media`, e);
-            // this is just a safety precaution
             removeMedia(filePath, logger);
+            return mediaIdString;
         }
-    });
+    } catch (e) {
+        loggerError(logger, `Failed uploading media`, e);
+        if (filePath) {
+            removeMedia(filePath, logger);
+        }
+        throw e;
+    }
 }
 
-function removeMedia(file, logger){
+// 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,
+            });
+
+        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,
+            });
+
+            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,
+    maxAttempts = 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 {
         fs.unlink(file, function (err) {
             if (err) {
-                loggerError(logger,`Failed removing ${file}`, err);
+                loggerError(logger, `Failed removing ${file}`, err);
             }
         });
     } catch (e) {
-        loggerError(logger,
+        loggerError(
+            logger,
             `failed trying to remove media ${file} it may have already been removed`
         );
     }
-};
+}