feat: enrich with geo location data during destination transformation

src/helpers/geoLocation.ts

@@ -0,0 +1,54 @@
+import cloneDeep from 'lodash/cloneDeep';
+import isEmpty from 'lodash/isEmpty';
+import set from 'set-value';
+import { FixMe } from '../util/types';
+import { getKeyAndValueFromMessage } from '../v0/util';
+import * as GenericFieldMappingJson from '../v0/util/data/GenericFieldMapping.json';
+
+export default class GeoLocationHelper {
+  public static getAddressKeyAndValue(message: Record<string, FixMe>): {
+    addressKey: string;
+    address: Record<string, FixMe>;
+  } {
+    const { value: address, key: foundKey } =
+      getKeyAndValueFromMessage(message, GenericFieldMappingJson.address) || {};
+    const { key: traitsKey } = getKeyAndValueFromMessage(message, GenericFieldMappingJson.traits);
+    let addressKey = foundKey;
+    if (!foundKey) {
+      addressKey = `${traitsKey}.address`;
+      if (!traitsKey) {
+        [addressKey] = GenericFieldMappingJson.address;
+      }
+    }
+    return { addressKey, address };
+  }
+
+  public static getGeoLocationData(message: Record<string, FixMe>): Record<string, FixMe> {
+    const msg = cloneDeep(message || {});
+    if (isEmpty(msg.context.geo)) {
+      // geo-location data was not sent
+      return {};
+    }
+    const { address, addressKey } = GeoLocationHelper.getAddressKeyAndValue(message);
+    const addressFieldMapping = {
+      city: 'city',
+      country: 'country',
+      postalCode: 'postal',
+      state: 'region',
+    };
+
+    const mappedAddress = Object.entries(addressFieldMapping).reduce(
+      (agg, [identifyAddressKey, geoKey]) => {
+        if (!address?.[identifyAddressKey] && msg?.context?.geo?.[geoKey]) {
+          return { [identifyAddressKey]: msg.context.geo[geoKey], ...agg };
+        }
+        return agg;
+      },
+      {},
+    );
+    if (!isEmpty(address) || !isEmpty(mappedAddress)) {
+      set(msg, addressKey, { ...address, ...mappedAddress });
+    }
+    return msg;
+  }
+}

src/middlewares/enricher.ts

@@ -0,0 +1,51 @@
+import { Context } from 'koa';
+import {
+  ProcessorTransformationRequest,
+  RouterTransformationRequest,
+  RouterTransformationRequestData,
+} from '../types';
+import GeoLocationHelper from '../helpers/geoLocation';
+
+export type DTRequest = RouterTransformationRequest | ProcessorTransformationRequest[];
+
+export default class Enricher {
+  private static enrichWithGeoInfo(
+    data: RouterTransformationRequestData[],
+  ): RouterTransformationRequestData[] {
+    return data.map((inpEv) => {
+      const geoEnrichedMessage = GeoLocationHelper.getGeoLocationData(inpEv.message);
+      return {
+        ...inpEv,
+        message: {
+          ...inpEv.message,
+          ...geoEnrichedMessage,
+        },
+      };
+    });
+  }
+
+  public static enrichGeoLocation(ctx: Context) {
+    const transformationRequest = ctx.request.body;
+    let transformationReq: DTRequest;
+    let reqBody: unknown;
+    const isRouterTransform = Array.isArray(
+      (transformationRequest as RouterTransformationRequest)?.input,
+    );
+    if (isRouterTransform) {
+      // Router or batch transformation request
+      transformationReq = transformationRequest as RouterTransformationRequest;
+      const enrichedEvents: RouterTransformationRequestData[] = Enricher.enrichWithGeoInfo(
+        transformationReq.input,
+      );
+      reqBody = {
+        input: enrichedEvents,
+        destType: transformationReq.destType,
+      };
+    } else {
+      // Processor transformation
+      transformationReq = transformationRequest as ProcessorTransformationRequest[];
+      reqBody = Enricher.enrichWithGeoInfo(transformationReq);
+    }
+    ctx.request.body = reqBody;
+  }
+}

src/types/index.ts

@@ -84,21 +84,44 @@ type UserTransformationLibrary = {
   VersionID: string;
 };
 
-type ProcessorTransformationRequest = {
-  request?: object;
-  message: object;
-  metadata: Metadata;
-  destination: Destination;
-  libraries: UserTransformationLibrary[];
-};
+type RudderTimestamp = Date | string;
+type RudderMessageType =
+  | 'identify'
+  | 'track'
+  | 'page'
+  | 'screen'
+  | 'group'
+  | 'alias'
+  | 'audiencelist';
+
+type RudderMessageSchema = Partial<{
+  userId: string;
+  anonymousId: string;
+  type: RudderMessageType;
+  channel: string;
+  context: object;
+  originalTimestamp: RudderTimestamp;
+  sentAt: RudderTimestamp;
+  timestamp: RudderTimestamp;
+  event: string;
+  integrations: object;
+  messageId: string;
+  properties: object;
+  traits: object;
+  [key: string]: FixMe;
+}>;
 
 type RouterTransformationRequestData = {
   request?: object;
-  message: object;
+  message: RudderMessageSchema;
   metadata: Metadata;
   destination: Destination;
 };
 
+type ProcessorTransformationRequest = {
+  libraries: UserTransformationLibrary[];
+} & RouterTransformationRequestData;
+
 type RouterTransformationRequest = {
   input: RouterTransformationRequestData[];
   destType: string;
@@ -246,4 +269,5 @@ export {
   UserDeletionResponse,
   Destination,
   ComparatorInput,
+  RudderMessageSchema,
 };

src/v0/util/index.js

@@ -659,6 +659,26 @@
   return null;
 };
 
+const getKeyAndValueFromMessage = (message, sourceKeys) => {
+  if (Array.isArray(sourceKeys)) {
+    // got the possible sourceKeys
+    // eslint-disable-next-line no-restricted-syntax
+    for (const sourceKey of sourceKeys) {
+      const val = get(message, sourceKey);
+      if (val || val === false || val === 0) {
+        // return only if the value is valid.
+        // else look for next possible source in precedence
+        return { value: val, key: sourceKey };
+      }
+    }
+  } else if (typeof sourceKeys === 'string') {
+    // got a single key
+    // - we don't need to iterate over a loop for a single possible value
+    return { value: get(message, sourceKeys), key: sourceKeys };
+  }
+  return { value: null, key: '' };
+};
+
 // get a field value from message.
 // if sourceFromGenericMap is true get its value from GenericFieldMapping.json and use it as sourceKey
 // else use sourceKey from `data/message.json` for actual field precedence
@@ -2192,4 +2212,5 @@
   isValidInteger,
   isNewStatusCodesAccepted,
   IsGzipSupported,
+  getKeyAndValueFromMessage,
 };