@meltwater/conversations-api-services 1.0.25 → 1.0.27

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

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.comment = comment;
+exports.commentOnMention = commentOnMention;
+exports.getAttachment = getAttachment;
+exports.getLikes = getLikes;
+exports.hide = hide;
+exports.privateMessage = privateMessage;
+exports.reply = reply;
+exports.replyOnMention = replyOnMention;
+exports.unhide = unhide;
+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 INSTAGRAM_URL = 'https://graph.facebook.com';
+async function requestApi(apiUrl, accessToken, text, data) {
+  let discussionType = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 're';
+  let adCampaign = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : undefined;
+  let logger = arguments.length > 6 ? arguments[6] : undefined;
+  let response = {};
+  try {
+    let queryStringArgs = {
+      access_token: accessToken
+    };
+    if (adCampaign) {
+      queryStringArgs.ad_id = adCampaign.adAccountId;
+    }
+    if (text) {
+      queryStringArgs[discussionType === 'dm' ? 'text' : 'message'] = text;
+    }
+    response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(queryStringArgs).send(data);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  (0, _loggerHelpers.loggerDebug)(logger, 'Instagram Response status', response.status);
+  return response;
+}
+async function getPost(apiUrl, accessToken, fields, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query({
+      fields: fields
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err.response.body.error);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function getMessageData(accessToken, sourceId, inReplyToId, logger) {
+  let response;
+  try {
+    response = await getPost(`${INSTAGRAM_URL}/${sourceId}`, accessToken, `mentioned_comment.comment_id(${inReplyToId}){id, text, timestamp, media{id,media_url}}`, logger);
+    return response.body;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    return null;
+  }
+}
+async function mentionRequestApi(apiUrl, accessToken, replayObject, text, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query(replayObject).query({
+      message: text
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function hideApi(apiUrl, accessToken, hideStatus, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query({
+      hide: hideStatus
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err.response.body.error);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function getLikes(accessToken, externalId, logger) {
+  let response;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram getPost api for externalId ${externalId}`);
+  try {
+    response = await getPost(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, accessToken, 'like_count', logger);
+    (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API getPost Response`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    return response.body;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error getLikes Instagram ' + externalId, err);
+    return 0;
+  }
+}
+async function commentOnMention(accessToken, sourceId, inReplyToId, text, logger) {
+  return commentHelper(accessToken, inReplyToId, text, true, sourceId, logger);
+}
+async function comment(accessToken, sourceId, inReplyToId, text, logger) {
+  return commentHelper(accessToken, inReplyToId, text, false, sourceId, logger);
+}
+async function commentHelper(accessToken, inReplyToId, text, isMention, sourceId, logger) {
+  let response;
+  if (isMention) {
+    response = await mentionRequestApi(`${INSTAGRAM_URL}/${sourceId}/mentions`, accessToken, {
+      media_id: (0, _externalIdHelpers.removePrefix)(inReplyToId)
+    }, text, logger);
+  } else {
+    response = await requestApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(inReplyToId)}/comments`, accessToken, text, undefined, 'qt', logger);
+  }
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Intagram API Publish Comment Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function replyOnMention(accessToken, inReplyToId, text, sourceId, threadId, logger) {
+  return replyHelper(accessToken, {
+    inReplyToId,
+    text,
+    sourceId,
+    threadId,
+    isMention: true
+  }, logger);
+}
+async function reply(accessToken, inReplyToId, text) {
+  let adCampaign = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+  let logger = arguments.length > 4 ? arguments[4] : undefined;
+  return replyHelper(accessToken, {
+    inReplyToId,
+    text,
+    isMention: false,
+    adCampaign
+  }, logger);
+}
+async function replyHelper(accessToken, payload, logger) {
+  let response;
+  const {
+    inReplyToId,
+    text,
+    isMention,
+    sourceId,
+    threadId,
+    adCampaign
+  } = payload;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram comment api`, {
+    payload: JSON.stringify(payload)
+  });
+  if (isMention) {
+    let messageData = await getMessageData(accessToken, sourceId, inReplyToId, logger);
+    let media_id = null;
+    if (messageData) {
+      media_id = messageData.mentioned_comment.media.id;
+    }
+    response = await mentionRequestApi(`${INSTAGRAM_URL}/${sourceId}/mentions`, accessToken, {
+      media_id: media_id ? media_id : (0, _externalIdHelpers.removePrefix)(threadId),
+      comment_id: (0, _externalIdHelpers.removePrefix)(inReplyToId)
+    }, text, logger);
+  } else {
+    response = await requestApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(inReplyToId)}/replies`, accessToken, text, undefined, 're', adCampaign, logger);
+  }
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Publish Reply Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function privateMessage(accessToken, profileId, text, logger) {
+  const response = await requestApi(`${INSTAGRAM_URL}/v10.0/me/messages`, accessToken,
+  // this sends in query string leaving out :shrug:
+  undefined, {
+    recipient: {
+      // not :100: this is right
+      id: (0, _externalIdHelpers.removePrefix)(profileId)
+    },
+    message: {
+      text
+    },
+    // this apparently allows up to 7 days after message 🤔
+    tag: 'HUMAN_AGENT'
+  }, 'dm', logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Publish Private Message Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function hide(accessToken, externalId, logger) {
+  let response;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram hide api`);
+  response = await hideApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, accessToken, true, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Hide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function unhide(accessToken, externalId, logger) {
+  let response;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram unhide api`);
+  response = await hideApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, accessToken, false, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Unhide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function getAttachment(token, externalId, logger) {
+  try {
+    const result = await getPost(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, token, 'media_url,children{media_url}', logger);
+    const res = result.body;
+    if (res?.children?.data?.length) {
+      return {
+        images: res.children.data.map(item => {
+          return {
+            source: item?.media_url
+          };
+        })
+      };
+    }
+    return {
+      images: [{
+        source: res?.media_url
+      }]
+    };
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting instagram attachment`, error);
+    throw error;
+  }
+}

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

@@ -3,101 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "CompanyApiClient", {
-  enumerable: true,
-  get: function () {
-    return _companiesApiClient.CompanyApiClient;
-  }
-});
-Object.defineProperty(exports, "CredentialsApiClient", {
-  enumerable: true,
-  get: function () {
-    return _credentialsApiClient.CredentialsApiClient;
-  }
-});
-exports.DocumentHelperFunctions = void 0;
-Object.defineProperty(exports, "EntitlementsApiClient", {
-  enumerable: true,
-  get: function () {
-    return _entitlementsApiClient.EntitlementsApiClient;
-  }
-});
-Object.defineProperty(exports, "FacebookApiClient", {
-  enumerable: true,
-  get: function () {
-    return _facebookApiClient.FacebookApiClient;
-  }
-});
-exports.FacebookNative = void 0;
-Object.defineProperty(exports, "FeatureToggleClient", {
-  enumerable: true,
-  get: function () {
-    return _featureToggleApiClient.FeatureToggleClient;
-  }
-});
-Object.defineProperty(exports, "IRClient", {
-  enumerable: true,
-  get: function () {
-    return _irClient.IRClient;
-  }
-});
-Object.defineProperty(exports, "IdentityServicesClient", {
-  enumerable: true,
-  get: function () {
-    return _identityServicesClient.IdentityServicesClient;
-  }
-});
-Object.defineProperty(exports, "InstagramApiClient", {
-  enumerable: true,
-  get: function () {
-    return _instagramApiClient.InstagramApiClient;
-  }
-});
-Object.defineProperty(exports, "InstagramVideoClient", {
-  enumerable: true,
-  get: function () {
-    return _InstagramVideoClient.InstagramVideoClient;
-  }
-});
-Object.defineProperty(exports, "LinkedInApiClient", {
-  enumerable: true,
-  get: function () {
-    return _linkedInApiClient.LinkedInApiClient;
-  }
-});
-exports.LinkedinNative = exports.LinkedInHelpers = void 0;
-Object.defineProperty(exports, "MasfClient", {
-  enumerable: true,
-  get: function () {
-    return _masfClient.MasfClient;
-  }
-});
-Object.defineProperty(exports, "TikTokApiClient", {
-  enumerable: true,
-  get: function () {
-    return _tiktokApiClient.TikTokApiClient;
-  }
-});
-exports.TwitterNative = exports.TiktokNative = void 0;
-Object.defineProperty(exports, "WarpZoneApiClient", {
-  enumerable: true,
-  get: function () {
-    return _WarpZoneApiClient.WarpZoneApiClient;
-  }
-});
-exports.YoutubeNative = void 0;
-Object.defineProperty(exports, "assetManagerTvmRepository", {
-  enumerable: true,
-  get: function () {
-    return _assetManagerTvmClient.assetManagerTvmRepository;
-  }
-});
-Object.defineProperty(exports, "awsS3Client", {
-  enumerable: true,
-  get: function () {
-    return _amazonS.awsS3Client;
-  }
-});
+exports.default = void 0;
 var _amazonS = require("./http/amazonS3.js");
 var _assetManagerTvmClient = require("./http/asset-manager-tvm.client.js");
 var _companiesApiClient = require("./http/companiesApi.client.js");
@@ -117,23 +23,44 @@ var messageHelpers = _interopRequireWildcard(require("../lib/message.helpers.js"
 var applicationTagFunctions = _interopRequireWildcard(require("../lib/applicationTags.helpers.js"));
 var hiddenHelpers = _interopRequireWildcard(require("../lib/hidden.helpers.js"));
 var FacebookNative = _interopRequireWildcard(require("./http/facebook.native.js"));
-exports.FacebookNative = FacebookNative;
 var TiktokNative = _interopRequireWildcard(require("./http/tiktok.native.js"));
-exports.TiktokNative = TiktokNative;
 var YoutubeNative = _interopRequireWildcard(require("./http/youtube.native.js"));
-exports.YoutubeNative = YoutubeNative;
 var LinkedinNative = _interopRequireWildcard(require("./http/linkedin.native.js"));
-exports.LinkedinNative = LinkedinNative;
 var TwitterNative = _interopRequireWildcard(require("./http/twitter.native.js"));
-exports.TwitterNative = TwitterNative;
+var InstagramNative = _interopRequireWildcard(require("./http/instagram.native.js"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const DocumentHelperFunctions = exports.DocumentHelperFunctions = {
+const DocumentHelperFunctions = {
   ...messageHelpers,
   ...applicationTagFunctions,
   ...hiddenHelpers
 };
-const LinkedInHelpers = exports.LinkedInHelpers = {
+const LinkedInHelpers = {
   getOrganization: _linkedInApiClient.getOrganization,
   getProfile: _linkedInApiClient.getProfile
+};
+var _default = exports.default = {
+  InstagramNative,
+  FacebookNative,
+  TiktokNative,
+  YoutubeNative,
+  LinkedinNative,
+  TwitterNative,
+  awsS3Client: _amazonS.awsS3Client,
+  assetManagerTvmRepository: _assetManagerTvmClient.assetManagerTvmRepository,
+  CompanyApiClient: _companiesApiClient.CompanyApiClient,
+  CredentialsApiClient: _credentialsApiClient.CredentialsApiClient,
+  EntitlementsApiClient: _entitlementsApiClient.EntitlementsApiClient,
+  FacebookApiClient: _facebookApiClient.FacebookApiClient,
+  FeatureToggleClient: _featureToggleApiClient.FeatureToggleClient,
+  IdentityServicesClient: _identityServicesClient.IdentityServicesClient,
+  InstagramApiClient: _instagramApiClient.InstagramApiClient,
+  InstagramVideoClient: _InstagramVideoClient.InstagramVideoClient,
+  IRClient: _irClient.IRClient,
+  LinkedInApiClient: _linkedInApiClient.LinkedInApiClient,
+  TikTokApiClient: _tiktokApiClient.TikTokApiClient,
+  MasfClient: _masfClient.MasfClient,
+  WarpZoneApiClient: _WarpZoneApiClient.WarpZoneApiClient,
+  DocumentHelperFunctions,
+  LinkedInHelpers
 };

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,271 @@
+import superagent from 'superagent';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+const INSTAGRAM_URL = 'https://graph.facebook.com';
+async function requestApi(apiUrl, accessToken, text, data) {
+  let discussionType = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 're';
+  let adCampaign = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : undefined;
+  let logger = arguments.length > 6 ? arguments[6] : undefined;
+  let response = {};
+  try {
+    let queryStringArgs = {
+      access_token: accessToken
+    };
+    if (adCampaign) {
+      queryStringArgs.ad_id = adCampaign.adAccountId;
+    }
+    if (text) {
+      queryStringArgs[discussionType === 'dm' ? 'text' : 'message'] = text;
+    }
+    response = await superagent.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(queryStringArgs).send(data);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      loggerError(logger, `Failed to call instagram api: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  loggerDebug(logger, 'Instagram Response status', response.status);
+  return response;
+}
+async function getPost(apiUrl, accessToken, fields, logger) {
+  let response = {};
+  try {
+    response = await superagent.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query({
+      fields: fields
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body) {
+      loggerError(logger, `Failed to call instagram api`, err.response.body.error);
+    } else {
+      loggerError(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function getMessageData(accessToken, sourceId, inReplyToId, logger) {
+  let response;
+  try {
+    response = await getPost(`${INSTAGRAM_URL}/${sourceId}`, accessToken, `mentioned_comment.comment_id(${inReplyToId}){id, text, timestamp, media{id,media_url}}`, logger);
+    return response.body;
+  } catch (err) {
+    loggerError(logger, `Failed to call instagram api`, err);
+    return null;
+  }
+}
+async function mentionRequestApi(apiUrl, accessToken, replayObject, text, logger) {
+  let response = {};
+  try {
+    response = await superagent.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query(replayObject).query({
+      message: text
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      loggerError(logger, `Failed to call instagram api: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function hideApi(apiUrl, accessToken, hideStatus, logger) {
+  let response = {};
+  try {
+    response = await superagent.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query({
+      hide: hideStatus
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body) {
+      loggerError(logger, `Failed to call instagram api`, err.response.body.error);
+    } else {
+      loggerError(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+export async function getLikes(accessToken, externalId, logger) {
+  let response;
+  loggerDebug(logger, `Starting to call instagram getPost api for externalId ${externalId}`);
+  try {
+    response = await getPost(`${INSTAGRAM_URL}/${removePrefix(externalId)}`, accessToken, 'like_count', logger);
+    loggerInfo(logger, `Native Instagram API getPost Response`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    return response.body;
+  } catch (err) {
+    loggerError(logger, 'Error getLikes Instagram ' + externalId, err);
+    return 0;
+  }
+}
+export async function commentOnMention(accessToken, sourceId, inReplyToId, text, logger) {
+  return commentHelper(accessToken, inReplyToId, text, true, sourceId, logger);
+}
+export async function comment(accessToken, sourceId, inReplyToId, text, logger) {
+  return commentHelper(accessToken, inReplyToId, text, false, sourceId, logger);
+}
+async function commentHelper(accessToken, inReplyToId, text, isMention, sourceId, logger) {
+  let response;
+  if (isMention) {
+    response = await mentionRequestApi(`${INSTAGRAM_URL}/${sourceId}/mentions`, accessToken, {
+      media_id: removePrefix(inReplyToId)
+    }, text, logger);
+  } else {
+    response = await requestApi(`${INSTAGRAM_URL}/${removePrefix(inReplyToId)}/comments`, accessToken, text, undefined, 'qt', logger);
+  }
+  loggerInfo(logger, `Native Intagram API Publish Comment Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function replyOnMention(accessToken, inReplyToId, text, sourceId, threadId, logger) {
+  return replyHelper(accessToken, {
+    inReplyToId,
+    text,
+    sourceId,
+    threadId,
+    isMention: true
+  }, logger);
+}
+export async function reply(accessToken, inReplyToId, text) {
+  let adCampaign = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+  let logger = arguments.length > 4 ? arguments[4] : undefined;
+  return replyHelper(accessToken, {
+    inReplyToId,
+    text,
+    isMention: false,
+    adCampaign
+  }, logger);
+}
+async function replyHelper(accessToken, payload, logger) {
+  let response;
+  const {
+    inReplyToId,
+    text,
+    isMention,
+    sourceId,
+    threadId,
+    adCampaign
+  } = payload;
+  loggerDebug(logger, `Starting to call instagram comment api`, {
+    payload: JSON.stringify(payload)
+  });
+  if (isMention) {
+    let messageData = await getMessageData(accessToken, sourceId, inReplyToId, logger);
+    let media_id = null;
+    if (messageData) {
+      media_id = messageData.mentioned_comment.media.id;
+    }
+    response = await mentionRequestApi(`${INSTAGRAM_URL}/${sourceId}/mentions`, accessToken, {
+      media_id: media_id ? media_id : removePrefix(threadId),
+      comment_id: removePrefix(inReplyToId)
+    }, text, logger);
+  } else {
+    response = await requestApi(`${INSTAGRAM_URL}/${removePrefix(inReplyToId)}/replies`, accessToken, text, undefined, 're', adCampaign, logger);
+  }
+  loggerInfo(logger, `Native Instagram API Publish Reply Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function privateMessage(accessToken, profileId, text, logger) {
+  const response = await requestApi(`${INSTAGRAM_URL}/v10.0/me/messages`, accessToken,
+  // this sends in query string leaving out :shrug:
+  undefined, {
+    recipient: {
+      // not :100: this is right
+      id: removePrefix(profileId)
+    },
+    message: {
+      text
+    },
+    // this apparently allows up to 7 days after message 🤔
+    tag: 'HUMAN_AGENT'
+  }, 'dm', logger);
+  loggerInfo(logger, `Native Instagram API Publish Private Message Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function hide(accessToken, externalId, logger) {
+  let response;
+  loggerDebug(logger, `Starting to call instagram hide api`);
+  response = await hideApi(`${INSTAGRAM_URL}/${removePrefix(externalId)}`, accessToken, true, logger);
+  loggerInfo(logger, `Native Instagram API Hide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function unhide(accessToken, externalId, logger) {
+  let response;
+  loggerDebug(logger, `Starting to call instagram unhide api`);
+  response = await hideApi(`${INSTAGRAM_URL}/${removePrefix(externalId)}`, accessToken, false, logger);
+  loggerInfo(logger, `Native Instagram API Unhide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function getAttachment(token, externalId, logger) {
+  try {
+    const result = await getPost(`${INSTAGRAM_URL}/${removePrefix(externalId)}`, token, 'media_url,children{media_url}', logger);
+    const res = result.body;
+    if (res?.children?.data?.length) {
+      return {
+        images: res.children.data.map(item => {
+          return {
+            source: item?.media_url
+          };
+        })
+      };
+    }
+    return {
+      images: [{
+        source: res?.media_url
+      }]
+    };
+  } catch (error) {
+    loggerError(logger, `Error getting instagram attachment`, error);
+    throw error;
+  }
+}

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

@@ -21,6 +21,7 @@ import * as TiktokNative from './http/tiktok.native.js';
 import * as YoutubeNative from './http/youtube.native.js';
 import * as LinkedinNative from './http/linkedin.native.js';
 import * as TwitterNative from './http/twitter.native.js';
+import * as InstagramNative from './http/instagram.native.js';
 const DocumentHelperFunctions = {
   ...messageHelpers,
   ...applicationTagFunctions,
@@ -30,4 +31,28 @@ const LinkedInHelpers = {
   getOrganization,
   getProfile
 };
-export { FacebookNative, TiktokNative, YoutubeNative, LinkedinNative, TwitterNative, awsS3Client, assetManagerTvmRepository, CompanyApiClient, CredentialsApiClient, EntitlementsApiClient, FacebookApiClient, FeatureToggleClient, IdentityServicesClient, InstagramApiClient, InstagramVideoClient, IRClient, LinkedInApiClient, TikTokApiClient, MasfClient, WarpZoneApiClient, DocumentHelperFunctions, LinkedInHelpers };
+export default {
+  InstagramNative,
+  FacebookNative,
+  TiktokNative,
+  YoutubeNative,
+  LinkedinNative,
+  TwitterNative,
+  awsS3Client,
+  assetManagerTvmRepository,
+  CompanyApiClient,
+  CredentialsApiClient,
+  EntitlementsApiClient,
+  FacebookApiClient,
+  FeatureToggleClient,
+  IdentityServicesClient,
+  InstagramApiClient,
+  InstagramVideoClient,
+  IRClient,
+  LinkedInApiClient,
+  TikTokApiClient,
+  MasfClient,
+  WarpZoneApiClient,
+  DocumentHelperFunctions,
+  LinkedInHelpers
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@meltwater/conversations-api-services",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "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",
   "exports": {
-    "require": "./dist/cjs/data-access/index.js",
-    "import": "./dist/esm/data-access/index.js"
+    ".": {
+      "require": "./dist/cjs/data-access/index.js",
+      "import": "./dist/esm/data-access/index.js"
+    }
   },
   "directories": {
     "doc": "docs"
@@ -16,7 +18,8 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "build:cjs": "BABEL_ENV=cjs babel src --out-dir dist/cjs",
     "build:esm": "BABEL_ENV=esm babel src --out-dir dist/esm",
-    "build": "npm run build:cjs && npm run build:esm"
+    "build": "npm run build:cjs && npm run build:esm && npm run postbuild",
+    "postbuild": "node scripts/create-package-json.js"
   },
   "repository": {
     "type": "git",

package/scripts/create-package-json.js

@@ -0,0 +1,22 @@
+const fs = require('fs');
+const path = require('path');
+
+const esmDir = path.join(__dirname, '../dist/esm');
+const cjsDir = path.join(__dirname, '../dist/cjs');
+
+// Function to write package.json
+function writePackageJson(dir, content) {
+  const packageJsonPath = path.join(dir, 'package.json');
+  fs.writeFileSync(packageJsonPath, JSON.stringify(content, null, 2), 'utf8');
+  console.log(`Created package.json in ${dir}`);
+}
+
+// Create package.json for ESM
+writePackageJson(esmDir, {
+  type: 'module',
+});
+
+// Create package.json for CJS (optional)
+writePackageJson(cjsDir, {
+  type: 'commonjs',
+});

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

@@ -0,0 +1,477 @@
+import superagent from 'superagent';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+
+
+const INSTAGRAM_URL = 'https://graph.facebook.com';
+
+
+async function requestApi(
+    apiUrl,
+    accessToken,
+    text,
+    data,
+    discussionType = 're',
+    adCampaign = undefined,
+    logger
+) {
+    let response = {};
+
+    try {
+        let queryStringArgs = { access_token: accessToken };
+        if (adCampaign) {
+            queryStringArgs.ad_id = adCampaign.adAccountId;
+        }
+        if (text) {
+            queryStringArgs[
+                discussionType === 'dm' ? 'text' : 'message'
+            ] = text;
+        }
+
+        response = await superagent
+            .post(apiUrl)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .query(queryStringArgs)
+            .send(data);
+    } catch (err) {
+        if (
+            err &&
+            err.response &&
+            err.response.body &&
+            err.response.body.error
+        ) {
+            loggerError(logger,
+                `Failed to call instagram api: ${err.response.body.error.message}`
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call instagram api`,
+                err
+            );
+        }
+        throw err;
+    }
+
+    if (response.status !== 200) {
+        loggerError(logger,
+            `Failed to call instagram api`,
+            { responseBody: JSON.stringify(response.body) }
+        );
+        let error = new Error(
+            `Failed to call instagram api`
+        );
+        error.code = response.status;
+        throw error;
+    }
+    loggerDebug(logger,'Instagram Response status', response.status)
+    return response;
+}
+
+async function getPost(apiUrl, accessToken, fields, logger) {
+
+    let response = {};
+    try {
+        response = await superagent
+            .get(apiUrl)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .query({ access_token: accessToken })
+            .query({ fields: fields })
+            .send();
+    } catch (err) {
+        if (err && err.response && err.response.body) {
+            loggerError(logger,
+                `Failed to call instagram api`,
+                err.response.body.error
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call instagram api`,
+                err
+            );
+        }
+        throw err;
+    }
+
+    if (response.status !== 200) {
+        loggerError(logger,
+            `Failed to call instagram api`,
+            { responseBody: JSON.stringify(response.body) }
+        );
+        let error = new Error(
+            `Failed to call instagram api`
+        );
+        error.code = response.status;
+        throw error;
+    }
+    return response;
+}
+
+async function getMessageData(accessToken, sourceId, inReplyToId, logger) {
+    let response;
+
+    try {
+        response = await getPost(
+            `${INSTAGRAM_URL}/${sourceId}`,
+            accessToken,
+            `mentioned_comment.comment_id(${inReplyToId}){id, text, timestamp, media{id,media_url}}`,
+            logger
+        );
+
+        return response.body;
+    } catch (err) {
+        loggerError(logger,
+            `Failed to call instagram api`,
+            err
+        );
+
+        return null;
+    }
+}
+
+async function mentionRequestApi(
+    apiUrl,
+    accessToken,
+    replayObject,
+    text,
+    logger
+) {
+    let response = {};
+
+    try {
+        response = await superagent
+            .post(apiUrl)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .query({ access_token: accessToken })
+            .query(replayObject)
+            .query({ message: text })
+            .send();
+    } catch (err) {
+        if (
+            err &&
+            err.response &&
+            err.response.body &&
+            err.response.body.error
+        ) {
+            loggerError(logger,
+                `Failed to call instagram api: ${err.response.body.error.message}`
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call instagram api`,
+                err
+            );
+        }
+        throw err;
+    }
+
+    if (response.status !== 200) {
+        loggerError(logger,
+            `Failed to call instagram api`,
+            { responseBody: JSON.stringify(response.body) }
+        );
+        let error = new Error(
+            `Failed to call instagram api`
+        );
+        error.code = response.status;
+        throw error;
+    }
+    return response;
+}
+
+async function hideApi(apiUrl, accessToken, hideStatus, logger) {
+    let response = {};
+    try {
+        response = await superagent
+            .post(apiUrl)
+            .set('Accept', 'application/json')
+            .set('Content-Type', 'application/json')
+            .query({ access_token: accessToken })
+            .query({ hide: hideStatus })
+            .send();
+    } catch (err) {
+        if (err && err.response && err.response.body) {
+            loggerError(logger,
+                `Failed to call instagram api`,
+                err.response.body.error
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call instagram api`,
+                err
+            );
+        }
+        throw err;
+    }
+
+    if (response.status !== 200) {
+        loggerError(logger,
+            `Failed to call instagram api`,
+            { responseBody: JSON.stringify(response.body) }
+        );
+        let error = new Error(
+            `Failed to call instagram api`
+        );
+        error.code = response.status;
+        throw error;
+    }
+    return response;
+}
+
+export async function getLikes(accessToken, externalId, logger) {
+    let response;
+    loggerDebug(logger,
+        `Starting to call instagram getPost api for externalId ${externalId}`
+    );
+    try {
+        response = await getPost(
+            `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+            accessToken,
+            'like_count',
+            logger
+        );
+
+        loggerInfo(logger,
+            `Native Instagram API getPost Response`,
+            { responseBody: JSON.stringify(response.body) }
+        );
+        return response.body;
+    } catch (err) {
+        loggerError(logger,'Error getLikes Instagram '+externalId,err);
+        return 0;
+    }
+}
+
+export async function commentOnMention(accessToken, sourceId, inReplyToId, text, logger) {
+    return commentHelper(accessToken, inReplyToId, text, true, sourceId, logger);
+}
+
+export async function comment(accessToken, sourceId, inReplyToId, text, logger) {
+    return commentHelper(accessToken, inReplyToId, text, false, sourceId, logger);
+}
+
+async function commentHelper(accessToken, inReplyToId, text, isMention, sourceId, logger) {
+    let response;
+
+    if (isMention) {
+        response = await mentionRequestApi(
+            `${INSTAGRAM_URL}/${sourceId}/mentions`,
+            accessToken,
+            { media_id: removePrefix(inReplyToId) },
+            text,
+            logger
+        );
+    } else {
+        response = await requestApi(
+            `${INSTAGRAM_URL}/${removePrefix(inReplyToId)}/comments`,
+            accessToken,
+            text,
+            undefined,
+            'qt',
+            logger
+        );
+    }
+
+    loggerInfo(logger,
+        `Native Intagram API Publish Comment Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function replyOnMention(
+    accessToken, 
+    inReplyToId,
+    text,
+    sourceId,
+    threadId,
+    logger
+) {
+    return replyHelper(
+        accessToken, 
+        {
+            inReplyToId,
+            text,
+            sourceId,
+            threadId,
+            isMention:true
+        }, 
+        logger
+    );
+}
+
+export async function reply(
+    accessToken, 
+    inReplyToId,
+    text,
+    adCampaign = undefined, 
+    logger
+) {
+    return replyHelper(
+        accessToken, 
+        {
+            inReplyToId, 
+            text, 
+            isMention:false, 
+            adCampaign,
+        }, 
+        logger
+    );
+}
+
+async function replyHelper(accessToken, payload, logger) {
+    let response;
+    const {
+        inReplyToId,
+        text,
+        isMention,
+        sourceId,
+        threadId,
+        adCampaign,
+    } = payload;
+
+    loggerDebug(logger,
+        `Starting to call instagram comment api`,
+        { payload: JSON.stringify(payload) }
+    );
+
+    if (isMention) {
+        let messageData = await getMessageData(
+            accessToken,
+            sourceId,
+            inReplyToId,
+            logger
+        );
+        let media_id = null;
+
+        if (messageData) {
+            media_id = messageData.mentioned_comment.media.id;
+        }
+
+        response = await mentionRequestApi(
+            `${INSTAGRAM_URL}/${sourceId}/mentions`,
+            accessToken,
+            {
+                media_id: media_id ? media_id : removePrefix(threadId),
+                comment_id: removePrefix(inReplyToId),
+            },
+            text,
+            logger
+        );
+    } else {
+        response = await requestApi(
+            `${INSTAGRAM_URL}/${removePrefix(inReplyToId)}/replies`,
+            accessToken,
+            text,
+            undefined,
+            're',
+            adCampaign,
+            logger
+        );
+    }
+
+    loggerInfo(logger,
+        `Native Instagram API Publish Reply Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function privateMessage(accessToken, profileId, text, logger) {
+    const response = await requestApi(
+        `${INSTAGRAM_URL}/v10.0/me/messages`,
+        accessToken,
+        // this sends in query string leaving out :shrug:
+        undefined,
+        {
+            recipient: {
+                // not :100: this is right
+                id: removePrefix(profileId),
+            },
+            message: {
+                text,
+            },
+            // this apparently allows up to 7 days after message 🤔
+            tag: 'HUMAN_AGENT',
+        },
+        'dm',
+        logger
+    );
+
+    loggerInfo(logger,
+        `Native Instagram API Publish Private Message Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function hide(accessToken, externalId, logger) {
+    let response;
+
+    loggerDebug(logger,
+        `Starting to call instagram hide api`,
+    );
+
+    response = await hideApi(
+        `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+        accessToken,
+        true,
+        logger
+    );
+
+    loggerInfo(logger, 
+        `Native Instagram API Hide Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function unhide(accessToken, externalId, logger) {
+    let response;
+
+    loggerDebug(logger,
+        `Starting to call instagram unhide api`
+    );
+
+    response = await hideApi(
+        `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+        accessToken,
+        false,
+        logger
+    );
+
+    loggerInfo(logger,
+        `Native Instagram API Unhide Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function getAttachment(token, externalId, logger) {
+    try {
+        const result = await getPost(
+            `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+            token,
+            'media_url,children{media_url}',
+            logger
+        );
+
+        const res = result.body;
+        if (res?.children?.data?.length) {
+            return {
+                images: res.children.data.map((item) => {
+                    return { source: item?.media_url };
+                }),
+            };
+        }
+
+        return {
+            images: [{ source: res?.media_url }],
+        };
+    } catch (error) {
+        loggerError(logger,`Error getting instagram attachment`, error);
+        throw error;
+    }
+}

package/src/data-access/index.js

@@ -21,6 +21,7 @@ import * as TiktokNative from './http/tiktok.native.js';
 import * as YoutubeNative from './http/youtube.native.js';
 import * as LinkedinNative from './http/linkedin.native.js';
 import * as TwitterNative from './http/twitter.native.js';
+import * as InstagramNative from './http/instagram.native.js';
 
 const DocumentHelperFunctions = {
     ...messageHelpers,
@@ -32,7 +33,8 @@ const LinkedInHelpers = {
     getProfile,
 }
 
-export {
+export default {
+    InstagramNative,
     FacebookNative,
     TiktokNative,
     YoutubeNative,