chore: vdm record v2 changes

🔒 Scanned for secrets using gitleaks 8.29.1

Author: achettyiitr

src/v0/destinations/tiktok_audience/config.ts

@@ -3,6 +3,12 @@ export const ACTION_MAP: Record<string, string> = {
   remove: 'delete',
 };
 
+export const ACTION_RECORD_MAP: Record<string, string> = {
+  insert: 'add',
+  delete: 'remove',
+  update: 'add',
+};
+
 export const SHA256_TRAITS = ['IDFA_SHA256', 'AAID_SHA256', 'EMAIL_SHA256', 'PHONE_SHA256'];
 
 export const BASE_URL = 'https://business-api.tiktok.com/open_api/v1.3';

src/v0/destinations/tiktok_audience/transform.record.ts

@@ -0,0 +1,75 @@
+import md5 from 'md5';
+import { hashToSha256, InstrumentationError, formatZodError } from '@rudderstack/integrations-lib';
+import type { TiktokAudienceRecordRequest } from './types.record';
+import { TiktokAudienceRecordRouterRequestSchema } from './types.record';
+import { SHA256_TRAITS, ENDPOINT, ENDPOINT_PATH, ACTION_RECORD_MAP } from './config';
+import { defaultRequestConfig } from '../../util';
+
+function prepareIdentifiersPayload(event: TiktokAudienceRecordRequest): Record<string, any> {
+  const { message, connection, destination } = event;
+  const { isHashRequired, audienceId } = connection.config.destination;
+  const { advertiserId } = destination.Config;
+  const { action, identifiers } = message;
+
+  const hashIdentifier = (fieldName: string, value: string) => {
+    if (isHashRequired) {
+      if (SHA256_TRAITS.includes(fieldName)) {
+        return hashToSha256(value);
+      }
+      return md5(value);
+    }
+    return value;
+  };
+
+  const identifiersList = Object.entries(identifiers).map(([fieldName, value]) => {
+    if (value) {
+      return {
+        id: hashIdentifier(fieldName, value!),
+        audience_ids: [audienceId],
+      };
+    }
+    return {};
+  });
+
+  const payload = {
+    batch_data: [identifiersList],
+    id_schema: Object.keys(identifiers),
+    advertiser_ids: [advertiserId],
+    action: ACTION_RECORD_MAP[action],
+  };
+  return payload;
+}
+
+function buildResponseForProcessTransformation(
+  payload: Record<string, any>,
+  event: TiktokAudienceRecordRequest,
+) {
+  const accessToken = event.metadata?.secret?.accessToken;
+  const userId = event.message?.userId;
+
+  const response = defaultRequestConfig();
+  response.body.JSON = payload;
+  response.userId = userId;
+  response.endpoint = ENDPOINT;
+  response.endpointPath = ENDPOINT_PATH;
+  response.headers = {
+    'Access-Token': accessToken,
+    'Content-Type': 'application/json',
+  };
+  return response;
+}
+
+function validateAudienceRecordEvent(event: unknown) {
+  const result = TiktokAudienceRecordRouterRequestSchema.safeParse(event);
+  if (!result.success) {
+    throw new InstrumentationError(formatZodError(result.error));
+  }
+  return result.data;
+}
+
+function processTiktokAudienceRecord(event: TiktokAudienceRecordRequest) {
+  const payload = prepareIdentifiersPayload(event);
+  return buildResponseForProcessTransformation(payload, event);
+}
+
+export { validateAudienceRecordEvent, processTiktokAudienceRecord };

src/v0/destinations/tiktok_audience/transform.ts

@@ -1,17 +1,19 @@
 import md5 from 'md5';
 import { hashToSha256, InstrumentationError, formatZodError } from '@rudderstack/integrations-lib';
 import type { RouterTransformationResponse } from '../../../types';
-import type { TiktokAudienceRequest } from './types';
-import { TiktokAudienceRouterRequestSchema } from './types';
+import type { TiktokAudienceListRequest } from './types';
+import { TiktokAudienceListRouterRequestSchema } from './types';
 import { SHA256_TRAITS, ACTION_MAP, ENDPOINT, ENDPOINT_PATH } from './config';
 import {
   defaultRequestConfig,
   getDestinationExternalIDInfoForRetl,
   getSuccessRespEvents,
   handleRtTfSingleEventError,
+  isEventSentByVDMV2Flow,
 } from '../../util';
+import { processTiktokAudienceRecord, validateAudienceRecordEvent } from './transform.record';
 
