@meltwater/conversations-api-services 1.1.5 → 1.1.7

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

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getInsights = getInsights;
 exports.getProfile = getProfile;
+exports.manageReply = manageReply;
+exports.quote = quote;
 exports.reply = reply;
 exports.repost = repost;
 var _superagent = _interopRequireDefault(require("superagent"));
@@ -17,25 +19,68 @@ 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) {
-  for (let retry = 0; retry <= MAX_RETRY_COUNT; retry++) {
+  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') {
-      const waitTime = retry === 0 ? SHORT_WAIT_TIME_MS : LONG_WAIT_TIME_MS;
-      (0, _loggerHelpers.loggerInfo)(logger, `Creation ID ${creationId} in progress. Retry ${retry}. Waiting ${waitTime / 1000} seconds.`);
-      await new Promise(resolve => setTimeout(resolve, waitTime));
-    } else {
-      (0, _loggerHelpers.loggerDebug)(logger, 'Threads Response status', response.status);
-      return response;
+      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;
   }
-  const error = new Error(`Creation ID ${creationId} is taking too long.`);
-  error.code = 408; // Request Timeout
-  throw error;
 }
+
+/**
+ * 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.default.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(params).send();
@@ -50,6 +95,15 @@ async function sendRequest(apiUrl, params, logger) {
     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();
@@ -64,6 +118,15 @@ async function requestApi(apiUrl, params, logger) {
     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);
@@ -72,6 +135,33 @@ async function reply(accessToken, inReplyToId, text, asset, logger) {
   });
   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`, {
@@ -82,6 +172,15 @@ async function repost(token, externalId, logger) {
   });
   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}`, {
@@ -92,6 +191,15 @@ async function getProfile(token, externalId, fields, logger) {
   });
   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`, {
@@ -103,11 +211,45 @@ async function getInsights(token, externalId, metric, logger) {
   });
   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,
-    reply_to_id: inReplyToId,
-    text
+    text,
+    [isQuote ? 'quote_post_id' : 'reply_to_id']: inReplyToId
   };
   const mediaQuery = getMediaQuery(asset);
   const query = {
@@ -119,13 +261,19 @@ async function constructReplyQuery(accessToken, inReplyToId, text, asset, logger
     await confirmCreationId(accessToken, containerResponse.body.id, logger);
     return {
       ...query,
-      containerResponse
+      creation_id: containerResponse.body.id
     };
   } 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 {

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

@@ -7,25 +7,68 @@ 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) {
-  for (let retry = 0; retry <= MAX_RETRY_COUNT; retry++) {
+  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') {
-      const waitTime = retry === 0 ? SHORT_WAIT_TIME_MS : LONG_WAIT_TIME_MS;
-      loggerInfo(logger, `Creation ID ${creationId} in progress. Retry ${retry}. Waiting ${waitTime / 1000} seconds.`);
-      await new Promise(resolve => setTimeout(resolve, waitTime));
-    } else {
-      loggerDebug(logger, 'Threads Response status', response.status);
-      return response;
+      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;
   }
-  const error = new Error(`Creation ID ${creationId} is taking too long.`);
-  error.code = 408; // Request Timeout
-  throw error;
 }
+
+/**
+ * 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(params).send();
@@ -40,6 +83,15 @@ async function sendRequest(apiUrl, params, logger) {
     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();
@@ -54,6 +106,15 @@ async function requestApi(apiUrl, params, logger) {
     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);
@@ -62,6 +123,33 @@ export async function reply(accessToken, inReplyToId, text, asset, logger) {
   });
   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`, {
@@ -72,6 +160,15 @@ export async function repost(token, externalId, logger) {
   });
   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}`, {
@@ -82,6 +179,15 @@ export async function getProfile(token, externalId, fields, logger) {
   });
   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`, {
@@ -93,11 +199,45 @@ export async function getInsights(token, externalId, metric, logger) {
   });
   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,
-    reply_to_id: inReplyToId,
-    text
+    text,
+    [isQuote ? 'quote_post_id' : 'reply_to_id']: inReplyToId
   };
   const mediaQuery = getMediaQuery(asset);
   const query = {
@@ -109,13 +249,19 @@ async function constructReplyQuery(accessToken, inReplyToId, text, asset, logger
     await confirmCreationId(accessToken, containerResponse.body.id, logger);
     return {
       ...query,
-      containerResponse
+      creation_id: containerResponse.body.id
     };
   } 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 {

package/package.json

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

@@ -13,8 +13,53 @@ 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) {
-    for (let retry = 0; retry <= MAX_RETRY_COUNT; retry++) {
+    const operation = async () => {
         const response = await superagent
             .get(`${THREADS_URL}/${creationId}`)
             .set('Accept', 'application/json')
@@ -26,26 +71,39 @@ async function confirmCreationId(accessToken, creationId, logger) {
             .send();
 
         if (response.body.status === 'IN_PROGRESS') {
-            const waitTime =
-                retry === 0 ? SHORT_WAIT_TIME_MS : LONG_WAIT_TIME_MS;
-            loggerInfo(
-                logger,
-                `Creation ID ${creationId} in progress. Retry ${retry}. Waiting ${
-                    waitTime / 1000
-                } seconds.`
-            );
-            await new Promise((resolve) => setTimeout(resolve, waitTime));
-        } else {
-            loggerDebug(logger, 'Threads Response status', response.status);
-            return response;
+            throw new Error('Status is still IN_PROGRESS');
         }
-    }
 
-    const error = new Error(`Creation ID ${creationId} is taking too long.`);
-    error.code = 408; // Request Timeout
-    throw error;
+        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;
+    }
 }
 
+/**
+ * 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
@@ -68,6 +126,14 @@ async function sendRequest(apiUrl, params, logger) {
     }
 }
 
+/**
+ * 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
@@ -90,6 +156,14 @@ async function requestApi(apiUrl, params, logger) {
     }
 }
 
+/**
+ * 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,
@@ -107,6 +181,39 @@ export async function reply(accessToken, inReplyToId, text, asset, logger) {
     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(
@@ -121,6 +228,14 @@ export async function repost(token, externalId, logger) {
     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(
@@ -135,6 +250,14 @@ export async function getProfile(token, externalId, fields, logger) {
     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(
@@ -149,17 +272,50 @@ export async function getInsights(token, externalId, metric, logger) {
     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
+    logger,
+    isQuote = false
 ) {
     const baseQuery = {
         access_token: accessToken,
-        reply_to_id: inReplyToId,
         text,
+        [isQuote ? 'quote_post_id' : 'reply_to_id']: inReplyToId,
     };
 
     const mediaQuery = getMediaQuery(asset);
@@ -175,13 +331,18 @@ async function constructReplyQuery(
 
         await confirmCreationId(accessToken, containerResponse.body.id, logger);
 
-        return { ...query, containerResponse };
+        return { ...query, creation_id: containerResponse.body.id };
     } 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' };