@mhubcloud/tms_core 1.7.6 → 2.0.0-beta.1

package/src/publishers/piano.ts

@@ -0,0 +1,71 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+
+interface Aux {
+  visitorId: string;
+  ref: string;
+  userAgent?: string;
+  referer?: string;
+  forwardedFor?: string;
+}
+
+interface PianoData {
+  aux: Aux;
+}
+
+export const piano: PlatformPublisher = {
+  source: 'Piano',
+  /**
+   * Publishes data to Piano
+   * @param log zure Function context.log
+   * @param config Publisher configuration
+   * @param data Data in publisher-friendly format to be published
+   * @param event Event for which the function is triggered
+   */
+  async publish(log, config, data, event) {
+    if (
+      typeof config.siteId === 'string' &&
+      typeof config.collectionDomain === 'string'
+    ) {
+      const pianoData = utils.removeUndefined(data) as PianoData;
+      let query = '';
+      // https://developers.atinternet-solutions.com/piano-analytics-tagging-en/event-tagging-piano-analytics-en/events-pattern-en/#post-request_5
+      // https://<collection-domain>/<path>?s=<site-id>&idclient=<visitor-id>&ref=<previous-url>
+      query = '?s=' + encodeURI(config.siteId);
+      query += '&idclient=' + encodeURI(pianoData.aux.visitorId);
+      query += '&ref=' + encodeURI(pianoData.aux.ref);
+
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+      };
+
+      requestOptions.headers = {};
+
+      if (pianoData.aux.userAgent) {
+        requestOptions.headers['User-Agent'] = pianoData.aux.userAgent;
+      }
+      if (pianoData.aux.referer) {
+        requestOptions.headers.Referer = pianoData.aux.referer;
+      }
+      if (pianoData.aux.forwardedFor) {
+        requestOptions.headers['X-Forwarded-For'] = pianoData.aux.forwardedFor;
+      }
+
+      const baseUrl = `https://${config.collectionDomain}/`;
+
+      await utils.handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log,
+      });
+    } else {
+      throw new Error('Invalid config for platform ' + this.source);
+    }
+  },
+};

package/src/publishers/universalAnalytics.ts

@@ -0,0 +1,63 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+import { TypeSafeObject } from '../types/UtilTypes';
+
+export const universalAnalytics: PlatformPublisher = {
+  source: 'UniversalAnalytics',
+  /**
+   * Publishes data to UniversalAnalytics
+   * @param log zure Function context.log
+   * @param config Publisher configuration
+   * @param data Data in publisher-friendly format to be published
+   * @param event Event for which the function is triggered
+   */
+  async publish(log, config, data, event) {
+    if (config.trackingId) {
+      const uaData = utils.removeUndefined(data) as TypeSafeObject;
+      uaData.v = 1;
+      uaData.tid = config.trackingId;
+
+      let payload = '';
+
+      for (const property in uaData) {
+        if (Object.prototype.hasOwnProperty.call(uaData, property)) {
+          if (payload) {
+            payload += '&';
+          }
+          if (uaData[property]) {
+            payload +=
+              encodeURI(property) + '=' + encodeURI(uaData[property] ?? '');
+          }
+        }
+      }
+
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+        body: payload,
+        headers: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'Content-Type': 'application/x-www-form-urlencoded',
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'User-Agent': 'mHub Cloud',
+        },
+      };
+      const baseUrl = 'https://www.google-analytics.com/collect';
+
+      const query = `?${payload}`;
+
+      await utils.handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log,
+      });
+    } else {
+      throw new Error('Invalid config for platform ' + this.source);
+    }
+  },
+};

package/src/types/EventHubMessage.ts

@@ -0,0 +1,8 @@
+export interface EventHubMessage {
+  enqueuedAt: number;
+  event: {
+    code: string;
+    name?: string;
+  };
+  [x: string]: unknown;
+}

package/src/types/EventPublisher.ts

@@ -0,0 +1,9 @@
+import { EventHubMessage } from './EventHubMessage';
+
+export interface EventPublisherBaseClass {
+  config: Record<string, unknown>;
+}
+
+export interface EventPublisher extends EventPublisherBaseClass {
+  map: (data: EventHubMessage) => Promise<Record<string, unknown>>;
+}

