@meltwater/conversations-api-services 1.1.4 → 1.1.6

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

@@ -3,90 +3,297 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.comment = comment;
+exports.getInsights = getInsights;
+exports.getProfile = getProfile;
+exports.manageReply = manageReply;
+exports.quote = quote;
+exports.reply = reply;
+exports.repost = repost;
 var _superagent = _interopRequireDefault(require("superagent"));
 var _externalIdHelpers = require("../../lib/externalId.helpers.js");
 var _loggerHelpers = require("../../lib/logger.helpers.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const THREADS_URL = 'https://graph.threads.net/v1.0';
 const THREADS_PUBLISH_URL = `${THREADS_URL}/me/threads_publish`;
+const MAX_RETRY_COUNT = 11;
+const SHORT_WAIT_TIME_MS = 10000; // 10 seconds
+const LONG_WAIT_TIME_MS = 60000; // 60 seconds
+
+/**
+ * Utility function to retry an asynchronous operation with exponential backoff.
+ * @param {Function} operation - The async operation to retry.
+ * @param {number} maxRetries - Maximum number of retries.
+ * @param {number} initialWaitTime - Initial wait time in milliseconds.
+ * @param {Function} logger - Logger instance for logging retries.
+ * @returns {Promise<any>} The result of the operation.
+ * @throws {Error} If the operation fails after all retries.
+ */
+async function retryWithBackoff(operation, maxRetries, initialWaitTime, logger) {
+  let waitTime = initialWaitTime;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (attempt === maxRetries) {
+        throw error; // Rethrow error if max retries are reached
+      }
+      (0, _loggerHelpers.loggerInfo)(logger, `Retry attempt ${attempt + 1} failed. Retrying in ${waitTime / 1000} seconds...`);
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+      waitTime *= 2; // Exponential backoff
+    }
+  }
+}
+
+/**
+ * Confirms the creation ID by polling the Threads API until the status is no longer "IN_PROGRESS".
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} creationId - The ID of the creation process to confirm.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response when the status is no longer "IN_PROGRESS".
+ * @throws {Error} If the status remains "IN_PROGRESS" after all retries.
+ */
 async function confirmCreationId(accessToken, creationId, logger) {
-  let retry = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-  let response = {};
-  response = await _superagent.default.get(`${THREADS_URL}/${creationId}`).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
-    access_token: accessToken,
-    fields: 'id,status,error_message'
-  }).send();
-  if (response.body.status == 'IN_PROGRESS' && retry < 11) {
-    // small wait for first attempt, sometimes its just a text post that doesn't take long
-    (0, _loggerHelpers.loggerInfo)(logger, `Creation ID is in progress ${creationId} retry ${retry} Waiting ${retry ? 60 : 10} seconds`);
-    await new Promise(resolve => setTimeout(resolve, retry ? 60000 : 10000));
-    return await confirmCreationId(accessToken, creationId, logger, retry + 1);
-  } else if (response.body.status == 'IN_PROGRESS' && retry == 11) {
-    let error = new Error(`Creation ID is in progress BUT TAKING TOO LONG ${creationId}`);
-    error.code = response.status;
+  const operation = async () => {
+    const response = await _superagent.default.get(`${THREADS_URL}/${creationId}`).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken,
+      fields: 'id,status,error_message'
+    }).send();
+    if (response.body.status === 'IN_PROGRESS') {
+      throw new Error('Status is still IN_PROGRESS');
+    }
+    (0, _loggerHelpers.loggerDebug)(logger, 'Threads Response status', response.status);
+    return response;
+  };
+  try {
+    return await retryWithBackoff(operation, MAX_RETRY_COUNT, SHORT_WAIT_TIME_MS, logger);
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, `Creation ID ${creationId} confirmation failed: ${error.message}`, error);
+    error.code = 408; // Request Timeout
     throw error;
   }
-  (0, _loggerHelpers.loggerDebug)(logger, 'Threads Response status', response.status);
-  return response;
 }
