@meltwater/conversations-api-services 1.1.3 → 1.1.5

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

@@ -3,90 +3,149 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.comment = comment;
+exports.getInsights = getInsights;
+exports.getProfile = getProfile;
+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
+
 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({
+  for (let retry = 0; retry <= MAX_RETRY_COUNT; retry++) {
+    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;
+    }
+  }
+  const error = new Error(`Creation ID ${creationId} is taking too long.`);
+  error.code = 408; // Request Timeout
+  throw error;
+}
+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();
+    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;
+  }
+}
+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;
+  }
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+async function constructReplyQuery(accessToken, inReplyToId, text, asset, logger) {
+  const baseQuery = {
     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;
+    reply_to_id: inReplyToId,
+    text
+  };
+  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
+    };
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error constructing reply query', error);
     throw error;
   }
-  (0, _loggerHelpers.loggerDebug)(logger, 'Threads Response status', response.status);
-  return response;
 }
-async function requestApi(apiUrl, accessToken, inReplyToId, text, asset, logger) {
-  let response = {};
-  try {
-    let query = {
-      access_token: accessToken,
-      reply_to_id: inReplyToId,
-      text
+function getMediaQuery(asset) {
+  if (!asset) {
+    return {
+      media_type: 'TEXT'
     };
-    if (!asset) {
-      query = {
-        ...query,
-        media_type: 'TEXT'
-      };
-    } else if (asset.type === 'image') {
-      query = {
-        ...query,
+  }
+  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/data-access/http/twitter.native.js

@@ -115,7 +115,8 @@ async function getMentionHandleInfo(token, externalId, logger) {
       token,
       uri,
       attachUrlPrefix: false,
-      convertPayloadToUri: false
+      convertPayloadToUri: false,
+      logger
     });
     return result.data;
   } catch (error) {

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,139 @@ 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
+
 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({
+  for (let retry = 0; retry <= MAX_RETRY_COUNT; retry++) {
+    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;
+    }
+  }
+  const error = new Error(`Creation ID ${creationId} is taking too long.`);
+  error.code = 408; // Request Timeout
+  throw error;
+}
+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();
+    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;
+  }
+}
+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;
+  }
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+async function constructReplyQuery(accessToken, inReplyToId, text, asset, logger) {
+  const baseQuery = {
     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;
+    reply_to_id: inReplyToId,
+    text
+  };
+  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;
   }
-  loggerDebug(logger, 'Threads Response status', response.status);
-  return response;
 }
-async function requestApi(apiUrl, accessToken, inReplyToId, text, asset, logger) {
-  let response = {};
-  try {
-    let query = {
-      access_token: accessToken,
-      reply_to_id: inReplyToId,
-      text
+function getMediaQuery(asset) {
+  if (!asset) {
+    return {
+      media_type: 'TEXT'
     };
-    if (!asset) {
-      query = {
-        ...query,
-        media_type: 'TEXT'
-      };
-    } else if (asset.type === 'image') {
-      query = {
-        ...query,
+  }
+  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;
+    default:
+      throw new Error(`Unsupported asset type: ${asset.type}`);
   }
-  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);
-  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/data-access/http/twitter.native.js

@@ -92,7 +92,8 @@ export async function getMentionHandleInfo(token, externalId, logger) {
       token,
       uri,
       attachUrlPrefix: false,
-      convertPayloadToUri: false
+      convertPayloadToUri: false,
+      logger
     });
     return result.data;
   } catch (error) {

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.3",
+  "version": "1.1.5",
   "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,206 @@
 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
-    }
+async function confirmCreationId(accessToken, creationId, logger) {
+    for (let retry = 0; retry <= MAX_RETRY_COUNT; retry++) {
+        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();
 
-    
-    loggerDebug(logger,'Threads Response status', response.status);
+        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;
+        }
+    }
 
-    return response;
+    const error = new Error(`Creation ID ${creationId} is taking too long.`);
+    error.code = 408; // Request Timeout
+    throw error;
 }
 
-
-async function requestApi(
-    apiUrl,
-    accessToken,
-    inReplyToId,
-    text,
-    asset,
-    logger
-) {
-    let response = {};
-
+async function sendRequest(apiUrl, params, logger) {
     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 ?? '',
-            }
-        }
-
-        const containerResponse = await superagent
-            .post(apiUrl)
+        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;
+    }
+}
+
+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}`);
         }
-        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);
+        return response;
+    } catch (err) {
+        const errorMessage = err?.response?.body?.error?.message || err.message;
+        loggerError(logger, `Failed to call Threads API: ${errorMessage}`, err);
+        throw err;
     }
-    
-    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`,
+export async function reply(accessToken, inReplyToId, text, asset, logger) {
+    const query = await constructReplyQuery(
         accessToken,
-        removePrefix(inReplyToId),
+        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;
+}
+
+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;
+}
+
+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 Publish Comment Response`,
-        { responseBody: JSON.stringify(response.body) }
+    loggerInfo(logger, `Native Threads API getProfile Response`, {
+        responseBody: JSON.stringify(response.body),
+    });
+    return response.body;
+}
+
+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;
-}
+}
+
+async function constructReplyQuery(
+    accessToken,
+    inReplyToId,
+    text,
+    asset,
+    logger
+) {
+    const baseQuery = {
+        access_token: accessToken,
+        reply_to_id: inReplyToId,
+        text,
+    };
+
+    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;
+    }
+}
+
+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/data-access/http/twitter.native.js

@@ -100,6 +100,7 @@ export async function getMentionHandleInfo(token, externalId, logger) {
             uri,
             attachUrlPrefix: false,
             convertPayloadToUri: false,
+            logger,
         });
         return result.data;
     } catch (error) {

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) {