@meltwater/conversations-api-services 1.2.1 → 1.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 Repository to contain all conversations api services shared across our services.
 
-## Maintainers
+## Maintainers.
 
 > Maintained by Phoenix (phoenix@meltwater.com).
 > Contact us via #eng-team-phoenix in Slack.

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.addOAuthToToken = addOAuthToToken;
+exports.createTweet = createTweet;
 exports.followUser = followUser;
 exports.getAuthenticatedUser = getAuthenticatedUser;
 exports.getBrandUserRelationship = getBrandUserRelationship;
@@ -505,6 +506,23 @@ async function getBrandUserRelationship(token, profileId, brandProfileId, logger
     (0, _loggerHelpers.loggerDebug)(logger, `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`, error);
   }
 }
+async function createTweet(token, text, attachment, logger) {
+  let mediaId;
+  if (attachment) {
+    // Upload media for regular tweets (not DM, so use 'og' but will map to tweet_image/video/gif)
+    mediaId = await uploadMedia(attachment, token, 'og', logger);
+  }
+  const payload = {
+    text,
+    ...(attachment && {
+      media: {
+        media_ids: [mediaId]
+      }
+    })
+  };
+  let query = 'https://api.twitter.com/2/tweets';
+  return publishTweet(token, payload, query, false, logger);
+}
 async function reply(token, text, attachment, inReplyToId, removeInReplyToId, logger) {
   let mediaId;
   if (attachment) {
@@ -535,8 +553,16 @@ async function privateMessage(token, text, attachment, profileId, logger) {
   let query = `https://api.x.com/2/dm_conversations/with/${(0, _externalIdHelpers.removePrefix)(profileId)}/messages`;
   let mediaId;
   if (attachment) {
+    (0, _loggerHelpers.loggerDebug)(logger, 'Uploading media for DM', {
+      attachmentUrl: attachment.url,
+      attachmentMimeType: attachment.mimeType
+    });
     // discussionType only matters if DM or Not
     mediaId = await uploadMedia(attachment, token, 'dm', logger);
+    (0, _loggerHelpers.loggerInfo)(logger, 'Media uploaded for DM', {
+      mediaId,
+      mediaIdType: typeof mediaId
+    });
   }
   const payload = {
     text: text || ' ',
@@ -546,6 +572,11 @@ async function privateMessage(token, text, attachment, profileId, logger) {
       }]
     })
   };
