@mhubcloud/tms_core 1.7.6 → 2.0.0-beta.1

package/js/publishers/HttpPublisher.js

@@ -0,0 +1,64 @@
+const fetch = require('node-fetch');
+const utils = require("../lib/utils");
+const SOURCE = "f_HttpPublisher";
+
+module.exports = {
+    /**
+     * Processed data comming from EventHub to data for further processing
+     * @param {Object} data The data comming from EventHub
+     * @param {FunctionContext} test Azure Function context.test
+     * @returns {Object} Data for further processing
+     */
+    parse: function parse(data, test) {
+        //ConsumerBase.cs:ConsumeOneEventAsync
+        data.enqueuedAt = test ? 1600000000000 : Date.now();
+        return data;
+    },
+
+    /**
+     * Publishes data to provided URL
+     * @param {FunctionContext} log Azure Function context.log.warn
+     * @param {string} event Required: event for which is it triggered
+     * @param {string} url Required: Request URL with query parameters
+     * @param {string} platform Required: Name of the plaform to which request is sent
+     * @param {string} method Required: Request method - GET|POST|PUT...
+     * @param {Object} headers Optional: Object of request headers
+     * @param {Object} body Optional: Non-strigifed request body object 
+     * 
+     */
+     publish: async function publish(log, event, platform, url, method, headers = {}, body = {}) {
+        const reqOpts = {
+            method: method,
+            headers: headers
+        };
+        if(method == "POST"){
+            reqOpts.body = JSON.stringify(body);
+        }
+
+        const resp = await fetch(url, reqOpts);
+
+        if (process.env.PUBLISHER_TESTURL) {
+            try {
+                utils.prepareTestRequestHeaders(reqOpts.headers, url, reqOpts, resp);
+                await fetch(process.env.PUBLISHER_TESTURL, reqOpts);
+            } catch { }
+        }
+
+        await utils.handleResponse(resp, event);
+
+        log(`${platform} - ${event} - sent`);
+    },
+
+    /**
+    * Validates an object against given schema
+    * @param {Object} data An object to validate.
+    * @param {string} schema Name of the schema. That's name of a file with `.schema.json` extension in `customizable/schemas` subfolder of current publisher folder
+    * @returns {boolean} Validation result, true if successful, false if unsuccessfull (in which case more info is written to console)
+    */
+    validate: function validate(data, schema) {
+        if (!schema) throw new Error("Schema parameters not provided");
+        if (schema.indexOf("/") >= 0) throw new Error("Schema must be provided as schema name, not schema path");
+        //More validation done by utils.validate
+        return utils.validate(data, SOURCE, schema);
+    }
+};

package/{publishers → js/publishers}/Piano.js