-function prepareIdentifiersList(event: TiktokAudienceRequest) {
+function prepareIdentifiersList(event: TiktokAudienceListRequest) {
   const { message, destination, metadata } = event;
   const { isHashRequired } = destination.Config;
 
@@ -57,7 +59,7 @@ function prepareIdentifiersList(event: TiktokAudienceRequest) {
 
 function buildResponseForProcessTransformation(
   identifiersList: any[],
-  event: TiktokAudienceRequest,
+  event: TiktokAudienceListRequest,
 ) {
   const accessToken = event.metadata?.secret?.accessToken;
   const anonymousId = event.message?.anonymousId;
@@ -80,21 +82,24 @@ function buildResponseForProcessTransformation(
   return responses;
 }
 
-function validateEvent(event: unknown) {
-  const result = TiktokAudienceRouterRequestSchema.safeParse(event);
+function validateAudienceListEvent(event: unknown) {
+  const result = TiktokAudienceListRouterRequestSchema.safeParse(event);
   if (!result.success) {
     throw new InstrumentationError(formatZodError(result.error));
   }
   return result.data;
 }
 
-function processTiktokAudience(event: TiktokAudienceRequest) {
+function processTiktokAudienceList(event: TiktokAudienceListRequest) {
   const identifierLists = prepareIdentifiersList(event);
   return buildResponseForProcessTransformation(identifierLists, event);
 }
 
 function process(event: unknown) {
-  return processTiktokAudience(validateEvent(event));
+  if (isEventSentByVDMV2Flow(event)) {
+    return processTiktokAudienceRecord(validateAudienceRecordEvent(event));
+  }
+  return processTiktokAudienceList(validateAudienceListEvent(event));
 }
 
 const processRouterDest = async (events: unknown[]): Promise<RouterTransformationResponse[]> => {
@@ -105,8 +110,16 @@ const processRouterDest = async (events: unknown[]): Promise<RouterTransformatio
 
   for (const event of events) {
     try {
-      const tiktokEvent = validateEvent(event);
-      const response = processTiktokAudience(tiktokEvent);
+      let tiktokEvent; let response;
+
+      if (isEventSentByVDMV2Flow(event)) {
+        tiktokEvent = validateAudienceRecordEvent(event);
+        response = processTiktokAudienceRecord(tiktokEvent);
+      } else {
+        tiktokEvent = validateAudienceListEvent(event);
+        response = processTiktokAudienceList(tiktokEvent);
+      }
+
       successfulResponses.push(
         getSuccessRespEvents(response, [tiktokEvent.metadata], tiktokEvent.destination, true),
       );

src/v0/destinations/tiktok_audience/types.record.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+
+const TiktokAudienceDestinationSchema = z
+  .object({
+    Config: z
+      .object({
+        advertiserId: z.string(),
+      })
+      .passthrough(),
+  })
+  .passthrough();
+
+const TiktokAudienceConnectionSchema = z
+  .object({
+    config: z
+      .object({
+        destination: z
+          .object({
+            isHashRequired: z.boolean(),
+            audienceId: z.string(),
+          })
+          .passthrough(),
+      })
+      .passthrough(),
+  })
+  .passthrough();
+
+const TiktokAudienceMessageSchema = z
+  .object({
+    type: z.enum(['record'], {
+      required_error: 'message Type is not present. Aborting message.',
+    }),
+    action: z.enum(['insert', 'delete', 'update'], {
+      required_error: 'action is not present. Aborting message.',
+    }),
+    userId: z.string().optional(),
+    identifiers: z.record(z.string(), z.string().nullable()),
+    fields: z.record(z.string(), z.string().nullable()),
+  })
+  .passthrough();
+
+const TiktokAudienceMetadataSchema = z
+  .object({
+    secret: z
+      .object({
+        accessToken: z.string(),
+      })
+      .passthrough(),
+  })
+  .passthrough();
+
+export const TiktokAudienceRecordRouterRequestSchema = z
+  .object({
+    message: TiktokAudienceMessageSchema,
+    destination: TiktokAudienceDestinationSchema,
+    connection: TiktokAudienceConnectionSchema,
+    metadata: TiktokAudienceMetadataSchema,
+  })
+  .passthrough();
+
+export type TiktokAudienceRecordRequest = z.infer<typeof TiktokAudienceRecordRouterRequestSchema>;

src/v0/destinations/tiktok_audience/types.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { ACTION_MAP } from './config';
 
-export const TiktokAudienceDestinationSchema = z
+const TiktokAudienceDestinationSchema = z
   .object({
     Config: z
       .object({
@@ -11,7 +11,7 @@ export const TiktokAudienceDestinationSchema = z
   })
   .passthrough();
 
-export const TiktokAudienceMessageSchema = z
+const TiktokAudienceMessageSchema = z
   .object({
     type: z.enum(['audienceList'], {
       required_error: 'message Type is not present. Aborting message.',
@@ -59,7 +59,7 @@ export const TiktokAudienceMessageSchema = z
   })
   .passthrough();
 
-export const TiktokAudienceMetadataSchema = z
+const TiktokAudienceMetadataSchema = z
   .object({
     secret: z
       .object({
@@ -70,12 +70,12 @@ export const TiktokAudienceMetadataSchema = z
   })
   .passthrough();
 
-export const TiktokAudienceRouterRequestSchema = z
+export const TiktokAudienceListRouterRequestSchema = z
   .object({
     message: TiktokAudienceMessageSchema,
     destination: TiktokAudienceDestinationSchema,
     metadata: TiktokAudienceMetadataSchema,
   })
   .passthrough();
 
-export type TiktokAudienceRequest = z.infer<typeof TiktokAudienceRouterRequestSchema>;
+export type TiktokAudienceListRequest = z.infer<typeof TiktokAudienceListRouterRequestSchema>;