@mhubcloud/tms_core 1.0.0 → 1.1.0

package/package.json

@@ -1,4 +1 @@
-{
-"name": "@mhubcloud/tms_core",
-"version": "1.0.0"
-}
+{"name":"@mhubcloud/tms_core","version":"1.1.0"}

package/utils.js

@@ -0,0 +1,295 @@
+const crypto = require('crypto');
+const Ajv = require("ajv");
+const fs = require('fs');
+const https = require('https');
+
+let aiClient;
+if (process.env.APPINSIGHTS_INSTRUMENTATIONKEY) {
+    const appInsights = require("applicationinsights");
+    appInsights.setup().start(); //Set einvironmet variable APPINSIGHTS_INSTRUMENTATIONKEY, so setup() can be called w/o parameters
+    aiClient = appInsights.defaultClient;
+}
+
+/** 
+ * Base class for Event Publisher classes
+ * Facilitates registration and configuration
+ */
+class EventPublisherBase {
+    /**
+     * Createa  new insatnce of the @see EventPublisherBase class 
+     * @param {Object} config Publisher configuration (in platform-specific format)
+     */
+    constructor(config) {
+        this.config = config;
+    }
+
+    /**
+     * Validates input data that they can be passed to mapper
+     * @param {Object} data Input data to validate
+     * @returns {boolean} Validation result
+     */
+    validate(data) {
+        return true; //Override this method in custom publisher for custom validation
+    }
+
+    /**
+     * 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) /* Trick: Creates instance of the specific derived class `register` has been called on */);
+    }
+}
+
+module.exports = {
+    EventPublisherBase: EventPublisherBase,
+
+    /**
+     * Provides access to Application Insights logging (event reporting)
+     * @type {appInsights.TelemetryClient|null}
+     */
+    appInsights: aiClient || null,
+
+    /**
+     * Computes SHA-256 hash of a string
+     * @param {string} email The vaue to hash
+     * @returns {string} @param email SHA-256 hash; returns email if it is 𝑓𝑎𝑙𝑠𝑒 (null, undefined etc.)
+     */
+    encodeEmail: function encodeEmail(email) {
+        if (!email) return email;
+        return crypto.createHash('sha256').update(email.toLowerCase(), "ascii").digest('hex').toLowerCase();
+    },
+
+    /**
+     * Handles HTTP response from node-fetch
+     * @param {*} response Node-fetch response object
+     * @param {string} event for which response is
+     * @returns {Object} Deserialized response JSON
+     * Throws exception in case of response error code
+     */
+    handleResponse: 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;
+        }
+    },
+
+    /**
+     * Creates a deep copy of given object removing any properties or array items with undefined value
+     * @param {*} obj Objec or array to copy. If value is neither array nor object it's returned as passed.
+     * @returns Deep copy of @param obj (providing array or object has bee 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.
+     */
+    removeUndefined: function removeUndefined(obj) {
+        let ret;
+        if (obj instanceof Array) {
+            ret = [];
+            for (let i = 0; i < obj.length; i++) {
+                if (obj[i] !== undefined)
+                    ret.push(removeUndefined(obj[i]));
+            }
+        } else if (obj instanceof Object) {
+            ret = {};
+            for (const prp in obj) {
+                if (obj.hasOwnProperty(prp) && obj[prp] !== undefined)
+                    ret[prp] = removeUndefined(obj[prp]);
+            }
+        } else {
+            return obj;
+        }
+        return ret;
+    },
+
+    /**
+     * Validates an object against the schema it states or given schema
+     * @param {Object} data An object to validate. The shema must be provided in its `$schema` property if ot passed in @param schema
+     * @param {string} schemaSource Name of a folder to look for schemas. Schemas JSON format are looked for in subfolder `customizable/schemas` of given folder.
+     * @param {string} schema Full URL id (i.e. URL starting with https://schema.measurementhub.net/), or just relative part of that URL to resolve schem in @param schemaSource`/customizable/schemas`
+     * @returns {boolean} Validation result, true if successful, Exception if unsuccessfull
+     */
+    validate: function validate(data, schemaSource, schema = null) {
+        schema = schema || data.$schema;
+        if (!schema) {
+            throw ("Data doesn't have schema and schema not passed");
+        }
+        if (schema.indexOf("https://schema.measurementhub.net/") !== 0 && (schema.indexOf("http://") === 0 || schema.indexOf("https://") == 0)) {
+            throw (`Schema ${data.$schema} is not supported, only https://schema.measurementhub.net/... and schemas identified by relative URL shemas are supported`);
+        }
+        let parts = schema.split('/');
+        if (parts.indexOf('..') >= 0) { //Directory traversal attack protection
+            throw (`It's invalid for schema URI to contain '..' segment, such as in ${schema}`);
+        }
+        if (schema.indexOf("http://") === 0 || schema.indexOf("https://") == 0)
+            parts = parts.slice(3);
+
+        const schemaLocation = `${schemaSource}/customizable/schemas/${parts.join('/')}.json`;
+        if (!fs.existsSync(schemaLocation)) {
+            throw (`Schema file ${schemaLocation} not found`);
+        }
+
+        let schemaStr;
+        try {
+            schemaStr = fs.readFileSync(schemaLocation).toString();
+        } catch (ex) {
+            throw (`Failed to load schema ${schema}`);
+        }
+
+        let schemaObj;
+        try {
+            schemaObj = JSON.parse(schemaStr);
+        } catch (ex) {
+            throw (`Failed to deserialize ${schema}`);
+        }
+
+        const ajv = new Ajv({ allErrors: true });
+        let validate;
+        try {
+            validate = ajv.compile(schemaObj);
+        } catch (ex) {
+            throw (`Failed to compile schema ${schema}`);
+        }
+
+        const valid = validate(data);
+        if (!valid) {
+            throw (`Schema vaidation failed for schema ${schema}, ${validate.errors.length} errors: ${JSON.stringify(validate.errors)}`);
+        }
+        return true;
+    },
+
+    /**
+     * Enhances header before sending test request to secondary target (like Pipedream)
+     * @param {Object} headers Request header dictionary. This contains the original headers and will be ehnanced.
+     * @param {string} origUrl Original URL the request has been sent to
+     * @param {*} origRequest The entire original request options
+     * @param {*} origResponse Response recievend from original request
+     */
+    prepareTestRequestHeaders: 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;
+    },
+
+    /**
+     * Extracts ad code from standardly structured event data (in legacy or new format)
+     * @param {{ads:(LegacyAd|Ad)[]}} 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 {string} adPlatform value of `data.ads.adPlatform` field to filter ad codes by platform (this is for new style data; ignored for legacy data)
+     * @param {string} 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 {(code: AdCodeInfo, ad: LegacyAd|Ad) => string|any} 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.
+     * @returns {AdCodeInfo|string|null|any} Ad code and time when it was recorded of newest event (by `visitAt`) with given ad code from @param data.ads; when @param format is provided returns string result of that function.
+     */
+    extractAdCode: function extractAdCode(data, adPlatform, adCode, format = null) {
+        const ad = data.ads.filter(x => x.adType === adCode /*legacy*/ || x.adPlatform === adPlatform /*new*/)
+            .sort((a, b) => b.visitAt - a.visitAt)[0];
+        const code = ad?.adCode /*legacy*/ || (ad?.adCodes ? ad.adCodes[adCode] : null);
+        if (code) {
+            const ret = { code: code, visitAt: ad.visitAt };
+            if (format) return format(ret, ad);
+            return ret;
+        }
+        return null;
+    },
+
+    /**
+     * Logs message to Azure Function context and to Application Insights (if configured)
+     * @param {*} context Azure Function context
+     * @param {0|1|2|3|4} level Application Insights log level according to https://docs.microsoft.com/en-us/dotnet/api/microsoft.applicationinsights.datacontracts.severitylevel?view=azure-dotnet
+     * @param {string} message The message to log
+     * @param {Object} properties Properties to pass to Application Insights trace
+     */
+    log2: function log2(context, level, message, properties) {
+        context.log(message);
+        aiClient?.trackTrace(
+            {
+                message: message,
+                severityLevel: level,
+                properties: properties
+            }
+        );
+    },
+
+    /**
+     * Logs exception to Azure Function context and to Application Insights (if configured)
+     * @param {object} exception
+     */
+    logException: function logException(exception) {
+        console.log(exception);
+        aiClient?.trackException({ exception: exception });
+    },
+
+    /**
+     * For http request. This function is for edge cases. Use Fetch if possible.
+     * @param {object} params (hostname, port, path, method)
+     * @param {object} postData 
+     * @returns 
+     */
+    httpRequest: function httpRequest(params, postData) {
+        return new Promise(function (resolve, reject) {
+            var req = https.request(params, function (res) {
+                // reject on bad status
+                if (res.statusCode < 200 || res.statusCode >= 300) {
+                    return reject(new Error('statusCode=' + res.statusCode));
+                }
+                // cumulate data
+                var body = [];
+                res.on('data', function (chunk) {
+                    body.push(chunk);
+                });
+                // resolve on end
+                res.on('end', function () {
+                    try {
+                        if (body.length > 0) {
+                            body = JSON.parse(Buffer.concat(body).toString());
+                        }
+                    } catch (e) {
+                        reject(e);
+                    }
+                    resolve(body);
+                });
+            });
+            // reject on request error
+            req.on('error', function (err) {
+                // This is not a "Second reject", just a different sort of failure
+                reject(err);
+            });
+            if (postData) {
+                req.write(postData);
+            }
+            // IMPORTANT
+            req.end();
+        });
+    },
+
+    /**
+     * Transforms an object to be flat, for instance for GA4
+     * @param {object} event Event that is received
+     * @param {sring} separator Separator that will be used to unnest the structure. The default separator is underscore _
+     * @returns 
+     */
+    flatten: function flatten(event, separator) {
+        return Object.assign(
+            {},
+            ...function _flatten(o, separator = '_', parent) {
+                return [].concat(...Object.keys(o)
+                    .map(key => {
+                        if (typeof o[key] === 'object' && o[key] !== null) {
+                            const newParent = parent ? (parent + separator + key) : key;
+                            return _flatten(o[key], separator, newParent);
+                        }
+                        else {
+                            const newKey = parent ? (parent + separator + key) : key;
+                            return { [newKey]: o[key] }
+                        }
+                    })
+                );
+            }(event, separator))
+    }
+};