feat: add support for both v0,v1 in handler for old server support

src/adapters/networkHandlerFactory.js

@@ -8,6 +8,8 @@ const { getIntegrations } = require('../routes/utils');
 
 const handlers = {
   generic: GenericNetworkHandler,
+  v0: {},
+  v1: {},
 };
 
 // Dynamically import the network handlers for all
@@ -16,16 +18,26 @@ SUPPORTED_VERSIONS.forEach((version) => {
   const destinations = getIntegrations(path.resolve(__dirname, `../${version}/destinations`));
   destinations.forEach((dest) => {
     try {
-      handlers[dest] = require(`../${version}/destinations/${dest}/networkHandler`).networkHandler;
+      // handles = {
+      //   v0: {
+      //     dest: handler
+      //   },
+      //   v1: {
+      //     dest: handler
+      //   },
+      // generic: GenericNetworkHandler,
+      // }
+      handlers[version][dest] =
+        require(`../${version}/destinations/${dest}/networkHandler`).networkHandler;
     } catch {
       // Do nothing as exception indicates
       // network handler is not defined for that destination
     }
   });
 });
 
-const getNetworkHandler = (type) => {
-  const NetworkHandler = handlers[type] || handlers.generic;
+const getNetworkHandler = (type, version) => {
+  const NetworkHandler = handlers[version][type] || handlers.generic;
   return new NetworkHandler();
 };
 

src/controllers/delivery.ts

@@ -16,9 +16,15 @@ export class DeliveryController {
     const requestMetadata = MiscService.getRequestMetadata(ctx);
     const event = ctx.request.body as ProcessorTransformationOutput;
     const { destination }: { destination: string } = ctx.params;
+    const { version }: { version: string } = ctx.params;
     const integrationService = ServiceSelector.getNativeDestinationService();
     try {
-      deliveryResponse = await integrationService.deliver(event, destination, requestMetadata);
+      deliveryResponse = await integrationService.deliver(
+        event,
+        destination,
+        requestMetadata,
+        version,
+      );
     } catch (error: any) {
       const metaTO = integrationService.getTags(
         destination,

src/interfaces/DestinationService.ts

@@ -47,6 +47,7 @@ export interface DestinationService {
     event: ProcessorTransformationOutput,
     destinationType: string,
     requestMetadata: NonNullable<unknown>,
+    version: string,
   ): Promise<DeliveryResponse>;
 
   processUserDeletion(

src/services/comparator.ts

@@ -368,11 +368,13 @@ export class ComparatorService implements DestinationService {
     event: ProcessorTransformationOutput,
     destinationType: string,
     requestMetadata: NonNullable<unknown>,
+    version: string,
   ): Promise<DeliveryResponse> {
     const primaryResplist = await this.primaryService.deliver(
       event,
       destinationType,
       requestMetadata,
+      version,
     );
     logger.error('[LIVE_COMPARE_TEST] not implemented for delivery routine');
 

src/services/destination/nativeIntegration.ts

@@ -172,9 +172,10 @@ export class NativeIntegrationDestinationService implements DestinationService {
     destinationRequest: ProcessorTransformationOutput,
     destinationType: string,
     _requestMetadata: NonNullable<unknown>,
+    version: string,
   ): Promise<DeliveryResponse> {
     try {
-      const networkHandler = networkHandlerFactory.getNetworkHandler(destinationType);
+      const networkHandler = networkHandlerFactory.getNetworkHandler(destinationType, version);
       const rawProxyResponse = await networkHandler.proxy(destinationRequest, destinationType);
       const processedProxyResponse = networkHandler.processAxiosResponse(rawProxyResponse);
       return networkHandler.responseHandler(

src/v1/destinations/campaign_manager/networkHandler.js

@@ -11,42 +11,6 @@ const {
 // const { TransformerProxyError } = require('../../util/errorTypes');
 const tags = require('../../../v0/util/tags');
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function checkIfFailuresAreRetryable(response, proxyOutputObj) {
-  const { status } = response;
-  try {
-    if (Array.isArray(status)) {
-      // iterate over each status, and if found retryable in conversations ..retry else discard
-      /* status : [{
-        "conversion": {
-          object (Conversion)
-        },
-        "errors": [
-          {
-            object (ConversionError)
-          }
-        ],
-        "kind": string
-      }] */
-      for (const st of status) {
-        for (const err of st.errors) {
-          // if code is any of these, event is not retryable
-          if (
-            err.code === 'PERMISSION_DENIED' ||
-            err.code === 'INVALID_ARGUMENT' ||
-            err.code === 'NOT_FOUND'
-          ) {
-            return false;
-          }
-        }
-      }
-    }
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
 function isEventRetryable(element, proxyOutputObj) {
   let flag = false;
   let errorMsg = '';