package/src/types/PlatformPublisher.ts

@@ -0,0 +1,19 @@
+import { HttpMethod, Logger } from '@azure/functions';
+import { BodyInit } from 'node-fetch';
+import { TypeSafeObject } from './UtilTypes';
+
+export interface PlatformPublisher {
+  source: string;
+  publish: (
+    log: Logger,
+    config: TypeSafeObject,
+    data: TypeSafeObject | unknown[],
+    event: string,
+  ) => Promise<void>;
+}
+
+export interface PlatformRequestOptions {
+  method: HttpMethod | undefined;
+  body?: BodyInit | undefined;
+  headers?: Record<string, string>;
+}

package/src/types/UtilTypes.ts

@@ -0,0 +1 @@
+export type TypeSafeObject = Record<string, unknown>;

package/src/types/global.d.ts

@@ -0,0 +1,3 @@
+declare namespace globalThis {
+  function it(): unknown;
+}

package/src/utils/utils.ts

@@ -0,0 +1,358 @@
+import * as crypto from 'crypto';
+import { Logger } from '@azure/functions';
+import * as appInsights from 'applicationinsights';
+import {
+  SeverityLevel,
+  Telemetry,
+} from 'applicationinsights/out/Declarations/Contracts';
+import fetch, { RequestInit, Response } from 'node-fetch';
+import { EventPublisherBaseClass } from '../types/EventPublisher';
+import { PlatformRequestOptions } from '../types/PlatformPublisher';
+import { TypeSafeObject } from '../types/UtilTypes';
+
+let aiClient: appInsights.TelemetryClient | null = null;
+
+if (process.env.APPINSIGHTS_INSTRUMENTATIONKEY) {
+  appInsights
+    .setup() // Set environment variable APPINSIGHTS_INSTRUMENTATIONKEY, so setup() can be called w/o parameters
+    .setAutoCollectDependencies(false)
+    .setAutoCollectConsole(true, true)
+    .setSendLiveMetrics(false)
+    .setAutoCollectRequests(false)
+    .setAutoCollectPerformance(false)
+    .setUseDiskRetryCaching(false)
+    .start();
+  aiClient = appInsights.defaultClient;
+}
+
+/**
+ * Base class for Event Publisher classes
+ * Facilitates registration (depracated) and configuration
+ */
+export class EventPublisherBase implements EventPublisherBaseClass {
+  config;
+  constructor(config: TypeSafeObject) {
+    this.config = config;
+  }
+
+  /** @deprecated Please use a 'new Class(config)' notation. The .register() method will be deleted in future major version
+   * Registers a new instance of @see EventPublisherBase -derived class with array of publishers
+   * @param {EventPublisher[]} publishers Tha publishers array to register with
+   * @param {Object} config Configuration to pass to new instance
+   * Call this static method on @see EventPublisherBase -derived class.
+   * It will create its instance and pass @param config to its constructor.
+   * Than it will add resulting instance of @param publishers.
+   */
+  public static register(publishers: unknown[], config: TypeSafeObject) {
+    // ? Otestovat zpetnou kompatibilitu
+    publishers.push(
+      new this(
+        config,
+      ) /* Trick: Creates instance of the specific derived class `register` has been called on */,
+    );
+  }
+}
+
+/**
+ * Logs message to Azure Function context and to Application Insights (if configured)
+ */
+export function log(
+  log: Logger,
+  level: SeverityLevel,
+  message: string,
+  properties?: Telemetry['properties'],
+): void {
+  log.warn(message);
+  aiClient?.trackTrace({
+    message,
+    severity: level,
+    properties,
+  });
+}
+
+/**
+ * Logs exception to Azure Function context and to Application Insights (if configured)
+ */
+export function logException(log: Logger, exception: Error) {
+  log.warn(exception);
+  aiClient?.trackException({
+    exception,
+  });
+}
+
+/**
+ * Creates a deep copy of given object removing any properties or array items with undefined value
+ * @param originalValue Object or array to copy. If value is neither array nor object it's returned as passed.
+ * @returns Deep copy of @param originalValue (providing array or object has been passed in). Any properties or array item with undefined value are skipped when making the copy, recursively. Returns @param obj untouched if neither array nor object has been passed in.
+ */
+export function removeUndefined(
+  originalValue: TypeSafeObject | unknown[],
+): TypeSafeObject | unknown[] {
+  // ? Toto bych rad otestoval. Klidne unit testy.
+  if (originalValue instanceof Array) {
+    return removeUndefinedFromArray(originalValue);
+  } else if (originalValue instanceof Object) {
+    return removeUndefinedFromObject(originalValue);
+  } else {
+    return originalValue;
+  }
+}
+
+function removeUndefinedFromObject(object: TypeSafeObject) {
+  const resultObject: TypeSafeObject = {};
+  for (const property in object) {
+    if (
+      Object.prototype.hasOwnProperty.call(object, property) &&
+      object[property] !== undefined
+    ) {
+      resultObject[property] = removeUndefined(
+        object[property] as TypeSafeObject | unknown[],
+      );
+    }
+  }
+  return resultObject;
+}
+
+function removeUndefinedFromArray(array: unknown[]) {
+  const resultArray: unknown[] = [];
+  for (const item of array) {
+    if (item !== undefined) {
+      resultArray.push(removeUndefined(item as TypeSafeObject | unknown[]));
+    }
+  }
+  return resultArray;
+}
+
+/**
+ * Computes SHA-256 hash of an email string. If email is not a string, undefined is returned
+ */
+export function encodeEmail(email: string) {
+  return computeSha256HashFromString(email);
+}
+
+/**
+ * Computes SHA-256 hash of any string. If provided value is not a string, undefined is returned
+ */
+function computeSha256HashFromString(stringToHash: string) {
+  if (typeof stringToHash !== 'string') {
+    return undefined;
+  }
+  return crypto
+    .createHash('sha256')
+    .update(stringToHash.toLowerCase(), 'ascii')
+    .digest('hex')
+    .toLowerCase();
+}
+
+interface Ad {
+  adPlatform: string;
+  visitAt: number;
+  adCodes?: Record<string, string>;
+}
+
+interface AdCodeInfo {
+  code: string;
+  visitAt: number;
+}
+
+/**
+ * Extracts ad code from standardly structured event data (in legacy or new format)
+ * @param data Event data to extract ad code from. As you can see the `ads` field is accepted in 2 formats the first being legacy and the later being new one.
+ * @param adPlatform value of `data.ads.adPlatform` field to filter ad codes by platform (this is for new style data; ignored for legacy data)
+ * @param adCode value of `data.ads.adType` field to filter items in `data.ads` by (this is for legacy style data); als used for new style data to identify the main parameter from `data.ads.adCodes` to obtain
+ * @param format If this custom function is provided it forats the code returned, so the function does not return object but string formated by this function. But nothing prevents it from returning object if the consumer can hanlde it.
+ */
+export function extractAdCode(
+  data: {
+    ads: Ad[];
+  },
+  adPlatform: string,
+  adCode: string,
+  format: ((code: AdCodeInfo, ad: Ad) => string | null | unknown) | null = null,
+): AdCodeInfo | null | string | unknown {
+  // ? Tady se udělalo hodně změn, protože se dal pryč legacy kód. Pro kontrolu je potřebná lepší znalost dat.
+  // ? Udelat unit test
+  const ad = data.ads
+    .filter((x) => {
+      return x.adPlatform === adPlatform;
+    })
+    .sort((a, b) => b.visitAt - a.visitAt)[0];
+  if (!ad) {
+    return null;
+  }
+  const code: string | null | undefined = ad.adCodes
+    ? ad.adCodes[adCode]
+    : null;
+  if (code) {
+    const returnValue: AdCodeInfo = { code: code, visitAt: ad.visitAt };
+    if (format) {
+      return format(returnValue, ad);
+    }
+    return returnValue;
+  }
+  return null;
+}
+
+/**
+ * Transforms an object to be flat, for instance for GA4
+ * @param event Event that is received
+ * @param separator Separator that will be used to unnest the structure. The default separator is underscore _
+ * @returns
+ */
+export function flatten(
+  event: TypeSafeObject,
+  separator = '_',
+): TypeSafeObject {
+  // ? Tady je pro safety potřeba celou funkci vylepšit
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return Object.assign(
+    {},
+    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-unsafe-argument
+    ...(function _flatten(
+      o: TypeSafeObject,
+      separator: string,
+      parent?: string,
+    ): any {
+      return [].concat(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        ...Object.keys(o).map((key) => {
+          if (typeof o[key] === 'object' && o[key] !== null) {
+            const newParent = parent ? parent + separator + key : key;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return _flatten(o[key] as TypeSafeObject, separator, newParent);
+          } else {
+            const newKey = parent ? parent + separator + key : key;
+            return { [newKey]: o[key] };
+          }
+        }),
+      );
+    })(event, separator),
+  );
+}
+
+/**
+ * Enhances header before sending test request to secondary target (like Pipedream)
+ * @param headers Request header dictionary. This contains the original headers and will be ehnanced.
+ * @param origUrl Original URL the request has been sent to
+ * @param origRequest The entire original request options
+ * @param origResponse Response recievend from original request
+ */
+export function prepareTestRequestHeaders(
+  headers: TypeSafeObject,
+  origUrl: string,
+  origRequest: TypeSafeObject,
+  origResponse: Response,
+) {
+  headers['x-mhub-orig-url'] = origUrl;
+  headers['x-mhub-orig-method'] = origRequest.method;
+  headers['x-mhub-orig-response-status-code'] = origResponse.status;
+  headers['x-mhub-orig-response-status-message'] = origResponse.statusText;
+}
+
+/**
+ * Handles HTTP response from node-fetch
+ * @param response Node-fetch response object
+ * @param event Event for which the response is
+ * @returns Deserialized response JSON
+ */
+export async function handleResponse(response: Response, event: string) {
+  if (!response.ok) {
+    throw new Error(
+      `HTTP Error code: ${
+        response.status
+      }, event: ${event}, body: ${await response.text()}`,
+    );
+  }
+  const body = await response.text();
+  try {
+    return JSON.parse(body) as object;
+  } catch (ex) {
+    return body;
+  }
+}
+
+interface HandleRequestParams {
+  source: string;
+  baseUrl: string;
+  requestOptions: PlatformRequestOptions;
+  query?: string;
+  event: string;
+  logger: Logger;
+}
+
+/**
+ *
+ * @param params
+ * @returns
+ */
+
+export async function handlePlatformRequest({
+  source,
+  baseUrl,
+  requestOptions,
+  query = '',
+  event,
+  logger,
+}: HandleRequestParams) {
+  if (!baseUrl || baseUrl.length < 3) {
+    // ? Mohli bychom zacit delat poradnou kontrolu validity vstupnich paramteru. Idealne pres ZOD
+    throw new Error('URL for request was not provided or was not valid');
+  }
+  const fullUrl = baseUrl + query;
+
+  const fetchRequestOptions: RequestInit = {
+    method: requestOptions.method ?? 'POST',
+    body: requestOptions.body ?? undefined,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    headers: { ...requestOptions.headers },
+  };
+
+  const rawPlatformResponse = await fetch(fullUrl, fetchRequestOptions);
+
+  if (process.env.PUBLISHER_TESTURL) {
+    await handleTestRequest({
+      fetchRequestOptions,
+      fullUrl,
+      query,
+      rawPlatformResponse,
+    });
+  }
+  const processedPlatfromResponse = await handleResponse(
+    rawPlatformResponse,
+    event,
+  );
+
+  log(logger, 1, `${source} - ${event} - sent`);
+
+  return processedPlatfromResponse;
+}
+
+interface HandleTestRequestParams {
+  fetchRequestOptions: RequestInit;
+  fullUrl: string;
+  query: string | undefined;
+  rawPlatformResponse: Response;
+}
+
+async function handleTestRequest(params: HandleTestRequestParams) {
+  try {
+    params.fetchRequestOptions.headers = {
+      ...params.fetchRequestOptions.headers,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'x-mhub-orig-url': params.fullUrl,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'x-mhub-orig-method': params.fetchRequestOptions.method ?? '',
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'x-mhub-orig-response-status-code': `${params.rawPlatformResponse.status}`,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'x-mhub-orig-response-status-message':
+        params.rawPlatformResponse.statusText,
+    };
+    await fetch(
+      `${process.env.PUBLISHER_TESTURL ?? ''} + ${params.query ?? ''}`,
+      params.fetchRequestOptions,
+    );
+  } catch {
+    /* empty */
+  }
+}