-async function requestApi(apiUrl, accessToken, inReplyToId, text, asset, logger) {
-  let response = {};
+
+/**
+ * Sends a GET request to the Threads API.
+ * @param {string} apiUrl - The API URL to send the request to.
+ * @param {Object} params - Query parameters for the request.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ * @throws {Error} If the request fails.
+ */
+async function sendRequest(apiUrl, params, logger) {
   try {
-    let query = {
-      access_token: accessToken,
-      reply_to_id: inReplyToId,
-      text
+    const response = await _superagent.default.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(params).send();
+    if (response.status !== 200) {
+      throw new Error(`Unexpected response status: ${response.status}`);
+    }
+    (0, _loggerHelpers.loggerDebug)(logger, 'Threads Response status', response.status);
+    return response;
+  } catch (err) {
+    const errorMessage = err?.response?.body?.error?.message || err.message;
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call Threads API: ${errorMessage}`, err);
+    throw err;
+  }
+}
+
+/**
+ * Sends a POST request to the Threads API.
+ * @param {string} apiUrl - The API URL to send the request to.
+ * @param {Object} params - Query parameters for the request.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ * @throws {Error} If the request fails.
+ */
+async function requestApi(apiUrl, params, logger) {
+  try {
+    const response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(params).send();
+    if (response.status !== 200) {
+      throw new Error(`Unexpected response status: ${response.status}`);
+    }
+    (0, _loggerHelpers.loggerDebug)(logger, 'Threads Response status', response.status);
+    return response;
+  } catch (err) {
+    const errorMessage = err?.response?.body?.error?.message || err.message;
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call Threads API: ${errorMessage}`, err);
+    throw err;
+  }
+}
+
+/**
+ * Publishes a post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} text - The text content of the post.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+async function reply(accessToken, inReplyToId, text, asset, logger) {
+  const query = await constructReplyQuery(accessToken, inReplyToId, text, asset, logger);
+  let response = await requestApi(THREADS_PUBLISH_URL, query, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Threads API Publish reply Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Publishes a quote post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} inReplyToId - The ID of the post to quote.
+ * @param {string} text - The text content of the quote.
+ * @param {Object} asset - The media asset to attach to the quote.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+async function quote(accessToken, inReplyToId, text, asset, logger) {
+  const query = await constructReplyQuery(accessToken, inReplyToId, text, asset, logger, true);
+  let response = await requestApi(THREADS_PUBLISH_URL, query, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Threads API Publish quote Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Publishes a post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} text - The text content of the post.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+async function repost(token, externalId, logger) {
+  const postId = (0, _externalIdHelpers.removePrefix)(externalId);
+  let response = await requestApi(`${THREADS_URL}/${postId}/repost`, {
+    access_token: token
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Threads API repost Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Retrieves the profile information of a user.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the user.
+ * @param {string} fields - The fields to retrieve from the profile.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response containing the profile information.
+ */
+async function getProfile(token, externalId, fields, logger) {
+  const userId = (0, _externalIdHelpers.removePrefix)(externalId);
+  let response = await sendRequest(`${THREADS_URL}/${userId}?fields=${fields}`, {
+    access_token: token
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Threads API getProfile Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Retrieves the insights of a post.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the post.
+ * @param {string} metric - The metric to retrieve insights for.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response containing the insights.
+ */
+async function getInsights(token, externalId, metric, logger) {
+  const mediaId = (0, _externalIdHelpers.removePrefix)(externalId);
+  let response = await sendRequest(`${THREADS_URL}/${mediaId}/insights`, {
+    access_token: token,
+    metric
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Threads API getInsights Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Manages the visibility of a reply.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the reply.
+ * @param {boolean} hide - Whether to hide the reply.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+async function manageReply(token, externalId) {
+  let hide = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  let logger = arguments.length > 3 ? arguments[3] : undefined;
+  const replyId = (0, _externalIdHelpers.removePrefix)(externalId);
+  let response = await requestApi(`${THREADS_URL}/${replyId}/manage_reply`, {
+    access_token: token,
+    hide
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Threads API hideReply Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Constructs the query parameters for replying to a post.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} inReplyToId - The ID of the post to reply to.
+ * @param {string} text - The text content of the reply.
+ * @param {Object} asset - The media asset to attach to the reply.
+ * @param {Object} logger - Logger instance for logging.
+ * @param {boolean} isQuote - Whether the reply is a quote.
+ * @returns {Promise<Object>} The constructed query parameters.
+ */
+async function constructReplyQuery(accessToken, inReplyToId, text, asset, logger) {
+  let isQuote = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+  const baseQuery = {
+    access_token: accessToken,
+    text,
+    [isQuote ? 'quote_post_id' : 'in_reply_to_id']: inReplyToId
+  };
+  const mediaQuery = getMediaQuery(asset);
+  const query = {
+    ...baseQuery,
+    ...mediaQuery
+  };
+  try {
+    const containerResponse = await _superagent.default.post(`${THREADS_URL}/me/threads`).set('Accept', 'application/json').set('Content-Type', 'application/json').query(query).send();
+    await confirmCreationId(accessToken, containerResponse.body.id, logger);
+    return {
+      ...query,
+      containerResponse
     };
-    if (!asset) {
-      query = {
-        ...query,
-        media_type: 'TEXT'
-      };
-    } else if (asset.type === 'image') {
-      query = {
-        ...query,
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error constructing reply query', error);
+    throw error;
+  }
+}
+
+/**
+ * Constructs the media query parameters based on the asset type.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @returns {Object} The constructed media query parameters.
+ */
+function getMediaQuery(asset) {
+  if (!asset) {
+    return {
+      media_type: 'TEXT'
+    };
+  }
+  switch (asset.type) {
+    case 'image':
+      return {
         media_type: 'IMAGE',
         image_url: asset.url,
         alt_text: asset.altText ?? ''
       };
-    } else if (asset.type === 'video') {
-      query = {
-        ...query,
+    case 'video':
+      return {
         media_type: 'VIDEO',
         video_url: asset.url,
         alt_text: asset.altText ?? ''
       };
-    }
-    const containerResponse = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(query).send();
-    await confirmCreationId(accessToken, containerResponse.body.id, logger);
-    response = await _superagent.default.post(THREADS_PUBLISH_URL).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
-      access_token: accessToken,
-      creation_id: containerResponse.body.id
-    }).send();
-  } catch (err) {
-    if (err && err.response && err.response.body && err.response.body.error) {
-      (0, _loggerHelpers.loggerError)(logger, `Failed to call threads api: ${err.response.body.error.message}`);
-    } else {
-      (0, _loggerHelpers.loggerError)(logger, `Failed to call threads api`, err);
-    }
-    throw err;
-  }
-  if (response.status !== 200) {
-    (0, _loggerHelpers.loggerError)(logger, `Failed to call threads api`, {
-      responseBody: JSON.stringify(response.body)
-    });
-    let error = new Error(`Failed to call threads api`);
-    error.code = response.status;
-    throw error;
+    default:
+      throw new Error(`Unsupported asset type: ${asset.type}`);
   }
-  (0, _loggerHelpers.loggerDebug)(logger, 'Threads Response status', response.status);
-  return response;
-}
-async function comment(accessToken, inReplyToId, text, asset, logger) {
-  let response = await requestApi(`${THREADS_URL}/me/threads`, accessToken, (0, _externalIdHelpers.removePrefix)(inReplyToId), text, asset, logger);
-  (0, _loggerHelpers.loggerInfo)(logger, `Native Threads API Publish Comment Response`, {
-    responseBody: JSON.stringify(response.body)
-  });
-  return response.body;
 }

package/dist/cjs/lib/externalId.helpers.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.removePrefix = removePrefix;
 exports.twitterPrefixCheck = twitterPrefixCheck;
 function removePrefix(document) {
-  return document && document.replace(/id\:[a-zA-Z]+\.com:/g, '');
+  return document && document.replace(/id\:[a-zA-Z]+\.(com|net):/g, '');
 }
 function twitterPrefixCheck(socialOriginType, value) {
   let result = value;

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

@@ -3,83 +3,285 @@ import { removePrefix } from '../../lib/externalId.helpers.js';
 import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
 const THREADS_URL = 'https://graph.threads.net/v1.0';
 const THREADS_PUBLISH_URL = `${THREADS_URL}/me/threads_publish`;
+const MAX_RETRY_COUNT = 11;
+const SHORT_WAIT_TIME_MS = 10000; // 10 seconds
+const LONG_WAIT_TIME_MS = 60000; // 60 seconds
+
+/**
+ * Utility function to retry an asynchronous operation with exponential backoff.
+ * @param {Function} operation - The async operation to retry.
+ * @param {number} maxRetries - Maximum number of retries.
+ * @param {number} initialWaitTime - Initial wait time in milliseconds.
+ * @param {Function} logger - Logger instance for logging retries.
+ * @returns {Promise<any>} The result of the operation.
+ * @throws {Error} If the operation fails after all retries.
+ */
+async function retryWithBackoff(operation, maxRetries, initialWaitTime, logger) {
+  let waitTime = initialWaitTime;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (attempt === maxRetries) {
+        throw error; // Rethrow error if max retries are reached
+      }
+      loggerInfo(logger, `Retry attempt ${attempt + 1} failed. Retrying in ${waitTime / 1000} seconds...`);
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+      waitTime *= 2; // Exponential backoff
+    }
+  }
+}
+
+/**
+ * Confirms the creation ID by polling the Threads API until the status is no longer "IN_PROGRESS".
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} creationId - The ID of the creation process to confirm.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response when the status is no longer "IN_PROGRESS".
+ * @throws {Error} If the status remains "IN_PROGRESS" after all retries.
+ */
 async function confirmCreationId(accessToken, creationId, logger) {
-  let retry = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-  let response = {};
-  response = await superagent.get(`${THREADS_URL}/${creationId}`).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
-    access_token: accessToken,
-    fields: 'id,status,error_message'
-  }).send();
-  if (response.body.status == 'IN_PROGRESS' && retry < 11) {
-    // small wait for first attempt, sometimes its just a text post that doesn't take long
-    loggerInfo(logger, `Creation ID is in progress ${creationId} retry ${retry} Waiting ${retry ? 60 : 10} seconds`);
-    await new Promise(resolve => setTimeout(resolve, retry ? 60000 : 10000));
-    return await confirmCreationId(accessToken, creationId, logger, retry + 1);
-  } else if (response.body.status == 'IN_PROGRESS' && retry == 11) {
-    let error = new Error(`Creation ID is in progress BUT TAKING TOO LONG ${creationId}`);
-    error.code = response.status;
+  const operation = async () => {
+    const response = await superagent.get(`${THREADS_URL}/${creationId}`).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken,
+      fields: 'id,status,error_message'
+    }).send();
+    if (response.body.status === 'IN_PROGRESS') {
+      throw new Error('Status is still IN_PROGRESS');
+    }
+    loggerDebug(logger, 'Threads Response status', response.status);
+    return response;
+  };
+  try {
+    return await retryWithBackoff(operation, MAX_RETRY_COUNT, SHORT_WAIT_TIME_MS, logger);
+  } catch (error) {
+    loggerError(logger, `Creation ID ${creationId} confirmation failed: ${error.message}`, error);
+    error.code = 408; // Request Timeout
     throw error;
   }
-  loggerDebug(logger, 'Threads Response status', response.status);
-  return response;
 }
-async function requestApi(apiUrl, accessToken, inReplyToId, text, asset, logger) {
-  let response = {};
+
+/**
+ * Sends a GET request to the Threads API.
+ * @param {string} apiUrl - The API URL to send the request to.
+ * @param {Object} params - Query parameters for the request.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ * @throws {Error} If the request fails.
+ */
+async function sendRequest(apiUrl, params, logger) {
   try {
-    let query = {
-      access_token: accessToken,
-      reply_to_id: inReplyToId,
-      text
+    const response = await superagent.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(params).send();
+    if (response.status !== 200) {
+      throw new Error(`Unexpected response status: ${response.status}`);
+    }
+    loggerDebug(logger, 'Threads Response status', response.status);
+    return response;
+  } catch (err) {
+    const errorMessage = err?.response?.body?.error?.message || err.message;
+    loggerError(logger, `Failed to call Threads API: ${errorMessage}`, err);
+    throw err;
+  }
+}
+
+/**
+ * Sends a POST request to the Threads API.
+ * @param {string} apiUrl - The API URL to send the request to.
+ * @param {Object} params - Query parameters for the request.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ * @throws {Error} If the request fails.
+ */
+async function requestApi(apiUrl, params, logger) {
+  try {
+    const response = await superagent.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(params).send();
+    if (response.status !== 200) {
+      throw new Error(`Unexpected response status: ${response.status}`);
+    }
+    loggerDebug(logger, 'Threads Response status', response.status);
+    return response;
+  } catch (err) {
+    const errorMessage = err?.response?.body?.error?.message || err.message;
+    loggerError(logger, `Failed to call Threads API: ${errorMessage}`, err);
+    throw err;
+  }
+}
+
+/**
+ * Publishes a post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} text - The text content of the post.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function reply(accessToken, inReplyToId, text, asset, logger) {
+  const query = await constructReplyQuery(accessToken, inReplyToId, text, asset, logger);
+  let response = await requestApi(THREADS_PUBLISH_URL, query, logger);
+  loggerInfo(logger, `Native Threads API Publish reply Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Publishes a quote post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} inReplyToId - The ID of the post to quote.
+ * @param {string} text - The text content of the quote.
+ * @param {Object} asset - The media asset to attach to the quote.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function quote(accessToken, inReplyToId, text, asset, logger) {
+  const query = await constructReplyQuery(accessToken, inReplyToId, text, asset, logger, true);
+  let response = await requestApi(THREADS_PUBLISH_URL, query, logger);
+  loggerInfo(logger, `Native Threads API Publish quote Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Publishes a post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} text - The text content of the post.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function repost(token, externalId, logger) {
+  const postId = removePrefix(externalId);
+  let response = await requestApi(`${THREADS_URL}/${postId}/repost`, {
+    access_token: token
+  }, logger);
+  loggerInfo(logger, `Native Threads API repost Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Retrieves the profile information of a user.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the user.
+ * @param {string} fields - The fields to retrieve from the profile.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response containing the profile information.
+ */
+export async function getProfile(token, externalId, fields, logger) {
+  const userId = removePrefix(externalId);
+  let response = await sendRequest(`${THREADS_URL}/${userId}?fields=${fields}`, {
+    access_token: token
+  }, logger);
+  loggerInfo(logger, `Native Threads API getProfile Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Retrieves the insights of a post.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the post.
+ * @param {string} metric - The metric to retrieve insights for.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response containing the insights.
+ */
+export async function getInsights(token, externalId, metric, logger) {
+  const mediaId = removePrefix(externalId);
+  let response = await sendRequest(`${THREADS_URL}/${mediaId}/insights`, {
+    access_token: token,
+    metric
+  }, logger);
+  loggerInfo(logger, `Native Threads API getInsights Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Manages the visibility of a reply.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the reply.
+ * @param {boolean} hide - Whether to hide the reply.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function manageReply(token, externalId) {
+  let hide = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  let logger = arguments.length > 3 ? arguments[3] : undefined;
+  const replyId = removePrefix(externalId);
+  let response = await requestApi(`${THREADS_URL}/${replyId}/manage_reply`, {
+    access_token: token,
+    hide
+  }, logger);
+  loggerInfo(logger, `Native Threads API hideReply Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+
+/**
+ * Constructs the query parameters for replying to a post.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} inReplyToId - The ID of the post to reply to.
+ * @param {string} text - The text content of the reply.
+ * @param {Object} asset - The media asset to attach to the reply.
+ * @param {Object} logger - Logger instance for logging.
+ * @param {boolean} isQuote - Whether the reply is a quote.
+ * @returns {Promise<Object>} The constructed query parameters.
+ */
+async function constructReplyQuery(accessToken, inReplyToId, text, asset, logger) {
+  let isQuote = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+  const baseQuery = {
+    access_token: accessToken,
+    text,
+    [isQuote ? 'quote_post_id' : 'in_reply_to_id']: inReplyToId
+  };
+  const mediaQuery = getMediaQuery(asset);
+  const query = {
+    ...baseQuery,
+    ...mediaQuery
+  };
+  try {
+    const containerResponse = await superagent.post(`${THREADS_URL}/me/threads`).set('Accept', 'application/json').set('Content-Type', 'application/json').query(query).send();
+    await confirmCreationId(accessToken, containerResponse.body.id, logger);
+    return {
+      ...query,
+      containerResponse
     };
-    if (!asset) {
-      query = {
-        ...query,
-        media_type: 'TEXT'
-      };
-    } else if (asset.type === 'image') {
-      query = {
-        ...query,
+  } catch (error) {
+    loggerError(logger, 'Error constructing reply query', error);
+    throw error;
+  }
+}
+
+/**
+ * Constructs the media query parameters based on the asset type.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @returns {Object} The constructed media query parameters.
+ */
+function getMediaQuery(asset) {
+  if (!asset) {
+    return {
+      media_type: 'TEXT'
+    };
+  }
+  switch (asset.type) {
+    case 'image':
+      return {
         media_type: 'IMAGE',
         image_url: asset.url,
         alt_text: asset.altText ?? ''
       };
-    } else if (asset.type === 'video') {
-      query = {
-        ...query,
+    case 'video':
+      return {
         media_type: 'VIDEO',
         video_url: asset.url,
         alt_text: asset.altText ?? ''
       };
-    }
-    const containerResponse = await superagent.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(query).send();
-    await confirmCreationId(accessToken, containerResponse.body.id, logger);
-    response = await superagent.post(THREADS_PUBLISH_URL).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
-      access_token: accessToken,
-      creation_id: containerResponse.body.id
-    }).send();
-  } catch (err) {
-    if (err && err.response && err.response.body && err.response.body.error) {
-      loggerError(logger, `Failed to call threads api: ${err.response.body.error.message}`);
-    } else {
-      loggerError(logger, `Failed to call threads api`, err);
-    }
-    throw err;
-  }
-  if (response.status !== 200) {
-    loggerError(logger, `Failed to call threads api`, {
-      responseBody: JSON.stringify(response.body)
-    });
-    let error = new Error(`Failed to call threads api`);
-    error.code = response.status;
-    throw error;
+    default:
+      throw new Error(`Unsupported asset type: ${asset.type}`);
   }
-  loggerDebug(logger, 'Threads Response status', response.status);
-  return response;
-}
-export async function comment(accessToken, inReplyToId, text, asset, logger) {
-  let response = await requestApi(`${THREADS_URL}/me/threads`, accessToken, removePrefix(inReplyToId), text, asset, logger);
-  loggerInfo(logger, `Native Threads API Publish Comment Response`, {
-    responseBody: JSON.stringify(response.body)
-  });
-  return response.body;
 }

package/dist/esm/lib/externalId.helpers.js

@@ -1,5 +1,5 @@
 export function removePrefix(document) {
-  return document && document.replace(/id\:[a-zA-Z]+\.com:/g, '');
+  return document && document.replace(/id\:[a-zA-Z]+\.(com|net):/g, '');
 }
 export function twitterPrefixCheck(socialOriginType, value) {
   let result = value;

package/package.json

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

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

@@ -1,152 +1,351 @@
 import superagent from 'superagent';
 import { removePrefix } from '../../lib/externalId.helpers.js';
-import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
-
+import {
+    loggerDebug,
+    loggerError,
+    loggerInfo,
+} from '../../lib/logger.helpers.js';
 
 const THREADS_URL = 'https://graph.threads.net/v1.0';
 const THREADS_PUBLISH_URL = `${THREADS_URL}/me/threads_publish`;
 
+const MAX_RETRY_COUNT = 11;
+const SHORT_WAIT_TIME_MS = 10000; // 10 seconds
+const LONG_WAIT_TIME_MS = 60000; // 60 seconds
 
-async function confirmCreationId(accessToken, creationId, logger, retry = 0) {
-    let response = {};
-
-    response = await superagent
-        .get(`${THREADS_URL}/${creationId}`)
-        .set('Accept', 'application/json')
-        .set('Content-Type', 'application/json')
-        .query({
-            access_token: accessToken,
-            fields: 'id,status,error_message',
-        })
-        .send();
-    if(response.body.status == 'IN_PROGRESS' && retry < 11){
-        // small wait for first attempt, sometimes its just a text post that doesn't take long
-        loggerInfo(logger,
-            `Creation ID is in progress ${creationId} retry ${retry} Waiting ${retry ? 60 : 10} seconds`
-        );
-        await new Promise((resolve) => setTimeout(resolve, retry ? 60000 : 10000));
-        return await confirmCreationId(accessToken, creationId, logger, retry + 1);
-    }else if(response.body.status == 'IN_PROGRESS' && retry == 11){
-        let error = new Error(
-            `Creation ID is in progress BUT TAKING TOO LONG ${creationId}`
-        );
-        error.code = response.status;
-        throw error
-    }
+/**
+ * Utility function to retry an asynchronous operation with exponential backoff.
+ * @param {Function} operation - The async operation to retry.
+ * @param {number} maxRetries - Maximum number of retries.
+ * @param {number} initialWaitTime - Initial wait time in milliseconds.
+ * @param {Function} logger - Logger instance for logging retries.
+ * @returns {Promise<any>} The result of the operation.
+ * @throws {Error} If the operation fails after all retries.
+ */
+async function retryWithBackoff(operation, maxRetries, initialWaitTime, logger) {
+    let waitTime = initialWaitTime;
 
-    
-    loggerDebug(logger,'Threads Response status', response.status);
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        } catch (error) {
+            if (attempt === maxRetries) {
+                throw error; // Rethrow error if max retries are reached
+            }
 
-    return response;
+            loggerInfo(
+                logger,
+                `Retry attempt ${attempt + 1} failed. Retrying in ${waitTime / 1000} seconds...`
+            );
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+            waitTime *= 2; // Exponential backoff
+        }
+    }
 }
 
+/**
+ * Confirms the creation ID by polling the Threads API until the status is no longer "IN_PROGRESS".
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} creationId - The ID of the creation process to confirm.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response when the status is no longer "IN_PROGRESS".
+ * @throws {Error} If the status remains "IN_PROGRESS" after all retries.
+ */
+async function confirmCreationId(accessToken, creationId, logger) {
+    const operation = async () => {
+        const response = await superagent
+            .get(`${THREADS_URL}/${creationId}`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .query({
+                access_token: accessToken,
+                fields: 'id,status,error_message',
+            })
+            .send();
 
-async function requestApi(
-    apiUrl,
-    accessToken,
-    inReplyToId,
-    text,
-    asset,
-    logger
-) {
-    let response = {};
+        if (response.body.status === 'IN_PROGRESS') {
+            throw new Error('Status is still IN_PROGRESS');
+        }
+
+        loggerDebug(logger, 'Threads Response status', response.status);
+        return response;
+    };
 
     try {
-        let query = {
-            access_token: accessToken,
-            reply_to_id: inReplyToId,
-            text,
-        };
-
-        if (!asset) {
-            query = {
-                ...query,
-                media_type: 'TEXT',
-            };
-        } else if (asset.type === 'image') {
-            query = {
-                ...query,
-                media_type: 'IMAGE',
-                image_url: asset.url,
-                alt_text: asset.altText ?? '',
-            }
-        } else if (asset.type === 'video') {
-            query = {
-                ...query,
-                media_type: 'VIDEO',
-                video_url: asset.url,
-                alt_text: asset.altText ?? '',
-            }
-        }
+        return await retryWithBackoff(operation, MAX_RETRY_COUNT, SHORT_WAIT_TIME_MS, logger);
+    } catch (error) {
+        loggerError(logger, `Creation ID ${creationId} confirmation failed: ${error.message}`, error);
+        error.code = 408; // Request Timeout
+        throw error;
+    }
+}
 
-        const containerResponse = await superagent
-            .post(apiUrl)
+/**
+ * Sends a GET request to the Threads API.
+ * @param {string} apiUrl - The API URL to send the request to.
+ * @param {Object} params - Query parameters for the request.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ * @throws {Error} If the request fails.
+ */
+async function sendRequest(apiUrl, params, logger) {
+    try {
+        const response = await superagent
+            .get(apiUrl)
             .set('Accept', 'application/json')
             .set('Content-Type', 'application/json')
-            .query(query)
+            .query(params)
             .send();
-        await confirmCreationId(accessToken, containerResponse.body.id, logger);
-        response = await superagent
-            .post(THREADS_PUBLISH_URL)
+
+        if (response.status !== 200) {
+            throw new Error(`Unexpected response status: ${response.status}`);
+        }
+
+        loggerDebug(logger, 'Threads Response status', response.status);
+        return response;
+    } catch (err) {
+        const errorMessage = err?.response?.body?.error?.message || err.message;
+        loggerError(logger, `Failed to call Threads API: ${errorMessage}`, err);
+        throw err;
+    }
+}
+
+/**
+ * Sends a POST request to the Threads API.
+ * @param {string} apiUrl - The API URL to send the request to.
+ * @param {Object} params - Query parameters for the request.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ * @throws {Error} If the request fails.
+ */
+async function requestApi(apiUrl, params, logger) {
+    try {
+        const response = await superagent
+            .post(apiUrl)
             .set('Accept', 'application/json')
             .set('Content-Type', 'application/json')
-            .query({
-                access_token: accessToken,
-                creation_id: containerResponse.body.id,
-            })
+            .query(params)
             .send();
 
-    } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(logger,
-                `Failed to call threads api: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(logger,
-                `Failed to call threads api`,
-                err
-            );
+        if (response.status !== 200) {
+            throw new Error(`Unexpected response status: ${response.status}`);
         }
+
+        loggerDebug(logger, 'Threads Response status', response.status);
+        return response;
+    } catch (err) {
+        const errorMessage = err?.response?.body?.error?.message || err.message;
+        loggerError(logger, `Failed to call Threads API: ${errorMessage}`, err);
         throw err;
     }
+}
 
-    if (response.status !== 200) {
-        loggerError(logger,
-            `Failed to call threads api`,
-            { responseBody: JSON.stringify(response.body) }
-        );
-        let error = new Error(
-            `Failed to call threads api`
-        );
-        error.code = response.status;
-        throw error;
-    }
-    
-    loggerDebug(logger,'Threads Response status', response.status);
+/**
+ * Publishes a post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} text - The text content of the post.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function reply(accessToken, inReplyToId, text, asset, logger) {
+    const query = await constructReplyQuery(
+        accessToken,
+        inReplyToId,
+        text,
+        asset,
+        logger
+    );
+    let response = await requestApi(THREADS_PUBLISH_URL, query, logger);
 
-    return response;
-}
+    loggerInfo(logger, `Native Threads API Publish reply Response`, {
+        responseBody: JSON.stringify(response.body),
+    });
 
+    return response.body;
+}
 
-export async function comment(accessToken, inReplyToId, text,asset, logger) {
-    let response = await requestApi(
-        `${THREADS_URL}/me/threads`,
+/**
+ * Publishes a quote post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} inReplyToId - The ID of the post to quote.
+ * @param {string} text - The text content of the quote.
+ * @param {Object} asset - The media asset to attach to the quote.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function quote(accessToken, inReplyToId, text, asset, logger) {
+    const query = await constructReplyQuery(
         accessToken,
-        removePrefix(inReplyToId),
+        inReplyToId,
         text,
         asset,
+        logger,
+        true
+    );
+    let response = await requestApi(THREADS_PUBLISH_URL, query, logger);
+    loggerInfo(logger, `Native Threads API Publish quote Response`, {
+        responseBody: JSON.stringify(response.body),
+    });
+    return response.body;
+}
+
+/**
+ * Publishes a post to Threads.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} text - The text content of the post.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function repost(token, externalId, logger) {
+    const postId = removePrefix(externalId);
+    let response = await requestApi(
+        `${THREADS_URL}/${postId}/repost`,
+        { access_token: token },
         logger
     );
 
-    loggerInfo(logger,
-        `Native Threads API Publish Comment Response`,
-        { responseBody: JSON.stringify(response.body) }
+    loggerInfo(logger, `Native Threads API repost Response`, {
+        responseBody: JSON.stringify(response.body),
+    });
+    return response.body;
+}
+
+/**
+ * Retrieves the profile information of a user.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the user.
+ * @param {string} fields - The fields to retrieve from the profile.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response containing the profile information.
+ */
+export async function getProfile(token, externalId, fields, logger) {
+    const userId = removePrefix(externalId);
+    let response = await sendRequest(
+        `${THREADS_URL}/${userId}?fields=${fields}`,
+        { access_token: token },
+        logger
     );
 
+    loggerInfo(logger, `Native Threads API getProfile Response`, {
+        responseBody: JSON.stringify(response.body),
+    });
     return response.body;
-}
+}
+
+/**
+ * Retrieves the insights of a post.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the post.
+ * @param {string} metric - The metric to retrieve insights for.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response containing the insights.
+ */
+export async function getInsights(token, externalId, metric, logger) {
+    const mediaId = removePrefix(externalId);
+    let response = await sendRequest(
+        `${THREADS_URL}/${mediaId}/insights`,
+        { access_token: token, metric },
+        logger
+    );
+
+    loggerInfo(logger, `Native Threads API getInsights Response`, {
+        responseBody: JSON.stringify(response.body),
+    });
+    return response.body;
+}
+
+/**
+ * Manages the visibility of a reply.
+ * @param {string} token - The access token for authentication.
+ * @param {string} externalId - The external ID of the reply.
+ * @param {boolean} hide - Whether to hide the reply.
+ * @param {Object} logger - Logger instance for logging.
+ * @returns {Promise<Object>} The API response.
+ */
+export async function manageReply(token, externalId, hide = false, logger) {
+    const replyId = removePrefix(externalId);
+    let response = await requestApi(
+        `${THREADS_URL}/${replyId}/manage_reply`,
+        { access_token: token, hide },
+        logger
+    );
+
+    loggerInfo(logger, `Native Threads API hideReply Response`, {
+        responseBody: JSON.stringify(response.body),
+    });
+    return response.body;
+}
+
+/**
+ * Constructs the query parameters for replying to a post.
+ * @param {string} accessToken - The access token for authentication.
+ * @param {string} inReplyToId - The ID of the post to reply to.
+ * @param {string} text - The text content of the reply.
+ * @param {Object} asset - The media asset to attach to the reply.
+ * @param {Object} logger - Logger instance for logging.
+ * @param {boolean} isQuote - Whether the reply is a quote.
+ * @returns {Promise<Object>} The constructed query parameters.
+ */
+async function constructReplyQuery(
+    accessToken,
+    inReplyToId,
+    text,
+    asset,
+    logger,
+    isQuote = false
+) {
+    const baseQuery = {
+        access_token: accessToken,
+        text,
+        [isQuote ? 'quote_post_id' : 'in_reply_to_id']: inReplyToId,
+    };
+
+    const mediaQuery = getMediaQuery(asset);
+    const query = { ...baseQuery, ...mediaQuery };
+
+    try {
+        const containerResponse = await superagent
+            .post(`${THREADS_URL}/me/threads`)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .query(query)
+            .send();
+
+        await confirmCreationId(accessToken, containerResponse.body.id, logger);
+
+        return { ...query, containerResponse };
+    } catch (error) {
+        loggerError(logger, 'Error constructing reply query', error);
+        throw error;
+    }
+}
+
+/**
+ * Constructs the media query parameters based on the asset type.
+ * @param {Object} asset - The media asset to attach to the post.
+ * @returns {Object} The constructed media query parameters.
+ */
+function getMediaQuery(asset) {
+    if (!asset) {
+        return { media_type: 'TEXT' };
+    }
+
+    switch (asset.type) {
+        case 'image':
+            return {
+                media_type: 'IMAGE',
+                image_url: asset.url,
+                alt_text: asset.altText ?? '',
+            };
+        case 'video':
+            return {
+                media_type: 'VIDEO',
+                video_url: asset.url,
+                alt_text: asset.altText ?? '',
+            };
+        default:
+            throw new Error(`Unsupported asset type: ${asset.type}`);
+    }
+}

package/src/lib/externalId.helpers.js

@@ -1,5 +1,5 @@
 export function removePrefix(document) {
-    return document && document.replace(/id\:[a-zA-Z]+\.com:/g, '');
+    return document && document.replace(/id\:[a-zA-Z]+\.(com|net):/g, '');
 }
 
 export function twitterPrefixCheck(socialOriginType, value) {