+  (0, _loggerHelpers.loggerDebug)(logger, 'Sending DM with payload', {
+    query,
+    payload: JSON.stringify(payload),
+    hasAttachment: !!attachment
+  });
   return publishDirectMessage(token, payload, query, logger);
 }
 async function retweetWithComment(token, text, attachment, logger) {
@@ -565,6 +596,84 @@ 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;
+  }
+  (0, _loggerHelpers.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
+    };
+    (0, _loggerHelpers.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;
+      (0, _loggerHelpers.loggerInfo)(logger, `Added author_id to tweet response from expansions`, {
+        tweet_id: normalizedData.id,
+        author_id: normalizedData.author_id
+      });
+    } else if (normalizedData.author_id) {
+      (0, _loggerHelpers.loggerDebug)(logger, `Twitter v2 tweet response already has 'author_id'`, {
+        id: response.data.id,
+        author_id: normalizedData.author_id
+      });
+    } else {
+      (0, _loggerHelpers.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({
@@ -599,7 +708,12 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
     (0, _loggerHelpers.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) {
     (0, _loggerHelpers.loggerError)(logger, `Twitter publish exception details`, err);
     throw err;
@@ -628,9 +742,13 @@ async function publishDirectMessage(token, payload, query, logger) {
     (0, _loggerHelpers.loggerDebug)(logger, `Twitter DM response is`, {
       response: JSON.stringify(response)
     });
-    return 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) {
-    (0, _loggerHelpers.loggerError)(logger, `Twitter DM exception details`, err);
+    (0, _loggerHelpers.loggerError)(logger, `Twitter DM send failed`, err);
     throw err;
   }
 }
@@ -796,7 +914,17 @@ async function uploadMedia(attachment, token, discussionType, logger) {
   try {
     filePath = generateFilePath(attachment.mimeType, attachment.__dirname);
     await downloadImage(attachment.url, filePath);
-    const mediaCategory = discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+
+    // Determine media category based on mime type and discussion type
+    const mimeType = attachment.mimeType.toLowerCase();
+    let mediaCategory;
+    if (mimeType.startsWith('video/')) {
+      mediaCategory = discussionType === 'dm' ? 'dm_video' : 'tweet_video';
+    } else if (mimeType === 'image/gif') {
+      mediaCategory = discussionType === 'dm' ? 'dm_gif' : 'tweet_gif';
+    } else {
+      mediaCategory = discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+    }
     const fileStats = _fs.default.statSync(filePath);
     const fileSize = fileStats.size;
     const fileData = _fs.default.readFileSync(filePath);
@@ -804,7 +932,7 @@ async function uploadMedia(attachment, token, discussionType, logger) {
     // For small files, use simple upload
     if (fileSize < 5000000) {
       // 5MB
-      const mediaIdString = await simpleMediaUpload(fileData, attachment.mimeType, token, logger);
+      const mediaIdString = await simpleMediaUpload(fileData, attachment.mimeType, mediaCategory, token, logger);
       removeMedia(filePath, logger);
       return mediaIdString;
     } else {
@@ -823,12 +951,14 @@ async function uploadMedia(attachment, token, discussionType, logger) {
 }
 
 // Simple upload for small media files
-async function simpleMediaUpload(fileData, mimeType, token, logger) {
+async function simpleMediaUpload(fileData, mimeType, mediaCategory, 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';
+
+    // Original working code: empty OAuth signature, let superagent handle content-type
     const {
       Authorization
     } = token.oauth.toHeader(token.oauth.authorize({
@@ -839,10 +969,9 @@ async function simpleMediaUpload(fileData, mimeType, token, logger) {
       key: token.token,
       secret: token.tokenSecret
     }));
-    const result = await _superagent.default.post(url).set('Authorization', Authorization).send({
-      media_data: base64Data,
-      media_type: mimeType
-    });
+
+    // Use .field() for multipart/form-data (OAuth ignores multipart body)
+    const result = await _superagent.default.post(url).set('Authorization', Authorization).field('media_data', base64Data).field('media_type', mimeType);
     (0, _loggerHelpers.loggerDebug)(logger, 'Media uploaded successfully (simple)', {
       media_id: result.body.media_id_string
     });
@@ -913,18 +1042,47 @@ async function chunkedMediaUpload(filePath, fileSize, mimeType, mediaCategory, t
 // Make a media upload request
 async function mediaUploadRequest(params, token, logger) {
   const url = 'https://upload.twitter.com/1.1/media/upload.json';
+
+  // Separate query params from body params
+  // Query params (everything except media_data) must be in OAuth signature
+  const queryParams = {};
+  const bodyParams = {};
+  for (const key in params) {
+    if (key === 'media_data') {
+      // media_data goes in POST body only
+      bodyParams[key] = params[key];
+    } else {
+      // All other params go in query string and OAuth signature
+      queryParams[key] = String(params[key]);
+    }
+  }
+
+  // Build full URL with query params
+  const queryString = Object.keys(queryParams).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(queryParams[key])}`).join('&');
+  const fullUrl = queryString ? `${url}?${queryString}` : url;
+
+  // OAuth signature: base URL + query params in data field
   const {
     Authorization
   } = token.oauth.toHeader(token.oauth.authorize({
-    url,
+    url: url,
+    // Base URL only
     method: 'post',
-    data: {}
+    data: queryParams // Query params go here for signature
   }, {
     key: token.token,
     secret: token.tokenSecret
   }));
   try {
-    const result = await _superagent.default.post(url).set('Authorization', Authorization).send(params);
+    // Don't set content-type, let superagent handle it
+    // For commands with media_data, it will use application/x-www-form-urlencoded
+    const request = _superagent.default.post(fullUrl).set('Authorization', Authorization);
+
+    // Only set type if we have body params
+    if (Object.keys(bodyParams).length > 0) {
+      request.type('form').send(bodyParams);
+    }
+    const result = await request;
     return result.body;
   } catch (e) {
     (0, _loggerHelpers.loggerError)(logger, `Media upload request failed for command: ${params.command}`, e);

package/dist/cjs/data-access/index.js

@@ -31,8 +31,7 @@ var TwitterNative = _interopRequireWildcard(require("./http/twitter.native.js"))
 var InstagramNative = _interopRequireWildcard(require("./http/instagram.native.js"));
 var ThreadsNative = _interopRequireWildcard(require("./http/threads.native.js"));
 var AssetManagerClient = _interopRequireWildcard(require("./http/assetManager.client.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const DocumentHelperFunctions = {
   ...messageHelpers,
   ...applicationTagFunctions,

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

@@ -481,6 +481,23 @@ export async function getBrandUserRelationship(token, profileId, brandProfileId,
     loggerDebug(logger, `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`, error);
   }
 }
+export async function createTweet(token, text, attachment, logger) {
+  let mediaId;
+  if (attachment) {
+    // Upload media for regular tweets (not DM, so use 'og' but will map to tweet_image/video/gif)
+    mediaId = await uploadMedia(attachment, token, 'og', logger);
+  }
+  const payload = {
+    text,
+    ...(attachment && {
+      media: {
+        media_ids: [mediaId]
+      }
+    })
+  };
+  let query = 'https://api.twitter.com/2/tweets';
+  return publishTweet(token, payload, query, false, logger);
+}
 export async function reply(token, text, attachment, inReplyToId, removeInReplyToId, logger) {
   let mediaId;
   if (attachment) {
@@ -511,8 +528,16 @@ 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) {
+    loggerDebug(logger, 'Uploading media for DM', {
+      attachmentUrl: attachment.url,
+      attachmentMimeType: attachment.mimeType
+    });
     // discussionType only matters if DM or Not
     mediaId = await uploadMedia(attachment, token, 'dm', logger);
+    loggerInfo(logger, 'Media uploaded for DM', {
+      mediaId,
+      mediaIdType: typeof mediaId
+    });
   }
   const payload = {
     text: text || ' ',
@@ -522,6 +547,11 @@ export async function privateMessage(token, text, attachment, profileId, logger)
       }]
     })
   };
+  loggerDebug(logger, 'Sending DM with payload', {
+    query,
+    payload: JSON.stringify(payload),
+    hasAttachment: !!attachment
+  });
   return publishDirectMessage(token, payload, query, logger);
 }
 export async function retweetWithComment(token, text, attachment, logger) {
@@ -541,6 +571,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({
@@ -575,7 +683,12 @@ 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;
@@ -604,9 +717,13 @@ async function publishDirectMessage(token, payload, query, logger) {
     loggerDebug(logger, `Twitter DM response is`, {
       response: JSON.stringify(response)
     });
-    return 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);
+    loggerError(logger, `Twitter DM send failed`, err);
     throw err;
   }
 }
@@ -772,7 +889,17 @@ async function uploadMedia(attachment, token, discussionType, logger) {
   try {
     filePath = generateFilePath(attachment.mimeType, attachment.__dirname);
     await downloadImage(attachment.url, filePath);
-    const mediaCategory = discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+
+    // Determine media category based on mime type and discussion type
+    const mimeType = attachment.mimeType.toLowerCase();
+    let mediaCategory;
+    if (mimeType.startsWith('video/')) {
+      mediaCategory = discussionType === 'dm' ? 'dm_video' : 'tweet_video';
+    } else if (mimeType === 'image/gif') {
+      mediaCategory = discussionType === 'dm' ? 'dm_gif' : 'tweet_gif';
+    } else {
+      mediaCategory = discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+    }
     const fileStats = fs.statSync(filePath);
     const fileSize = fileStats.size;
     const fileData = fs.readFileSync(filePath);
@@ -780,7 +907,7 @@ async function uploadMedia(attachment, token, discussionType, logger) {
     // For small files, use simple upload
     if (fileSize < 5000000) {
       // 5MB
-      const mediaIdString = await simpleMediaUpload(fileData, attachment.mimeType, token, logger);
+      const mediaIdString = await simpleMediaUpload(fileData, attachment.mimeType, mediaCategory, token, logger);
       removeMedia(filePath, logger);
       return mediaIdString;
     } else {
@@ -799,12 +926,14 @@ async function uploadMedia(attachment, token, discussionType, logger) {
 }
 
 // Simple upload for small media files
-async function simpleMediaUpload(fileData, mimeType, token, logger) {
+async function simpleMediaUpload(fileData, mimeType, mediaCategory, 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';
+
+    // Original working code: empty OAuth signature, let superagent handle content-type
     const {
       Authorization
     } = token.oauth.toHeader(token.oauth.authorize({
@@ -815,10 +944,9 @@ async function simpleMediaUpload(fileData, mimeType, token, logger) {
       key: token.token,
       secret: token.tokenSecret
     }));
-    const result = await superagent.post(url).set('Authorization', Authorization).send({
-      media_data: base64Data,
-      media_type: mimeType
-    });
+
+    // Use .field() for multipart/form-data (OAuth ignores multipart body)
+    const result = await superagent.post(url).set('Authorization', Authorization).field('media_data', base64Data).field('media_type', mimeType);
     loggerDebug(logger, 'Media uploaded successfully (simple)', {
       media_id: result.body.media_id_string
     });
@@ -889,18 +1017,47 @@ async function chunkedMediaUpload(filePath, fileSize, mimeType, mediaCategory, t
 // Make a media upload request
 async function mediaUploadRequest(params, token, logger) {
   const url = 'https://upload.twitter.com/1.1/media/upload.json';
+
+  // Separate query params from body params
+  // Query params (everything except media_data) must be in OAuth signature
+  const queryParams = {};
+  const bodyParams = {};
+  for (const key in params) {
+    if (key === 'media_data') {
+      // media_data goes in POST body only
+      bodyParams[key] = params[key];
+    } else {
+      // All other params go in query string and OAuth signature
+      queryParams[key] = String(params[key]);
+    }
+  }
+
+  // Build full URL with query params
+  const queryString = Object.keys(queryParams).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(queryParams[key])}`).join('&');
+  const fullUrl = queryString ? `${url}?${queryString}` : url;
+
+  // OAuth signature: base URL + query params in data field
   const {
     Authorization
   } = token.oauth.toHeader(token.oauth.authorize({
-    url,
+    url: url,
+    // Base URL only
     method: 'post',
-    data: {}
+    data: queryParams // Query params go here for signature
   }, {
     key: token.token,
     secret: token.tokenSecret
   }));
   try {
-    const result = await superagent.post(url).set('Authorization', Authorization).send(params);
+    // Don't set content-type, let superagent handle it
+    // For commands with media_data, it will use application/x-www-form-urlencoded
+    const request = superagent.post(fullUrl).set('Authorization', Authorization);
+
+    // Only set type if we have body params
+    if (Object.keys(bodyParams).length > 0) {
+      request.type('form').send(bodyParams);
+    }
+    const result = await request;
     return result.body;
   } catch (e) {
     loggerError(logger, `Media upload request failed for command: ${params.command}`, e);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meltwater/conversations-api-services",
-    "version": "1.2.1",
+    "version": "1.3.1",
     "description": "Repository to contain all conversations api services shared across our services",
     "main": "dist/cjs/data-access/index.js",
     "module": "dist/esm/data-access/index.js",
@@ -28,10 +28,6 @@
     "keywords": [],
     "author": "",
     "license": "ISC",
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org/",
-        "access": "public"
-    },
     "bugs": {
         "url": "https://github.com/meltwater/conversations-api-services/issues"
     },

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

@@ -609,6 +609,25 @@ export async function getBrandUserRelationship(
     }
 }
 
+export async function createTweet(token, text, attachment, logger) {
+    let mediaId;
+    if (attachment) {
+        // Upload media for regular tweets (not DM, so use 'og' but will map to tweet_image/video/gif)
+        mediaId = await uploadMedia(attachment, token, 'og', logger);
+    }
+    const payload = {
+        text,
+        ...(attachment && {
+            media: {
+                media_ids: [mediaId],
+            },
+        }),
+    };
+
+    let query = 'https://api.twitter.com/2/tweets';
+    return publishTweet(token, payload, query, false, logger);
+}
+
 export async function reply(
     token,
     text,
@@ -658,8 +677,16 @@ export async function privateMessage(
     )}/messages`;
     let mediaId;
     if (attachment) {
+        loggerDebug(logger, 'Uploading media for DM', {
+            attachmentUrl: attachment.url,
+            attachmentMimeType: attachment.mimeType,
+        });
         // discussionType only matters if DM or Not
         mediaId = await uploadMedia(attachment, token, 'dm', logger);
+        loggerInfo(logger, 'Media uploaded for DM', {
+            mediaId,
+            mediaIdType: typeof mediaId,
+        });
     }
     const payload = {
         text: text || ' ',
@@ -671,6 +698,11 @@ export async function privateMessage(
             ],
         }),
     };
+    loggerDebug(logger, 'Sending DM with payload', {
+        query,
+        payload: JSON.stringify(payload),
+        hasAttachment: !!attachment,
+    });
     return publishDirectMessage(token, payload, query, logger);
 }
 
@@ -693,6 +725,111 @@ export async function retweetWithComment(token, text, attachment, 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) {
     try {
         let nativeResponse = await postRequest({
@@ -735,10 +872,21 @@ async function publishTweet(token, payload, query, isDirectMessage, logger) {
                   statusCode: nativeResponse.statusCode,
                   statusMessage: nativeResponse.message,
               };
+
         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;
@@ -773,12 +921,22 @@ async function publishDirectMessage(token, payload, query, logger) {
                   statusCode: nativeResponse.statusCode,
                   statusMessage: nativeResponse.message,
               };
+
         loggerDebug(logger, `Twitter DM response is`, {
             response: JSON.stringify(response),
         });
-        return 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);
+        loggerError(logger, `Twitter DM send failed`, err);
         throw err;
     }
 }
@@ -971,8 +1129,20 @@ async function uploadMedia(attachment, token, discussionType, logger) {
         filePath = generateFilePath(attachment.mimeType, attachment.__dirname);
         await downloadImage(attachment.url, filePath);
 
-        const mediaCategory =
-            discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+        // Determine media category based on mime type and discussion type
+        const mimeType = attachment.mimeType.toLowerCase();
+        let mediaCategory;
+
+        if (mimeType.startsWith('video/')) {
+            mediaCategory =
+                discussionType === 'dm' ? 'dm_video' : 'tweet_video';
+        } else if (mimeType === 'image/gif') {
+            mediaCategory = discussionType === 'dm' ? 'dm_gif' : 'tweet_gif';
+        } else {
+            mediaCategory =
+                discussionType === 'dm' ? 'dm_image' : 'tweet_image';
+        }
+
         const fileStats = fs.statSync(filePath);
         const fileSize = fileStats.size;
         const fileData = fs.readFileSync(filePath);
@@ -983,6 +1153,7 @@ async function uploadMedia(attachment, token, discussionType, logger) {
             const mediaIdString = await simpleMediaUpload(
                 fileData,
                 attachment.mimeType,
+                mediaCategory,
                 token,
                 logger
             );
@@ -1011,12 +1182,14 @@ async function uploadMedia(attachment, token, discussionType, logger) {
 }
 
 // Simple upload for small media files
-async function simpleMediaUpload(fileData, mimeType, token, logger) {
+async function simpleMediaUpload(fileData, mimeType, mediaCategory, 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';
+
+        // Original working code: empty OAuth signature, let superagent handle content-type
         const { Authorization } = token.oauth.toHeader(
             token.oauth.authorize(
                 {
@@ -1031,13 +1204,12 @@ async function simpleMediaUpload(fileData, mimeType, token, logger) {
             )
         );
 
+        // Use .field() for multipart/form-data (OAuth ignores multipart body)
         const result = await superagent
             .post(url)
             .set('Authorization', Authorization)
-            .send({
-                media_data: base64Data,
-                media_type: mimeType,
-            });
+            .field('media_data', base64Data)
+            .field('media_type', mimeType);
 
         loggerDebug(logger, 'Media uploaded successfully (simple)', {
             media_id: result.body.media_id_string,
@@ -1136,12 +1308,34 @@ async function chunkedMediaUpload(
 async function mediaUploadRequest(params, token, logger) {
     const url = 'https://upload.twitter.com/1.1/media/upload.json';
 
+    // Separate query params from body params
+    // Query params (everything except media_data) must be in OAuth signature
+    const queryParams = {};
+    const bodyParams = {};
+
+    for (const key in params) {
+        if (key === 'media_data') {
+            // media_data goes in POST body only
+            bodyParams[key] = params[key];
+        } else {
+            // All other params go in query string and OAuth signature
+            queryParams[key] = String(params[key]);
+        }
+    }
+
+    // Build full URL with query params
+    const queryString = Object.keys(queryParams)
+        .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(queryParams[key])}`)
+        .join('&');
+    const fullUrl = queryString ? `${url}?${queryString}` : url;
+
+    // OAuth signature: base URL + query params in data field
     const { Authorization } = token.oauth.toHeader(
         token.oauth.authorize(
             {
-                url,
+                url: url, // Base URL only
                 method: 'post',
-                data: {},
+                data: queryParams, // Query params go here for signature
             },
             {
                 key: token.token,
@@ -1151,11 +1345,18 @@ async function mediaUploadRequest(params, token, logger) {
     );
 
     try {
-        const result = await superagent
-            .post(url)
-            .set('Authorization', Authorization)
-            .send(params);
+        // Don't set content-type, let superagent handle it
+        // For commands with media_data, it will use application/x-www-form-urlencoded
+        const request = superagent
+            .post(fullUrl)
+            .set('Authorization', Authorization);
+
+        // Only set type if we have body params
+        if (Object.keys(bodyParams).length > 0) {
+            request.type('form').send(bodyParams);
+        }
 
+        const result = await request;
         return result.body;
     } catch (e) {
         loggerError(

package/link-for-testing.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-# Script to rebuild and re-link conversations-api-services for testing with engage-conversations-api
-
-set -e
-
-echo "🔨 Building conversations-api-services..."
-npm run build
-
-echo "🔗 Creating npm link..."
-npm link
-
-echo "🔗 Linking in engage-conversations-api..."
-cd ../engage-conversations-api
-npm link @meltwater/conversations-api-services
-
-echo "✅ Successfully linked conversations-api-services for testing!"
-echo ""
-echo "📋 To unlink when done testing:"
-echo "   cd ../engage-conversations-api"
-echo "   npm unlink @meltwater/conversations-api-services"
-echo "   npm install"