@mhubcloud/tms_core 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/index.js

@@ -0,0 +1,624 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DefaultPublisher: () => defaultPublisher,
+  publisher: () => publisher,
+  testUtils: () => testUtils_exports,
+  utils: () => utils_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  EventPublisherBase: () => EventPublisherBase,
+  encodeEmail: () => encodeEmail,
+  extractAdCode: () => extractAdCode,
+  flatten: () => flatten,
+  handlePlatformRequest: () => handlePlatformRequest,
+  handleResponse: () => handleResponse,
+  log: () => log,
+  logException: () => logException,
+  prepareTestRequestHeaders: () => prepareTestRequestHeaders,
+  removeUndefined: () => removeUndefined
+});
+var crypto = __toESM(require("crypto"));
+var appInsights = __toESM(require("applicationinsights"));
+var import_node_fetch = __toESM(require("node-fetch"));
+var aiClient = null;
+if (process.env.APPINSIGHTS_INSTRUMENTATIONKEY) {
+  appInsights.setup().setAutoCollectDependencies(false).setAutoCollectConsole(true, true).setSendLiveMetrics(false).setAutoCollectRequests(false).setAutoCollectPerformance(false).setUseDiskRetryCaching(false).start();
+  aiClient = appInsights.defaultClient;
+}
+var EventPublisherBase = class {
+  config;
+  constructor(config) {
+    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.
+   */
+  static register(publishers, config) {
+    publishers.push(
+      new this(
+        config
+      )
+    );
+  }
+};
+function log(log3, level, message, properties) {
+  log3.warn(message);
+  aiClient?.trackTrace({
+    message,
+    severity: level,
+    properties
+  });
+}
+function logException(log3, exception) {
+  log3.warn(exception);
+  aiClient?.trackException({
+    exception
+  });
+}
+function removeUndefined(originalValue) {
+  if (originalValue instanceof Array) {
+    return removeUndefinedFromArray(originalValue);
+  } else if (originalValue instanceof Object) {
+    return removeUndefinedFromObject(originalValue);
+  } else {
+    return originalValue;
+  }
+}
+function removeUndefinedFromObject(object) {
+  const resultObject = {};
+  for (const property in object) {
+    if (Object.prototype.hasOwnProperty.call(object, property) && object[property] !== void 0) {
+      resultObject[property] = removeUndefined(
+        object[property]
+      );
+    }
+  }
+  return resultObject;
+}
+function removeUndefinedFromArray(array) {
+  const resultArray = [];
+  for (const item of array) {
+    if (item !== void 0) {
+      resultArray.push(removeUndefined(item));
+    }
+  }
+  return resultArray;
+}
+function encodeEmail(email) {
+  return computeSha256HashFromString(email);
+}
+function computeSha256HashFromString(stringToHash) {
+  if (typeof stringToHash !== "string") {
+    return void 0;
+  }
+  return crypto.createHash("sha256").update(stringToHash.toLowerCase(), "ascii").digest("hex").toLowerCase();
+}
+function extractAdCode(data, adPlatform, adCode, format = null) {
+  const ad = data.ads.filter((x) => {
+    return x.adPlatform === adPlatform;
+  }).sort((a, b) => b.visitAt - a.visitAt)[0];
+  if (!ad) {
+    return null;
+  }
+  const code = ad.adCodes ? ad.adCodes[adCode] : null;
+  if (code) {
+    const returnValue = { code, visitAt: ad.visitAt };
+    if (format) {
+      return format(returnValue, ad);
+    }
+    return returnValue;
+  }
+  return null;
+}
+function flatten(event, separator = "_") {
+  return Object.assign(
+    {},
+    ...function _flatten(o, separator2, parent) {
+      return [].concat(
+        ...Object.keys(o).map((key) => {
+          if (typeof o[key] === "object" && o[key] !== null) {
+            const newParent = parent ? parent + separator2 + key : key;
+            return _flatten(o[key], separator2, newParent);
+          } else {
+            const newKey = parent ? parent + separator2 + key : key;
+            return { [newKey]: o[key] };
+          }
+        })
+      );
+    }(event, separator)
+  );
+}
+function prepareTestRequestHeaders(headers, origUrl, origRequest, origResponse) {
+  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;
+}
+async function handleResponse(response, event) {
+  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);
+  } catch (ex) {
+    return body;
+  }
+}
+async function handlePlatformRequest({
+  source,
+  baseUrl,
+  requestOptions,
+  query = "",
+  event,
+  logger
+}) {
+  if (!baseUrl || baseUrl.length < 3) {
+    throw new Error("URL for request was not provided or was not valid");
+  }
+  const fullUrl = baseUrl + query;
+  const fetchRequestOptions = {
+    method: requestOptions.method ?? "POST",
+    body: requestOptions.body ?? void 0,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    headers: { ...requestOptions.headers }
+  };
+  const rawPlatformResponse = await (0, import_node_fetch.default)(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;
+}
+async function handleTestRequest(params) {
+  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 (0, import_node_fetch.default)(
+      `${process.env.PUBLISHER_TESTURL ?? ""} + ${params.query ?? ""}`,
+      params.fetchRequestOptions
+    );
+  } catch {
+  }
+}
+
+// src/defaultPublisher.ts
+async function defaultPublisher(azureFunctionContext, eventHubMessages, source, platformPublisher, trigger) {
+  const processMessagePromises = [];
+  for (const message of eventHubMessages) {
+    processMessagePromises.push(
+      processMessage(
+        message,
+        azureFunctionContext.log,
+        platformPublisher,
+        trigger
+      )
+    );
+  }
+  const results = await Promise.allSettled(processMessagePromises);
+  for (const result of results) {
+    if (result.status === "rejected") {
+      logException(
+        azureFunctionContext.log,
+        new Error(result.reason)
+      );
+    }
+  }
+}
+async function processMessage(message, log3, platfromPublisher, trigger) {
+  const logProperties = {
+    source: platfromPublisher.source,
+    data: JSON.stringify(message)
+  };
+  const publishers = trigger(message);
+  if (!publishers.length) {
+    log(
+      log3,
+      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(
+      log3,
+      mapped,
+      eventPublisher.config,
+      platfromPublisher,
+      message.event.code + (message.event.name ? "/" + message.event.name : "")
+    );
+    if (res) {
+      publishedAny = true;
+    } else {
+      logException(
+        log3,
+        new Error(
+          `The message has not been published. Source: ${platfromPublisher.source}`
+        )
+      );
+      failedToPublishAll = true;
+    }
+  }
+  if (!publishedAny) {
+    logException(
+      log3,
+      new Error(
+        "The message has not been published to any publisher configuration"
+      )
+    );
+    return false;
+  }
+  return !failedToPublishAll;
+}
+async function publishMessage(log3, mapped, config, platformPublisher, event) {
+  await platformPublisher.publish(log3, config, mapped, event);
+  return true;
+}
+
+// src/publishers/affiliatePort.ts
+var affiliatePort = {
+  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(log3, config, data, event) {
+    if (data.products instanceof Array && (typeof config.offerId === "string" || typeof config.offerId === "number")) {
+      const affiliatePortData = removeUndefined(
+        data
+      );
+      const requestOptions = {
+        method: "GET"
+      };
+      const baseUrl = "https://tracking.affiliateclub.cz/aff_lsr";
+      for (const product of affiliatePortData.products) {
+        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 handlePlatformRequest({
+          source: this.source,
+          baseUrl,
+          query,
+          requestOptions,
+          event,
+          logger: log3
+        });
+      }
+    } else {
+      throw new Error("Invalid config for platform " + this.source);
+    }
+  }
+};
+
+// src/publishers/cj.ts
+var cj = {
+  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(log3, config, data, event) {
+    if (!data.cjevent) {
+      log(log3, 1, `CJ - ${event} - skipped because CJEVENT is missing`);
+    } else {
+      if (typeof config.cid === "string" && typeof config.type === "string") {
+        const cjData = removeUndefined(data);
+        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] !== void 0) {
+            query += "&" + encodeURI(property) + "=" + encodeURI(
+              cjData[property] === null ? "" : (
+                // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
+                cjData[property]?.toString()
+              )
+            );
+          }
+        }
+        const baseUrl = "https://www.kdukvh.com/u";
+        const requestOptions = {
+          method: "GET"
+        };
+        await handlePlatformRequest({
+          source: this.source,
+          baseUrl,
+          query,
+          requestOptions,
+          event,
+          logger: log3
+        });
+      } else {
+        throw new Error("Invalid config for platform " + this.source);
+      }
+    }
+  }
+};
+
+// src/publishers/facebook.ts
+var facebook = {
+  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(log3, config, data, event) {
+    if (typeof config.id === "string" && typeof config.access_token === "string") {
+      const requestOptions = {
+        method: "POST",
+        body: JSON.stringify({ data: [removeUndefined(data)] }),
+        headers: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          "Content-Type": "application/json"
+        }
+      };
+      const baseUrl = `https://graph.facebook.com/v11.0/${encodeURIComponent(
+        config.id
+      )}/events`;
+      const query = `?access_token=${encodeURI(config.access_token)}`;
+      await handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log3
+      });
+    } else {
+      throw new Error("Invalid config for platform " + this.source);
+    }
+  }
+};
+
+// src/publishers/googleAnalytics4.ts
+var googleAnalytics4 = {
+  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(log3, config, data, event) {
+    if (config.trackingId) {
+      const ga4Data = removeUndefined(data);
+      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 = {
+        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 handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log3
+      });
+    } else {
+      throw new Error("Invalid config for platform " + this.source);
+    }
+  }
+};
+
+// src/publishers/piano.ts
+var piano = {
+  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(log3, config, data, event) {
+    if (typeof config.siteId === "string" && typeof config.collectionDomain === "string") {
+      const pianoData = removeUndefined(data);
+      let query = "";
+      query = "?s=" + encodeURI(config.siteId);
+      query += "&idclient=" + encodeURI(pianoData.aux.visitorId);
+      query += "&ref=" + encodeURI(pianoData.aux.ref);
+      const requestOptions = {
+        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 handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log3
+      });
+    } else {
+      throw new Error("Invalid config for platform " + this.source);
+    }
+  }
+};
+
+// src/publishers/universalAnalytics.ts
+var universalAnalytics = {
+  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(log3, config, data, event) {
+    if (config.trackingId) {
+      const uaData = removeUndefined(data);
+      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 = {
+        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 handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log3
+      });
+    } else {
+      throw new Error("Invalid config for platform " + this.source);
+    }
+  }
+};
+
+// src/utils/testUtils.ts
+var testUtils_exports = {};
+__export(testUtils_exports, {
+  context: () => context
+});
+var context = {};
+context.log = function log2(str) {
+  console.log(str);
+};
+context.log.warn = function warn(str) {
+  console.warn(str);
+};
+
+// src/index.ts
+var 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
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultPublisher,
+  publisher,
+  testUtils,
+  utils
+});

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@mhubcloud/tms_core",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.2",
   "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",
