@meltwater/conversations-api-services 1.2.1 → 1.2.2

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

@@ -565,6 +565,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 +677,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,7 +711,11 @@ 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);
     throw err;

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

@@ -541,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({
@@ -575,7 +653,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,7 +687,11 @@ 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);
     throw err;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meltwater/conversations-api-services",
-    "version": "1.2.1",
+    "version": "1.2.2",
     "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

@@ -693,6 +693,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 +840,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,10 +889,20 @@ 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);
         throw err;

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"