chore: add network handler with tests

src/v0/destinations/amazon_audience/config.js

@@ -1,4 +1,5 @@
 const CREATE_USERS_URL = 'https://advertising-api.amazon.com/dp/records/hashed/';
 const ASSOCIATE_USERS_URL = 'https://advertising-api.amazon.com/dp/records/hashed/';
 const MAX_PAYLOAD_SIZE_IN_BYTES = 4000000;
-module.exports = { CREATE_USERS_URL, MAX_PAYLOAD_SIZE_IN_BYTES, ASSOCIATE_USERS_URL };
+const DESTINATION = 'amazon_audience';
+module.exports = { CREATE_USERS_URL, MAX_PAYLOAD_SIZE_IN_BYTES, ASSOCIATE_USERS_URL, DESTINATION };

src/v0/destinations/amazon_audience/networkHandler.js

@@ -0,0 +1,124 @@
+const {
+  NetworkError,
+  ThrottledError,
+  AbortedError,
+  RetryableError,
+} = require('@rudderstack/integrations-lib');
+const { prepareProxyRequest, handleHttpRequest } = require('../../../adapters/network');
+const { isHttpStatusSuccess } = require('../../util/index');
+const {
+  processAxiosResponse,
+  getDynamicErrorType,
+} = require('../../../adapters/utils/networkUtils');
+const { REFRESH_TOKEN } = require('../../../adapters/networkhandler/authConstants');
+const { DESTINATION, CREATE_USERS_URL, ASSOCIATE_USERS_URL } = require('./config');
+const { TAG_NAMES } = require('../../util/tags');
+
+const amazonAudienceRespHandler = (destResponse, stageMsg) => {
+  const { status, response } = destResponse;
+
+  // to handle the case when authorization-token is invalid
+  // docs for error codes: https://advertising.amazon.com/API/docs/en-us/reference/concepts/errors#tag/Audiences/operation/dspCreateAudiencesPost
+  if (status === 401) {
+    // 401 takes place in case of authorization isue meaning token is epxired or access is not enough.
+    // Since acces is configured from dashboard only refresh token makes sense
+    throw new NetworkError(
+      `${response?.message} ${stageMsg}`,
+      status,
+      {
+        [TAG_NAMES.ERROR_TYPE]: getDynamicErrorType(status),
+      },
+      response,
+      REFRESH_TOKEN,
+    );
+  } else if (status === 429) {
+    throw new ThrottledError(
+      `Request Failed: ${stageMsg} - due to Request Limit exceeded, (Throttled)`,
+      destResponse,
+    );
+  } else if (status === 504 || status === 502 || status === 500) {
+    // see if its 5xx internal error
+    throw new RetryableError(`Request Failed: ${stageMsg} (Retryable)`, 500, destResponse);
+  }
+  // else throw the error
+  throw new AbortedError(
+    `Request Failed: ${stageMsg} with status "${status}" due to "${JSON.stringify(
+      response,
+    )}", (Aborted) `,
+    400,
+    destResponse,
+  );
+};
+
+const responseHandler = (responseParams) => {
+  const { destinationResponse } = responseParams;
+  const message = `[${DESTINATION} Response Handler] - Request Processed Successfully`;
+  const { status } = destinationResponse;
+
+  if (!isHttpStatusSuccess(status)) {
+    // if error, successfully return status, message and original destination response
+    amazonAudienceRespHandler(
+      destinationResponse,
+      'during amazon_audience response transformation',
+    );
+  }
+  return {
+    status,
+    message,
+    destinationResponse,
+  };
+};
+
+const makeRequest = async (url, data, headers, metadata, method) => {
+  const { httpResponse } = await handleHttpRequest(
+    method,
+    url,
+    data,
+    { headers },
+    {
+      destType: 'amazon_audience',
+      feature: 'proxy',
+      endpointPath: '/records/hashed',
+      requestMethod: 'POST',
+      module: 'dataDelivery',
+      metadata,
+    },
+  );
+  return httpResponse;
+};
+
+const amazonAudienceProxyRequest = async (request) => {
+  const { body, metadata } = request;
+  const { headers } = request;
+  const { JSON } = body;
+  const { createUsers, associateUsers } = JSON;
+
+  // step 1: Create users
+  const firstResponse = await makeRequest(CREATE_USERS_URL, createUsers, headers, metadata, 'post');
+  // validate response success
+  if (!firstResponse.success && !isHttpStatusSuccess(firstResponse?.response?.status)) {
+    amazonAudienceRespHandler(
+      {
+        response: firstResponse.response?.response?.data || firstResponse,
+        status: firstResponse.response?.response?.status || firstResponse,
+      },
+      'during creating users',
+    );
+  }
+  // we are returning above in case of failure because if first step is not executed then there is no sense of executing second step
+  // step2: Associate Users to Audience Id
+  return makeRequest(ASSOCIATE_USERS_URL, associateUsers, headers, metadata, 'patch');
+};
+// eslint-disable-next-line @typescript-eslint/naming-convention
+class networkHandler {
+  constructor() {
+    this.responseHandler = responseHandler;
+    this.proxy = amazonAudienceProxyRequest;
+    this.prepareProxy = prepareProxyRequest;
+    this.processAxiosResponse = processAxiosResponse;
+  }
+}
+
+module.exports = {
+  networkHandler,
+};