+  "main": "dist/index.js",
   "keywords": [
     "mHub Cloud",
     "TMS",

package/src/index.ts

@@ -5,6 +5,7 @@ import { facebook } from './publishers/facebook';
 import { googleAnalytics4 } from './publishers/googleAnalytics4';
 import { piano } from './publishers/piano';
 import { universalAnalytics } from './publishers/universalAnalytics';
+import * as testUtils from './utils/testUtils';
 import * as utils from './utils/utils';
 
 export const publisher = {
@@ -22,4 +23,4 @@ export const publisher = {
   AffiliatePort: affiliatePort,
 };
 
-export { utils, defaultPublisher as DefaultPublisher };
+export { utils, defaultPublisher as DefaultPublisher, testUtils };

package/src/utils/testUtils.ts

@@ -0,0 +1,18 @@
+interface LogFunction {
+  (str: string): void;
+  warn: (str: string) => void;
+}
+// TODO tohle by se mělo dát spíš do nějakých obecných types asi
+interface Context {
+  log: LogFunction;
+}
+
+const context: Context = {} as Context;
+context.log = function log(str: string) {
+  console.log(str);
+} as LogFunction;
+context.log.warn = function warn(str: string) {
+  console.warn(str);
+};
+
+export { context };

package/tests/AffiliatePort.js

@@ -2,7 +2,7 @@ const publisher = require('../dist/index.js').publisher.AffiliatePort;
 const defaultPublisher = require('../dist/index.js').DefaultPublisher;
 const utils = require('../dist/index.js').utils;
 var assert = require('assert');
-const testUtils = require('./testUtils');
+const testUtils = require('../dist/index.js').testUtils;
 
 describe('test AffiliatePort publisher', function () {
   it('purchase', async function () {

package/tests/CJ.js

@@ -2,7 +2,7 @@ const publisher = require('../dist/index.js').publisher.CJ;
 const defaultPublisher = require('../dist/index.js').DefaultPublisher;
 const utils = require('../dist/index.js').utils;
 var assert = require('assert');
-const testUtils = require('./testUtils');
+const testUtils = require('../dist/index.js').testUtils;
 
 describe('test CJ publisher', function () {
   it('purchase', async function () {

package/tests/Facebook.js

@@ -2,7 +2,7 @@ const publisher = require('../dist/index.js').publisher.Facebook;
 const defaultPublisher = require('../dist/index.js').DefaultPublisher;
 const utils = require('../dist/index.js').utils;
 var assert = require('assert');
-const testUtils = require('./testUtils');
+const testUtils = require('../dist/index.js').testUtils;
 
 describe('test Facebook publisher', function () {
   it('purchase', async function () {