@@ -6,22 +6,24 @@ module.exports = {
     /**
      * Processed data comming from EventHub to data for further processing
      * @param {Object} data The data comming from EventHub
+     * @param {FunctionContext} test Azure Function context.test
      * @returns {Object} Data for further processing
      */
-    parse: function parse(data, context) {
+    parse: function parse(data, test) {
         //ConsumerBase.cs:ConsumeOneEventAsync
-        data.enqueuedAt = context.test ? 1600000000000 : Date.now();
+        data.enqueuedAt = test ? 1600000000000 : Date.now();
         return data;
     },
 
     /**
      * Publishes data to Piano
+     * @param {FunctionContext} log Azure Function context.log.warn
      * @param {{collectionDomain: string, siteId: string|number}} config Publisher configuration
      * @param {{pianoData: {events: {name: string, data: {[key: string]: any}}[]}, aux: {visitorId: string, ref: string, userAgent?: string, referer?: string, forwardedFor?: string}}} data Data in publisher-friendly format to be published
      * @returns {*} Data returned by platform, if possible JSON-deserialized (otherwise as string)
      * @param {string} event for which is it triggered
      */
-    publish: async function publish(config, data, event) {
+    publish: async function publish(log, config, data, event) {
         data = utils.removeUndefined(data);
         let dt = "";
         //https://developers.atinternet-solutions.com/piano-analytics-tagging-en/event-tagging-piano-analytics-en/events-pattern-en/#post-request_5
@@ -48,7 +50,7 @@ module.exports = {
 
         await utils.handleResponse(resp, event);
 
-        console.log(`Piano Analytics - ${event} - sent`);
+        log(`Piano Analytics - ${event} - sent`);
     },
 
     /**

package/{publishers → js/publishers}/UniversalAnalytics.js

@@ -8,20 +8,22 @@ module.exports = {
     /**
      * Processed data comming from EventHub to data for further processing
      * @param {Object} data The data comming from EventHub
-     * @returns {object} Data for further processing
+     * @param {FunctionContext} test Azure Function context.test
+     * @returns {Object} Data for further processing
      */
-    parse: function parse(data, context) {
+    parse: function parse(data, test) {
         //ConsumerBase.cs:ConsumeOneEventAsync
-        data.enqueuedAt = context.test ? 1600000000000 : Date.now();
+        data.enqueuedAt = test ? 1600000000000 : Date.now();
         return data;
     },
 
     /**
      * Publishes data to Google Analytics
+     * @param {FunctionContext} log Azure Function context.log.warn
      * @param {{tid: string}} config Publisher configuration
      * @param {{action: string, ti: string, [key:string]: string|number|boolean}} data Data in publisher-friendly format to be published
      */
-    publish: async function publish(config, data, event) {
+    publish: async function publish(log, config, data, event) {
         data = utils.removeUndefined(data);
         //https://developers.google.com/analytics/devguides/collection/protocol/v1/devguide#event
         const url = "https://www.google-analytics.com/collect";
@@ -55,7 +57,7 @@ module.exports = {
 
         await utils.handleResponse(resp);
 
-        console.log(`Universal Analytics - ${event} - sent`);
+        log(`Universal Analytics - ${event} - sent`);
     },
 
     /**

package/package.json

@@ -1,29 +1,46 @@
-{
-    "name": "@mhubcloud/tms_core",
-    "version": "1.7.6",
-    "description": "Core function for mHub Cloud TMS publishers",
-    "homepage": "https://mhubcloud.com/",
-    "license": "Apache 2.0",
-    "email": "info@crossmasters.com",
-    "author": "Jan Brzobohatý",
-    "main": "index.js",
-    "keywords": [
-        "mHub Cloud",
-        "TMS",
-        "tag management system",
-        "backend measurement",
-        "server side measurement",
-        "conversion API"
-    ],
-    "scripts": {
-        "test": "mocha ./tests/*.js  --timeout 10000 "
-    },
-    "dependencies": {
-        "ajv": "^8.8.2",
-        "applicationinsights": "^2.2.0",
-        "node-fetch": "^2.6.7"
-    },
-    "devDependencies": {
-        "mocha": "^10.0.0"
-    }
-}
+{
+  "name": "@mhubcloud/tms_core",
+  "version": "2.0.0-beta.1",
+  "description": "Core function for mHub Cloud TMS publishers",
+  "homepage": "https://mhubcloud.com/",
+  "license": "Apache 2.0",
+  "email": "info@crossmasters.com",
+  "author": "Jan Brzobohatý",
+  "main": "dist/index.js",
+  "keywords": [
+    "mHub Cloud",
+    "TMS",
+    "tag management system",
+    "backend measurement",
+    "server side measurement",
+    "conversion API"
+  ],
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "applicationinsights": "^2.6.0",
+    "node-fetch": "^2.6.11"
+  },
+  "devDependencies": {
+    "@azure/functions": "^3.5.1",
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/node": "^18.16.14",
+    "@types/node-fetch": "^2.6.4",
+    "@typescript-eslint/eslint-plugin": "^5.59.7",
+    "@typescript-eslint/parser": "^5.59.7",
+    "eslint": "^8.41.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.8",
+    "ts-node": "^10.9.1",
+    "tsup": "^6.7.0",
+    "typescript": "^4.9.5"
+  },
+  "scripts": {
+    "dev": "ts-node index.ts",
+    "build": "tsup ./src/index.ts --format cjs --target node18",
+    "test": "mocha ./tests/*.js  --timeout 10000 "
+  }
+}

package/releasePlan.md

@@ -0,0 +1,3 @@
+To test after release:
+- Zkontrolovat event_time posílaný do FB, že chodí ve správném formátu a že obsahuje správný údaj.
+- Když použiju utils.log tak to do appinsights zaloguje dvakrát? Máme totiž podezření, že ano. 

package/src/defaultPublisher.ts

@@ -0,0 +1,132 @@
+import { Context, Logger } from '@azure/functions';
+import { Telemetry } from 'applicationinsights/out/Declarations/Contracts';
+import { EventHubMessage } from './types/EventHubMessage';
+import { EventPublisher } from './types/EventPublisher';
+import { PlatformPublisher } from './types/PlatformPublisher';
+import { TypeSafeObject } from './types/UtilTypes';
+import * as utils from './utils/utils';
+
+/**
+ * Implements the Azure Function, called for set of events received via Event Hub
+ * @deprecated Udelat novou metodu, ktera bude spravne a bude inicializovat classu
+ * @param azureFunctionContext Azure Function Context
+ * @param eventHubMessages Array of messages received from Event Hub
+ * @param source Name of the publisher (it's folder name in which it's implemented)
+ * @param platformPublisher Publisher implementation instance (from <publisher>/publisher.js)
+ * @param trigger
+ */
+export async function defaultPublisher(
+  azureFunctionContext: Context,
+  eventHubMessages: EventHubMessage[],
+  source: string,
+  platformPublisher: PlatformPublisher,
+  trigger: (a: unknown) => EventPublisher[],
+) {
+  const processMessagePromises = [];
+  for (const message of eventHubMessages) {
+    processMessagePromises.push(
+      processMessage(
+        message,
+        azureFunctionContext.log,
+        platformPublisher,
+        trigger,
+      ),
+    );
+  }
+  const results = await Promise.allSettled(processMessagePromises);
+  // ? musi nahoru probublat, ze aspon neco selhalo a to je to, co bude triggerovat nasledujici error. Error pro konkretniho publishera musi byt primo v processMessage v loopu. Hodnotu pro typ publishera vezmeme z platformBublisher.SOURCE
+  for (const result of results) {
+    if (result.status === 'rejected') {
+      utils.logException(
+        azureFunctionContext.log,
+        new Error(result.reason as Error['message']),
+      );
+    }
+  }
+}
+
+/**
+ * Processes single message from EventHub
+ * @param message A message received from EventHub
+ * @param log Azure Function context.log
+ * @param source Name of the publisher (it's folder name in which it's implemented)
+ * @param platfromPublisher Publisher implementation instance (from <publisher>/publisher.js)
+ * @param trigger Publisher-specific trigger function (from <publisher>/customizable/trigger.js)
+ * @returns Returns false if at least one publisher failed or in case of other failed requirements
+ */
+async function processMessage(
+  message: EventHubMessage,
+  log: Logger,
+  platfromPublisher: PlatformPublisher,
+  trigger: (a: object) => EventPublisher[],
+) {
+  // TODO Je potreba otestovat, ze se to nerozbije, kdyz jsme prestali prepisovat enqueuedAt na Date.now()
+  const logProperties: Telemetry['properties'] = {
+    source: platfromPublisher.source,
+    data: JSON.stringify(message),
+  };
+  const publishers = trigger(message);
+  if (!publishers.length) {
+    utils.log(
+      log,
+      1,
+      'Message excluded by filter (no publishers determined)',
+      logProperties,
+    );
+    return false;
+  }
+  let publishedAny = false;
+  let failedToPublishAll = false;
+  for (const eventPublisher of publishers) {
+    const mapped = await eventPublisher.map(message);
+
+    const res = await publishMessage(
+      log,
+      mapped,
+      eventPublisher.config,
+      platfromPublisher,
+      message.event.code + (message.event.name ? '/' + message.event.name : ''),
+    );
+    if (res) {
+      publishedAny = true;
+    } else {
+      utils.logException(
+        log,
+        new Error(
+          `The message has not been published. Source: ${platfromPublisher.source}`,
+        ),
+      );
+      failedToPublishAll = true;
+    }
+  }
+  if (!publishedAny) {
+    utils.logException(
+      log,
+      new Error(
+        'The message has not been published to any publisher configuration',
+      ),
+    );
+    return false;
+  }
+  // Returns false
+  return !failedToPublishAll;
+}
+
+/**
+ * Publishes a message to configured publisher
+ * @param log Azure Function context.log
+ * @param mapped Mapped message data
+ * @param config Platform-specific platform publisher configuration
+ * @param platformPublisher Publisher implementation instance (from <publisher>/publisher.js)
+ * @param event Event for which logic was triggered
+ */
+async function publishMessage(
+  log: Logger,
+  mapped: TypeSafeObject,
+  config: TypeSafeObject,
+  platformPublisher: PlatformPublisher,
+  event: string,
+) {
+  await platformPublisher.publish(log, config, mapped, event);
+  return true;
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+import { defaultPublisher } from './defaultPublisher';
+import { affiliatePort } from './publishers/affiliatePort';
+import { cj } from './publishers/cj';
+import { facebook } from './publishers/facebook';
+import { googleAnalytics4 } from './publishers/googleAnalytics4';
+import { piano } from './publishers/piano';
+import { universalAnalytics } from './publishers/universalAnalytics';
+import * as utils from './utils/utils';
+
+export const publisher = {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  Facebook: facebook,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  CJ: cj,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  GoogleAnalytics4: googleAnalytics4,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  UniversalAnalytics: universalAnalytics,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  Piano: piano,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  AffiliatePort: affiliatePort,
+};
+
+export { utils, defaultPublisher as DefaultPublisher };

package/src/publishers/affiliatePort.ts

@@ -0,0 +1,69 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+
+interface Product {
+  orderId: string;
+  quantity: number;
+  price: number;
+  category: string;
+  masterType: string;
+}
+
+interface AffiliatePortData {
+  products: Product[];
+  orderId: string;
+  transactionID: string;
+  [x: string]: unknown;
+}
+
+export const affiliatePort: PlatformPublisher = {
+  source: 'AffiliatePort',
+  /**
+   * Publishes data to AffiliatePort
+   * @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 (
+      (data as AffiliatePortData).products instanceof Array &&
+      (typeof config.offerId === 'string' || typeof config.offerId === 'number')
+    ) {
+      const affiliatePortData = utils.removeUndefined(
+        data,
+      ) as AffiliatePortData;
+
+      const requestOptions: PlatformRequestOptions = {
+        method: 'GET',
+      };
+
+      const baseUrl = 'https://tracking.affiliateclub.cz/aff_lsr';
+
+      for (const product of affiliatePortData.products) {
+        // https://tracking.affiliateclub.cz/aff_lsr?offer_id=OFFER_ID&adv_sub=TID_SUB_ID&amount=AMOUNT&transaction_id=TRANSACTION_ID&adv_sub2=CATEGORY&adv_sub3=MASTER_TYPE
+        const query = `?offer_id=${encodeURIComponent(
+          config.offerId,
+        )}&adv_sub=TID_${affiliatePortData.orderId}&amount=${
+          product.quantity * product.price
+        }&transaction_id=${affiliatePortData.transactionID}&adv_sub2=${
+          product.category
+        }&adv_sub3=${product.masterType}`;
+
+        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/cj.ts

@@ -0,0 +1,67 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+import { TypeSafeObject } from '../types/UtilTypes';
+
+interface CjData {
+  cjevent?: unknown;
+  [x: string]: unknown;
+}
+
+export const cj: PlatformPublisher = {
+  source: 'CJAffiliate',
+  /**
+   * Publishes data to CJ
+   * @param log Azure 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 (!(data as CjData).cjevent) {
+      utils.log(log, 1, `CJ - ${event} - skipped because CJEVENT is missing`);
+      // ? Tady se returnoval false, ale nemyslim, ze to neco pouzivalo
+    } else {
+      if (typeof config.cid === 'string' && typeof config.type === 'string') {
+        const cjData = utils.removeUndefined(data) as TypeSafeObject;
+        let query = '?cid=' + encodeURI(config.cid);
+        query += '&type=' + encodeURI(config.type);
+        for (const property in data) {
+          if (
+            Object.prototype.hasOwnProperty.call(cjData, property) &&
+            cjData[property] !== undefined
+          ) {
+            query +=
+              '&' +
+              encodeURI(property) +
+              '=' +
+              encodeURI(
+                cjData[property] === null
+                  ? ''
+                  : // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
+                    (cjData[property]?.toString() as string),
+              );
+          }
+        }
+        const baseUrl = 'https://www.kdukvh.com/u';
+
+        const requestOptions: PlatformRequestOptions = {
+          method: 'GET',
+        };
+
+        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/facebook.ts

@@ -0,0 +1,49 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+
+export const facebook: PlatformPublisher = {
+  source: 'Faceboook',
+  /**
+   *Publishes data to Facebook
+   * @param log Azure 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.id === 'string' &&
+      typeof config.access_token === 'string'
+    ) {
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+        body: JSON.stringify({ data: [utils.removeUndefined(data)] }),
+        headers: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'Content-Type': 'application/json',
+        },
+      };
+
+      // https://graph.facebook.com/v11.0/<id>/events
+      const baseUrl = `https://graph.facebook.com/v11.0/${encodeURIComponent(
+        config.id,
+      )}/events`;
+
+      const query = `?access_token=${encodeURI(config.access_token)}`;
+
+      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/googleAnalytics4.ts

@@ -0,0 +1,60 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+import { TypeSafeObject } from '../types/UtilTypes';
+
+export const googleAnalytics4: PlatformPublisher = {
+  source: 'GoogleAnalytics4',
+  /**
+   * Publishes data to Google Analytics
+   * @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 ga4Data = utils.removeUndefined(data) as TypeSafeObject;
+      ga4Data.v = 2;
+      ga4Data.seg = 1;
+      ga4Data.gcs = 111;
+      ga4Data.tid = config.trackingId;
+
+      let payload = '';
+
+      for (const property in ga4Data) {
+        if (Object.prototype.hasOwnProperty.call(ga4Data, property)) {
+          if (payload) {
+            payload += '&';
+          }
+          payload += encodeURI(property) + '=' + encodeURI(ga4Data[property]);
+        }
+      }
+
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+        headers: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'User-Agent': 'mHub Cloud',
+        },
+      };
+
+      const baseUrl = 'https://www.google-analytics.com/g/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);
+    }
+  },
+};