src/v0/destinations/amazon_audience/transform.js

@@ -22,7 +22,7 @@ const process = (event) => {
   const { message, destination, metadata } = event;
   const { Config } = destination;
   const { user, action } = processRecord(message, Config);
-  return buildResponseWithUsers([user], action, Config, [metadata.jobId]);
+  return buildResponseWithUsers([user], action, Config, [metadata.jobId], metadata.secret);
 };
 // This function is used to process multiple records
 const processRouterDest = async (inputs, reqMetadata) => {

src/v0/destinations/amazon_audience/utils.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 const sha256 = require('sha256');
 const lodash = require('lodash');
-const { ConfigurationError } = require('@rudderstack/integrations-lib');
+const { ConfigurationError, OAuthSecretError } = require('@rudderstack/integrations-lib');
 const {
   defaultRequestConfig,
   defaultPostRequestConfig,
@@ -10,15 +10,26 @@ const {
 } = require('../../util');
 
 // Docs: https://developer.x.com/en/docs/x-ads-api/audiences/api-reference/custom-audience-user
-const buildResponseWithUsers = (users, action, config, jobIdList) => {
+const buildResponseWithUsers = (users, action, config, jobIdList, secret) => {
   const { audienceId } = config;
   if (!audienceId) {
     throw new ConfigurationError('[AMAZON AUDIENCE]: Audience Id not found');
   }
+  if (!secret?.accessToken) {
+    throw new OAuthSecretError('OAuth - access token not found');
+  }
+  if (!secret?.clientId) {
+    throw new OAuthSecretError('OAuth - Client Id not found');
+  }
   const externalId = `Rudderstack_${sha256(`${jobIdList}`)}`;
   const response = defaultRequestConfig();
   response.endpoint = '';
   response.method = defaultPostRequestConfig.requestMethod;
+  response.headers = {
+    'Amazon-Advertising-API-ClientId': `${secret.clientId}`,
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${secret.accessToken}`,
+  };
   response.body.JSON = {
     createUsers: {
       records: [
@@ -64,8 +75,10 @@ const groupResponsesUsingOperation = (respList) => {
  * @param {*} responseList 
  */
 const batchEvents = (responseList, destination) => {
+  const { secret } = responseList[0].metadata;
   const eventGroups = groupResponsesUsingOperation(responseList);
   const respList = [];
+
   Object.keys(eventGroups).forEach((op) => {
     const { userList, jobIdList, metadataList } = eventGroups[op].reduce(
       (acc, event) => ({
@@ -77,7 +90,13 @@ const batchEvents = (responseList, destination) => {
     );
     respList.push(
       getSuccessRespEvents(
-        buildResponseWithUsers(userList, op, destination.config || destination.Config, jobIdList),
+        buildResponseWithUsers(
+          userList,
+          op,
+          destination.config || destination.Config,
+          jobIdList,
+          secret,
+        ),
         metadataList,
         destination,
         true,

test/integrations/destinations/amazon_audience/common.ts

@@ -21,5 +21,10 @@ export const generateMetadata = (jobId: number, userId?: string): any => {
     destinationId: 'default-destinationId',
     workspaceId: 'default-workspaceId',
     dontBatch: false,
+    secret: {
+      accessToken: 'dummyAccessToken',
+      refreshToken: 'dummyRefreshToken',
+      clientId: 'dummyClientId',
+    },
   };
 };