fix conflicts

Author: abhandage

packages/destination-actions/src/destinations/amazon-amc/function.ts

@@ -1,15 +1,10 @@
-import {
-  InvalidAuthenticationError,
-  JSONLikeObject,
-  MultiStatusResponse,
-  PayloadValidationError,
-  RequestClient
-} from '@segment/actions-core'
+import { InvalidAuthenticationError } from '@segment/actions-core'
+import { JSONLikeObject, MultiStatusResponse, PayloadValidationError, RequestClient } from '@segment/actions-core'
 import { AudienceSettings, Settings } from './generated-types'
 import type { Payload } from './syncAudiencesToDSP/generated-types'
-import { AudienceRecord, HashedPIIObject, RecordsResponseType } from './types'
+import { AudienceRecord, HashedPIIObject } from './types'
+import { CONSTANTS, RecordsResponseType, REGEX_EXTERNALUSERID } from './utils'
 import { processHashing } from '../../lib/hashing-utils'
-import { CONSTANTS, REGEX_EXTERNALUSERID, ALPHA_NUMERIC, EMAIL_ALLOWED, NON_DIGIT, SYNC_TO } from './constants'
 import { AMAZON_AMC_API_VERSION } from './versioning-info'
 
 export async function processPayload(
@@ -53,20 +48,7 @@ export async function processPayload(
  */
 export function createPayloadToUploadRecords(payloads: Payload[], audienceSettings: AudienceSettings) {
   const records: AudienceRecord[] = []
-  const [audienceId, connectionId = ''] = payloads[0].audienceId.split(':')
-
-  const { syncTo, advertiserId, amcInstanceId, amcAccountId, amcAccountMarketplaceId } = audienceSettings || {}
-
-  if ((!syncTo || syncTo === SYNC_TO.DSP) && !advertiserId) {
-    throw new PayloadValidationError('Advertiser Id value is required when syncing an audience to DSP')
-  }
-
-  if (syncTo === SYNC_TO.AMC && (!amcInstanceId || !amcAccountId || !amcAccountMarketplaceId)) {
-    throw new PayloadValidationError(
-      'AMC Instance Id, AMC Account Id and AMC Account Marketplace Id value are required when syncing audience to AMC'
-    )
-  }
-
+  const { audienceId } = payloads[0]
   payloads.forEach((payload: Payload) => {
     // Check if the externalUserId matches the pattern
     if (!REGEX_EXTERNALUSERID.test(payload.externalUserId)) {
@@ -89,9 +71,8 @@ export function createPayloadToUploadRecords(payloads: Payload[], audienceSettin
   }
 
   return {
-    records,
-    audienceId,
-    ...(connectionId ? { targetResource: { connectionId } } : {})
+    records: records,
+    audienceId: audienceId
   }
 }
 
@@ -113,27 +94,6 @@ function validateAndPreparePayload(
       return
     }
 
-    const { syncTo, advertiserId, amcInstanceId, amcAccountId, amcAccountMarketplaceId } = audienceSettings || {}
-
-    if ((!syncTo || syncTo === SYNC_TO.DSP) && !advertiserId) {
-      multiStatusResponse.setErrorResponseAtIndex(originalBatchIndex, {
-        status: 400,
-        errortype: 'PAYLOAD_VALIDATION_FAILED',
-        errormessage: 'Advertiser Id value is required when syncing an audience to DSP'
-      })
-      return
-    }
-
-    if (syncTo === SYNC_TO.AMC && (!amcInstanceId || !amcAccountId || !amcAccountMarketplaceId)) {
-      multiStatusResponse.setErrorResponseAtIndex(originalBatchIndex, {
-        status: 400,
-        errortype: 'PAYLOAD_VALIDATION_FAILED',
-        errormessage:
-          'AMC Instance Id, AMC Account Id and AMC Account Marketplace Id value are required when syncing audience to AMC'
-      })
-      return
-    }
-
     const hashedPII = hashedPayload(payload)
     const payloadRecord: AudienceRecord = {
       externalUserId: payload.externalUserId,
@@ -178,13 +138,10 @@ export async function processBatchPayload(
     return multiStatusResponse
   }
 
-  const [audienceId, connectionId = ''] = payloads[0].audienceId.split(':')
-
-  const payloadString = JSON.stringify({
-    audienceId: audienceId,
-    records: filteredPayloads,
-    ...(connectionId ? { targetResource: { connectionId } } : {})
-  }).replace(/"audienceId":"(\d+)"/, '"audienceId":$1')
+  const payloadString = JSON.stringify({ audienceId: payloads[0].audienceId, records: filteredPayloads }).replace(
+    /"audienceId":"(\d+)"/,
+    '"audienceId":$1'
+  )
 
   const response = await request<RecordsResponseType>(`${settings.region}/amc/audiences/records`, {
     method: 'POST',
@@ -244,17 +201,22 @@ function normalize(value: string, allowedChars: RegExp, trim = true): string {
   return normalized
 }
 
+// Define allowed character patterns
+const alphanumeric = /[^a-z0-9]/g
+const emailAllowed = /[^a-z0-9.@-]/g
+const nonDigits = /[^\d]/g
+
 // Combine city,state,firstName,lastName normalization
 function normalizeStandard(value: string): string {
-  return normalize(value, ALPHA_NUMERIC)
+  return normalize(value, alphanumeric)
 }
 
 function normalizePhone(phone: string): string {
-  return normalize(phone, NON_DIGIT)
+  return normalize(phone, nonDigits)
 }
 
 function normalizeEmail(email: string): string {
-  return normalize(email, EMAIL_ALLOWED)
+  return normalize(email, emailAllowed)
 }
 
 /**

packages/destination-actions/src/destinations/amazon-amc/generated-types.ts

@@ -1,19 +1,20 @@
 import {
   AudienceDestinationDefinition,
   InvalidAuthenticationError,
-  PayloadValidationError,
+  IntegrationError,
   defaultValues
 } from '@segment/actions-core'
+import type { RefreshTokenResponse, AmazonTestAuthenticationError } from './types'
+import type { Settings, AudienceSettings } from './generated-types'
 import {
-  RefreshTokenResponse,
-  AmazonTestAuthenticationError,
   AudiencePayload,
-  DSPTargetResource,
-  AMCTargetResource
-} from './types'
-import type { Settings, AudienceSettings } from './generated-types'
-import { extractNumberAndSubstituteWithStringValue, getAuthToken } from './utils'
-import { SYNC_TO, REGEX_AUDIENCEID, REGEX_ADVERTISERID, TTL_MAX_VALUE } from './constants'
+  extractNumberAndSubstituteWithStringValue,
+  getAuthToken,
+  REGEX_ADVERTISERID,
+  REGEX_AUDIENCEID,
+  TTL_MAX_VALUE
+} from './utils'
+import { AMAZON_AMC_AUTH_API_VERSION } from './versioning-info'
 import syncAudiencesToDSP from './syncAudiencesToDSP'
 
 const destination: AudienceDestinationDefinition<Settings, AudienceSettings> = {
@@ -76,17 +77,6 @@ const destination: AudienceDestinationDefinition<Settings, AudienceSettings> = {
   },
 
   audienceFields: {
-    syncTo: {
-      type: 'string',
-      label: 'Sync To',
-      required: false,
-      description: 'Chose whether to sync audience to DSP or AMC. Defaults to DSP.',
-      choices: [
-        { label: 'DSP', value: SYNC_TO.DSP },
-        { label: 'AMC', value: SYNC_TO.AMC }
-      ],
-      default: SYNC_TO.DSP
-    },
     description: {
       type: 'string',
       label: 'Description',
@@ -141,23 +131,9 @@ const destination: AudienceDestinationDefinition<Settings, AudienceSettings> = {
     //As per the discussion, for now taking `advertiserId` in `audienceFields` as user can create multiple audiences within a single instance of destination.
     advertiserId: {
       label: 'Advertiser ID',
-      description: 'Advertiser ID when when syncing an Audience to Amazon Ads DSP',
-      type: 'string'
-    },
-    amcInstanceId: {
-      label: 'AMC Instance ID',
-      description: 'AMC Instance ID used when syncing an audience to Amazon Marketing Cloud (AMC)',
-      type: 'string'
-    },
-    amcAccountId: {
-      label: 'AMC Account ID',
-      description: 'AMC Account ID used when syncing an audience to Amazon Marketing Cloud (AMC)',
-      type: 'string'
-    },
-    amcAccountMarketplaceId: {
-      label: 'AMC Account Marketplace ID',
-      description: 'AMC Account Marketplace ID used when syncing an audience to Amazon Marketing Cloud (AMC)',
-      type: 'string'
+      description: 'Advertiser Id',
+      type: 'string',
+      required: true
     }
   },
 
@@ -169,115 +145,64 @@ const destination: AudienceDestinationDefinition<Settings, AudienceSettings> = {
     async createAudience(request, createAudienceInput) {
       const { audienceName, audienceSettings, settings } = createAudienceInput
       const endpoint = settings.region
+      const description = audienceSettings?.description
+      const advertiser_id = audienceSettings?.advertiserId
+      const external_audience_id = audienceSettings?.externalAudienceId
+      const country_code = audienceSettings?.countryCode
+      const ttl = audienceSettings?.ttl
+      const currency = audienceSettings?.currency
+      const cpm_cents = audienceSettings?.cpmCents
 
-      const {
-        syncTo = SYNC_TO.DSP,
-        description,
-        advertiserId,
-        externalAudienceId,
-        countryCode,
-        ttl,
-        currency,
-        cpmCents,
-        amcInstanceId,
-        amcAccountId,
-        amcAccountMarketplaceId
-      } = audienceSettings || {}
-
-      if (syncTo === SYNC_TO.DSP && !advertiserId) {
-        throw new PayloadValidationError('Advertiser Id value is required when syncing an audience to DSP')
-      }
-
-      if (syncTo === SYNC_TO.AMC && (!amcInstanceId || !amcAccountId || !amcAccountMarketplaceId)) {
-        throw new PayloadValidationError(
-          'AMC Instance Id, AMC Account Id and AMC Account Marketplace Id value are required when syncing audience to AMC'
-        )
+      if (!advertiser_id) {
+        throw new IntegrationError('Missing advertiserId Value', 'MISSING_REQUIRED_FIELD', 400)
       }
 
       if (!description) {
-        throw new PayloadValidationError('Missing description Value')
+        throw new IntegrationError('Missing description Value', 'MISSING_REQUIRED_FIELD', 400)
       }
 
-      if (!externalAudienceId) {
-        throw new PayloadValidationError('Missing externalAudienceId Value')
+      if (!external_audience_id) {
+        throw new IntegrationError('Missing externalAudienceId Value', 'MISSING_REQUIRED_FIELD', 400)
       }
 
       if (!audienceName) {
-        throw new PayloadValidationError('Missing audienceName Value')
+        throw new IntegrationError('Missing audienceName Value', 'MISSING_REQUIRED_FIELD', 400)
       }
-
-      if (!countryCode) {
-        throw new PayloadValidationError('Missing countryCode Value')
+      if (!country_code) {
+        throw new IntegrationError('Missing countryCode Value', 'MISSING_REQUIRED_FIELD', 400)
       }
-
       if (ttl && ttl > TTL_MAX_VALUE) {
-        throw new PayloadValidationError(`TTL must have value less than or equal to ${TTL_MAX_VALUE}`)
-      }
-
-      let connectionId: string | undefined = undefined
-      if (syncTo === SYNC_TO.AMC) {
-        const payloadStringConnsAPI = JSON.stringify({ amcInstanceId, amcAccountId, amcAccountMarketplaceId })
-        const response = await request(`${endpoint}/amc/audiences/connections`, {
-          method: 'POST',
-          body: payloadStringConnsAPI,
-          headers: {
-            'Content-Type': 'application/vnd.amcaudiencesconnections.v1+json'
-          }
-        })
-
-        connectionId = JSON.parse(await response.text())?.connectionId
-        if (!connectionId) {
-          throw new PayloadValidationError(
-            'Unable to fetch connectionId with given AMC amcInstanceId amcAccountId and amcAccountMarketplaceId details'
-          )
-        }
+        throw new IntegrationError(`TTL must have value less than or equal to ${TTL_MAX_VALUE}`, 'INVALID_INPUT', 400)
       }
 
       const payload: AudiencePayload = {
         name: audienceName,
-        description,
-        targetResource: (() => {
-          if (syncTo === SYNC_TO.AMC) {
-            const targetResource: AMCTargetResource = {
-              amcInstanceId: amcInstanceId as string,
-              amcAccountId: amcAccountId as string,
-              amcAccountMarketplaceId: amcAccountMarketplaceId as string,
-              connectionId: connectionId as string
-            }
-            return targetResource
-          }
-          if (syncTo === SYNC_TO.DSP) {
-            const targetResource: DSPTargetResource = {
-              advertiserId: advertiserId as string
-            }
-            return targetResource
-          }
-          throw new PayloadValidationError('Invalid syncTo value')
-        })(),
+        description: description,
+        targetResource: {
+          advertiserId: advertiser_id
+        },
         metadata: {
-          externalAudienceId
+          externalAudienceId: external_audience_id
         },
-        countryCode
+        countryCode: country_code
       }
 
       if (ttl) {
         payload.metadata.ttl = ttl
       }
 
-      if (cpmCents && currency) {
+      if (cpm_cents && currency) {
         payload.metadata.audienceFees = []
         payload.metadata?.audienceFees.push({
           currency,
-          cpmCents
+          cpmCents: cpm_cents
         })
       }
 
       let payloadString = JSON.stringify(payload)
       // Regular expression to find a advertiserId numeric string and replace the quoted advertiserId string with an unquoted number
       // AdvertiserId is very big number string and can not be assigned or converted to number directly as it changes the value due to integer overflow.
-      if (syncTo === SYNC_TO.DSP) {
-        payloadString = payloadString.replace(REGEX_ADVERTISERID, '"advertiserId":$1')
-      }
+      payloadString = payloadString.replace(REGEX_ADVERTISERID, '"advertiserId":$1')
 
       const response = await request(`${endpoint}/amc/audiences/metadata`, {
         method: 'POST',
@@ -292,17 +217,17 @@ const destination: AudienceDestinationDefinition<Settings, AudienceSettings> = {
       // Regular expression to find a audienceId number and replace the audienceId with quoted string
       const resp = extractNumberAndSubstituteWithStringValue(res, REGEX_AUDIENCEID, '"audienceId":"$1"')
       return {
-        externalId: syncTo === SYNC_TO.DSP ? resp.audienceId : resp.audienceId + ':' + connectionId
+        externalId: resp.audienceId
       }
     },
 
     async getAudience(request, getAudienceInput) {
       // getAudienceInput.externalId represents audience ID that was created in createAudience
-      const audience_id = getAudienceInput.externalId.split(':')[0]
+      const audience_id = getAudienceInput.externalId
       const { settings } = getAudienceInput
       const endpoint = settings.region
       if (!audience_id) {
-        throw new PayloadValidationError('Missing audienceId value')
+        throw new IntegrationError('Missing audienceId value', 'MISSING_REQUIRED_FIELD', 400)
       }
       const response = await request(`${endpoint}/amc/audiences/metadata/${audience_id}`, {
         method: 'GET',