@rudderstack/integrations-lib 0.1.0

package/build/utils/json.js

@@ -0,0 +1,507 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonUtils = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const get_value_1 = __importDefault(require("get-value"));
+const set_value_1 = __importDefault(require("set-value"));
+const lodash_1 = require("lodash");
+const logger = __importStar(require("../logger"));
+const platform_error_1 = require("../errors/platform_error");
+const sem_1 = require("./sem");
+const instrumentation_error_1 = require("../errors/instrumentation_error");
+const misc_1 = require("./misc");
+const moment_timezone_1 = __importDefault(require("moment-timezone"));
+const transformation_error_1 = require("../errors/transformation_error");
+const constants_1 = require("../constants");
+class JsonUtils {
+    /**
+     * Description: This method is used to handle the source keys operation
+     * @param message - the message object
+     * @returns	{any}	- returns the value of the source key
+     * 						if the source key is not present in the message
+     * 						returns null
+     *
+     */
+    static handleSourceKeysOperation({ message, operationObject, }) {
+        const { operation, args } = operationObject;
+        // populate the values from the arguments
+        // in the same order it is populated
+        const argValues = args.map((arg) => {
+            const { sourceKeys, defaultVal } = arg;
+            const val = (0, get_value_1.default)(message, sourceKeys);
+            if (val || val === false || val === 0) {
+                return val;
+            }
+            return defaultVal;
+        });
+        // quick sanity check for the undefined values in the list.
+        // if there is any undefined values, return null
+        // without going further for operations
+        const isAllDefined = (0, lodash_1.every)(argValues, (v) => !(0, lodash_1.isNil)(v));
+        if (!isAllDefined) {
+            return null;
+        }
+        // start handling operations
+        let result;
+        switch (operation) {
+            case 'multiplication':
+                result = 1;
+                for (const v of argValues) {
+                    if ((0, lodash_1.isNumber)(v)) {
+                        result *= v;
+                    }
+                    else {
+                        // if there is a non number argument simply return null
+                        // non numbers can't be operated arithmatically
+                        return null;
+                    }
+                }
+                return result;
+            case 'addition':
+                result = 0;
+                for (const v of argValues) {
+                    if ((0, lodash_1.isNumber)(v)) {
+                        result += v;
+                    }
+                    else {
+                        // if there is a non number argument simply return null
+                        // non numbers can't be operated arithmatically
+                        return null;
+                    }
+                }
+                return result;
+            default:
+                return null;
+        }
+    }
+    static checkTimestamp(validateTimestamp, formattedVal) {
+        const { allowedPastTimeDifference, allowedPastTimeUnit, // seconds, minutes, hours
+        allowedFutureTimeDifference, allowedFutureTimeUnit, // seconds, minutes, hours
+         } = validateTimestamp;
+        let pastTimeDifference;
+        let futureTimeDifference;
+        const currentTime = moment_timezone_1.default.unix(Number((0, moment_timezone_1.default)().format('X')));
+        const time = moment_timezone_1.default.unix(Number((0, moment_timezone_1.default)(formattedVal).format('X')));
+        switch (allowedPastTimeUnit) {
+            case 'seconds':
+                pastTimeDifference = Math.ceil(moment_timezone_1.default.duration(currentTime.diff(time)).asSeconds());
+                break;
+            case 'minutes':
+                pastTimeDifference = Math.ceil(moment_timezone_1.default.duration(currentTime.diff(time)).asMinutes());
+                break;
+            case 'hours':
+                pastTimeDifference = Math.ceil(moment_timezone_1.default.duration(currentTime.diff(time)).asHours());
+                break;
+            default:
+                break;
+        }
+        if (pastTimeDifference > allowedPastTimeDifference) {
+            throw new instrumentation_error_1.InstrumentationError(`Allowed timestamp is [${allowedPastTimeDifference} ${allowedPastTimeUnit}] into the past`);
+        }
+        if (pastTimeDifference <= 0) {
+            switch (allowedFutureTimeUnit) {
+                case 'seconds':
+                    futureTimeDifference = Math.ceil(moment_timezone_1.default.duration(time.diff(currentTime)).asSeconds());
+                    break;
+                case 'minutes':
+                    futureTimeDifference = Math.ceil(moment_timezone_1.default.duration(time.diff(currentTime)).asMinutes());
+                    break;
+                case 'hours':
+                    futureTimeDifference = Math.ceil(moment_timezone_1.default.duration(time.diff(currentTime)).asHours());
+                    break;
+                default:
+                    break;
+            }
+            if (futureTimeDifference > allowedFutureTimeDifference) {
+                throw new instrumentation_error_1.InstrumentationError(`Allowed timestamp is [${allowedFutureTimeDifference} ${allowedFutureTimeUnit}] into the future`);
+            }
+        }
+    }
+    static formatValues(formattedVal, formattingType, typeFormat, integrationsObj) {
+        let curFormattedVal = formattedVal;
+        const formattingFunctions = {
+            timestamp: () => {
+                curFormattedVal = (0, misc_1.formatTimeStamp)(String(formattedVal), typeFormat);
+            },
+            secondTimestamp: () => {
+                if (!(0, moment_timezone_1.default)(String(formattedVal), 'x', true).isValid()) {
+                    curFormattedVal = Math.floor((0, misc_1.formatTimeStamp)(String(formattedVal), typeFormat) / 1000);
+                }
+            },
+            microSecondTimestamp: () => {
+                const temp_val = moment_timezone_1.default.unix(Number((0, moment_timezone_1.default)(String(formattedVal)).format('X')));
+                curFormattedVal = temp_val.toDate().getTime() * 1000 + temp_val.toDate().getMilliseconds();
+            },
+            flatJson: () => {
+                curFormattedVal = (0, misc_1.flattenJson)(formattedVal);
+            },
+            encodeURIComponent: () => {
+                const t_val = formattedVal;
+                curFormattedVal = encodeURIComponent(t_val);
+            },
+            jsonStringify: () => {
+                curFormattedVal = JSON.stringify(formattedVal);
+            },
+            jsonStringifyOnFlatten: () => {
+                curFormattedVal = JSON.stringify((0, misc_1.flattenJson)(formattedVal));
+            },
+            dobInMMDD: () => {
+                curFormattedVal = String(formattedVal).slice(5);
+                curFormattedVal = String(curFormattedVal).replace('-', '/');
+            },
+            jsonStringifyOnObject: () => {
+                if (typeof formattedVal !== 'string') {
+                    curFormattedVal = JSON.stringify(formattedVal);
+                }
+            },
+            numberForRevenue: () => {
+                if ((typeof formattedVal === 'string' || formattedVal instanceof String) &&
+                    formattedVal.charAt(0) === '$') {
+                    curFormattedVal = formattedVal.substring(1);
+                }
+                curFormattedVal = Number.parseFloat(Number(curFormattedVal || 0).toFixed(2));
+                if (Number.isNaN(curFormattedVal)) {
+                    throw new instrumentation_error_1.InstrumentationError('Revenue is not in the correct format');
+                }
+            },
+            toString: () => {
+                curFormattedVal = String(formattedVal);
+            },
+            toNumber: () => {
+                curFormattedVal = Number(formattedVal);
+            },
+            toFloat: () => {
+                curFormattedVal = parseFloat(String(formattedVal));
+            },
+            toInt: () => {
+                curFormattedVal = parseInt(String(formattedVal), 10);
+            },
+            toLower: () => {
+                curFormattedVal = String(formattedVal).toLowerCase();
+            },
+            hashToSha256: () => {
+                curFormattedVal = integrationsObj?.hashed
+                    ? String(formattedVal)
+                    : (0, misc_1.hashToSha256)(String(formattedVal));
+            },
+            getOffsetInSec: () => {
+                curFormattedVal = (0, misc_1.getOffsetInSec)(String(formattedVal));
+            },
+            domainUrl: () => {
+                curFormattedVal = String(formattedVal).replace('https://', '').replace('http://', '');
+            },
+            domainUrlV2: () => {
+                const url = (0, misc_1.isValidUrl)(formattedVal);
+                if (!url) {
+                    throw new instrumentation_error_1.InstrumentationError(`Invalid URL: ${formattedVal}`);
+                }
+                curFormattedVal = url.hostname.replace('www.', '');
+            },
+            IsBoolean: () => {
+                curFormattedVal = true;
+                if (!(typeof formattedVal === 'boolean')) {
+                    logger.debug('Boolean value missing, so dropping it');
+                    curFormattedVal = false;
+                }
+            },
+            trim: () => {
+                if (typeof formattedVal === 'string') {
+                    curFormattedVal = formattedVal.trim();
+                }
+            },
+        };
+        if (formattingType in formattingFunctions) {
+            const formattingFunction = formattingFunctions[formattingType];
+            formattingFunction();
+        }
+        return curFormattedVal;
+    }
+    static handleExcludes(value, excludes, formattedVal) {
+        if (typeof value === 'object') {
+            // exclude the fields from the formattedVal
+            excludes.forEach((key) => {
+                delete formattedVal[key];
+            });
+        }
+        else {
+            logger.warn("excludes doesn't work with non-object data type. Ignoring excludes");
+        }
+    }
+    // format the value as per the metadata values
+    // Expected metadata keys are: (according to precedence)
+    // - - type, typeFormat: expected data type and its format
+    // - - template : need to have a handlebar expression {{value}}
+    // - - excludes : fields you want to strip of from the final value (works only for object)
+    // - - - - ex: "anonymousId", "userId" from traits
+    static handleMetadataForValue(value, metadata, destKey, integrationsObj) {
+        if (!metadata) {
+            return value;
+        }
+        // get information from metadata
+        const { type, typeFormat, template, defaultValue, excludes, multikeyMap, strictMultiMap, validateTimestamp, allowedKeyCheck, } = metadata;
+        // if value is null and defaultValue is supplied - use that
+        if (!(0, misc_1.isDefinedAndNotNull)(value)) {
+            return defaultValue || value;
+        }
+        // we've got a correct value. start processing
+        let formattedVal = value;
+        /**
+         * validate allowed time difference
+         */
+        if (validateTimestamp) {
+            formattedVal = Number(formattedVal);
+            if (Number.isNaN(formattedVal)) {
+                throw new transformation_error_1.TransformationError('Timestamp is not a number, cannot validate');
+            }
+            JsonUtils.checkTimestamp(validateTimestamp, formattedVal);
+        }
+        if (type) {
+            if (Array.isArray(type)) {
+                type.forEach((eachType) => {
+                    formattedVal = JsonUtils.formatValues(formattedVal, eachType, typeFormat, integrationsObj);
+                });
+            }
+            else {
+                formattedVal = JsonUtils.formatValues(formattedVal, type, typeFormat, integrationsObj);
+            }
+        }
+        // handle template
+        if (template) {
+            formattedVal = JsonUtils.handleTemplate(template, value);
+        }
+        // handle excludes
+        if (excludes) {
+            JsonUtils.handleExcludes(value, excludes, formattedVal);
+        }
+        // handle multikeyMap
+        if (multikeyMap || strictMultiMap) {
+            formattedVal = JsonUtils.handleMultikeyMap(multikeyMap, strictMultiMap, formattedVal, destKey);
+        }
+        if (allowedKeyCheck) {
+            let foundVal = false;
+            if (Array.isArray(allowedKeyCheck)) {
+                allowedKeyCheck.some((key) => {
+                    switch (key.type) {
+                        case 'toLowerCase':
+                            formattedVal = String(formattedVal).toLowerCase();
+                            break;
+                        case 'toUpperCase':
+                            formattedVal = String(formattedVal).toUpperCase();
+                            break;
+                        default:
+                            break;
+                    }
+                    if (key.sourceVal.includes(formattedVal)) {
+                        foundVal = true;
+                        return true;
+                    }
+                    return false;
+                });
+            }
+            if (!foundVal) {
+                formattedVal = undefined;
+            }
+        }
+        return formattedVal;
+    }
+    static handleTemplate(template, value) {
+        const hTemplate = handlebars_1.default.compile(template.trim());
+        const formattedVal = hTemplate({ value }).trim();
+        return formattedVal;
+    }
+    static handleMultikeyMap(multikeyMap, strictMultiMap, formattedVal, destKey) {
+        // sourceVal is expected to be an array
+        // if value is present in sourceVal, returns the destVal
+        // else returns the original value
+        // Expected multikeyMap value:
+        // "multikeyMap": [
+        //   {
+        //     "sourceVal": ["m", "M", "Male", "male"],
+        //     "destVal": "M"
+        //   },
+        //   {
+        //     "sourceVal": ["f", "F", "Female", "female"],
+        //     "destVal": "F"
+        //   }
+        // ]
+        let curFormattedVal = formattedVal;
+        const finalKeyMap = multikeyMap || strictMultiMap;
+        let foundVal = false;
+        if (Array.isArray(finalKeyMap)) {
+            finalKeyMap.some((map) => {
+                if (!map.sourceVal || !(0, misc_1.isDefinedAndNotNull)(map.destVal) || !Array.isArray(map.sourceVal)) {
+                    logger.warn('multikeyMap skipped: sourceVal and destVal must be of valid type');
+                    foundVal = true;
+                    return true;
+                }
+                if (map.sourceVal.includes(String(formattedVal))) {
+                    curFormattedVal = map.destVal;
+                    foundVal = true;
+                    return true;
+                }
+                return false;
+            });
+        }
+        else {
+            logger.warn('multikeyMap skipped: multikeyMap must be an array');
+        }
+        if (!foundVal) {
+            if (strictMultiMap) {
+                throw new instrumentation_error_1.InstrumentationError(`Invalid entry for key ${destKey}`);
+            }
+            else {
+                curFormattedVal = undefined;
+            }
+        }
+        return curFormattedVal;
+    }
+    /**
+     * Description: This method is used to get the value from the message
+     * 						  based on the source keys
+     * @param message - the message object
+     * @param sourceKeys - the source keys to be used to get the value from the message
+     * @returns  {any} - returns the value of the source key
+     *             if the source key is not present in the message
+     *            returns null
+     */
+    static getValueFromMessage(message, sourceKeys) {
+        if (Array.isArray(sourceKeys) && sourceKeys.length > 0) {
+            if (sourceKeys.length === 1) {
+                logger.warn('List with single element is not ideal. Use it as string instead');
+            }
+            // got the possible sourceKeys
+            // eslint-disable-next-line no-restricted-syntax
+            for (const sourceKey of sourceKeys) {
+                let val;
+                // if the sourceKey is an object we expect it to be a operation
+                if (typeof sourceKey === 'object') {
+                    val = JsonUtils.handleSourceKeysOperation({
+                        message,
+                        operationObject: sourceKey,
+                    });
+                }
+                else {
+                    val = (0, get_value_1.default)(message, sourceKey);
+                }
+                if (val || val === false || val === 0) {
+                    // return only if the value is valid.
+                    // else look for next possible source in precedence
+                    return val;
+                }
+            }
+        }
+        else if (typeof sourceKeys === 'string') {
+            // got a single key
+            // - we don't need to iterate over a loop for a single possible value
+            return (0, get_value_1.default)(message, sourceKeys);
+        }
+        else if (typeof sourceKeys === 'object') {
+            // if the sourceKey is an object we expect it to be a operation
+            return JsonUtils.handleSourceKeysOperation({
+                message,
+                operationObject: sourceKeys,
+            });
+        }
+        else {
+            // wrong sourceKey type. abort
+            // DEVELOPER ERROR
+            throw new platform_error_1.PlatformError('Wrong sourceKey type or blank sourceKey array');
+        }
+        return null;
+    }
+    /**
+     * Description: This method is used to get the value from the message
+     *               based on the source key
+     * @param message - the message object
+     * @param sourceKey - the source key to be used to get the value from the message
+     * @returns  {any} - returns the value of the source key
+     *            if the source key is not present in the message
+     *           returns null
+     */
+    static getFieldValueFromMessage(message, sourceKey) {
+        const sourceKeyMap = JsonUtils.MESSAGE_MAPPING[sourceKey];
+        if (sourceKeyMap) {
+            return JsonUtils.getValueFromMessage(message, sourceKeyMap);
+        }
+        return null;
+    }
+    /**
+     * Description: This method is used to construct the payload based on the mappingJson
+     * @param message - the message object
+     * @param mappingJson - the mappingJson to be used to construct the payload
+     * @param destinationName - the destination name to be used to get the mappingJson
+     * @returns  {any} - returns the payload constructed based on the mappingJson
+     *           if the mappingJson is not present in the message or blank
+     *           returns null
+     */
+    static constructPayload(message, mappingJson, destinationName = '') {
+        // Mapping JSON should be an array
+        if (Array.isArray(mappingJson) && mappingJson.length > 0) {
+            // - construct a blank payload and return at the end
+            // - if you to need merge multiple constructPayload do it on the transformer code
+            // - - will give a cleaner approach
+            // - - you don't need to iterate over multiple loops to construct a payload for a single event
+            const payload = {};
+            mappingJson.forEach((mapping) => {
+                const { sourceKeys, destKey, required, metadata, sourceFromGenericMap, } = mapping;
+                // get the value from event, pass sourceFromGenericMap in the mapping to force this to take the
+                // sourcekeys from GenericFieldMapping, else take the sourceKeys from specific destination mapping sourceKeys
+                const integrationsObj = (0, lodash_1.isEmpty)(destinationName)
+                    ? sem_1.SemanticUtil.getIntegrationsObj(message, destinationName)
+                    : null;
+                const value = JsonUtils.handleMetadataForValue(sourceFromGenericMap
+                    ? this.getFieldValueFromMessage(message, sourceKeys)
+                    : this.getValueFromMessage(message, sourceKeys), metadata, destKey, integrationsObj);
+                if (value || value === 0 || value === false) {
+                    if (destKey) {
+                        // set the value only if correct
+                        (0, set_value_1.default)(payload, destKey, value);
+                    }
+                    else {
+                        // to set to root and flatten later
+                        payload[''] = value;
+                    }
+                }
+                else if (required) {
+                    // throw error if reqired value is missing
+                    throw new instrumentation_error_1.InstrumentationError(`Missing required value from ${JSON.stringify(sourceKeys)}`);
+                }
+            });
+            return payload;
+        }
+        // invalid mappingJson
+        return null;
+    }
+    static stringify(value) {
+        return JSON.stringify(value);
+    }
+}
+exports.JsonUtils = JsonUtils;
+JsonUtils.MESSAGE_MAPPING = constants_1.GENERIC_MAPPING_CONFIG;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/utils/json.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4DAAoC;AAEpC,0DAA4B;AAC5B,0DAA4B;AAC5B,mCAAyD;AAGzD,kDAAoC;AACpC,6DAAyD;AACzD,+BAAqC;AACrC,2EAAuE;AACvE,iCAOgB;AAChB,sEAAqC;AACrC,yEAAqE;AACrE,4CAAsD;AAqBtD,MAAa,SAAS;IAGpB;;;;;;;OAOG;IACK,MAAM,CAAC,yBAAyB,CAAC,EACvC,OAAO,EACP,eAAe,GAIhB;QACC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,eAAe,CAAC;QAE5C,yCAAyC;QACzC,oCAAoC;QACpC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YACjC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC;YACvC,MAAM,GAAG,GAAG,IAAA,mBAAG,EAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YACrC,IAAI,GAAG,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,CAAC,EAAE;gBACrC,OAAO,GAAG,CAAC;aACZ;YACD,OAAO,UAAU,CAAC;QACpB,CAAC,CAAC,CAAC;QAEH,2DAA2D;QAC3D,gDAAgD;QAChD,uCAAuC;QACvC,MAAM,YAAY,GAAG,IAAA,cAAK,EAAC,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAA,cAAK,EAAC,CAAC,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,YAAY,EAAE;YACjB,OAAO,IAAI,CAAC;SACb;QAED,4BAA4B;QAC5B,IAAI,MAAc,CAAC;QACnB,QAAQ,SAAS,EAAE;YACjB,KAAK,gBAAgB;gBACnB,MAAM,GAAG,CAAC,CAAC;gBACX,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE;oBACzB,IAAI,IAAA,iBAAQ,EAAC,CAAC,CAAC,EAAE;wBACf,MAAM,IAAI,CAAC,CAAC;qBACb;yBAAM;wBACL,uDAAuD;wBACvD,+CAA+C;wBAC/C,OAAO,IAAI,CAAC;qBACb;iBACF;gBACD,OAAO,MAAM,CAAC;YAChB,KAAK,UAAU;gBACb,MAAM,GAAG,CAAC,CAAC;gBACX,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE;oBACzB,IAAI,IAAA,iBAAQ,EAAC,CAAC,CAAC,EAAE;wBACf,MAAM,IAAI,CAAC,CAAC;qBACb;yBAAM;wBACL,uDAAuD;wBACvD,+CAA+C;wBAC/C,OAAO,IAAI,CAAC;qBACb;iBACF;gBACD,OAAO,MAAM,CAAC;YAChB;gBACE,OAAO,IAAI,CAAC;SACf;IACH,CAAC;IAEO,MAAM,CAAC,cAAc,CAC3B,iBAKC,EACD,YAAoB;QAEpB,MAAM,EACJ,yBAAyB,EACzB,mBAAmB,EAAE,0BAA0B;QAC/C,2BAA2B,EAC3B,qBAAqB,EAAE,0BAA0B;UAClD,GAAG,iBAAiB,CAAC;QAEtB,IAAI,kBAAkB,CAAC;QACvB,IAAI,oBAAoB,CAAC;QAEzB,MAAM,WAAW,GAAG,yBAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAA,yBAAM,GAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9D,MAAM,IAAI,GAAG,yBAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAA,yBAAM,EAAC,YAAY,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAEnE,QAAQ,mBAAmB,EAAE;YAC3B,KAAK,SAAS;gBACZ,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,yBAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;gBACpF,MAAM;YACR,KAAK,SAAS;gBACZ,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,yBAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;gBACpF,MAAM;YACR,KAAK,OAAO;gBACV,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,yBAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;gBAClF,MAAM;YACR;gBACE,MAAM;SACT;QAED,IAAI,kBAAkB,GAAG,yBAAyB,EAAE;YAClD,MAAM,IAAI,4CAAoB,CAC5B,yBAAyB,yBAAyB,IAAI,mBAAmB,iBAAiB,CAC3F,CAAC;SACH;QAED,IAAI,kBAAkB,IAAI,CAAC,EAAE;YAC3B,QAAQ,qBAAqB,EAAE;gBAC7B,KAAK,SAAS;oBACZ,oBAAoB,GAAG,IAAI,CAAC,IAAI,CAAC,yBAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;oBACtF,MAAM;gBACR,KAAK,SAAS;oBACZ,oBAAoB,GAAG,IAAI,CAAC,IAAI,CAAC,yBAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;oBACtF,MAAM;gBACR,KAAK,OAAO;oBACV,oBAAoB,GAAG,IAAI,CAAC,IAAI,CAAC,yBAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;oBACpF,MAAM;gBACR;oBACE,MAAM;aACT;YAED,IAAI,oBAAoB,GAAG,2BAA2B,EAAE;gBACtD,MAAM,IAAI,4CAAoB,CAC5B,yBAAyB,2BAA2B,IAAI,qBAAqB,mBAAmB,CACjG,CAAC;aACH;SACF;IACH,CAAC;IAEO,MAAM,CAAC,YAAY,CACzB,YAAqB,EACrB,cAAsB,EACtB,UAAmB,EACnB,eAAwC;QAExC,IAAI,eAAe,GAAG,YAAY,CAAC;QAEnC,MAAM,mBAAmB,GAAG;YAC1B,SAAS,EAAE,GAAG,EAAE;gBACd,eAAe,GAAG,IAAA,sBAAe,EAAC,MAAM,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,CAAC;YACtE,CAAC;YACD,eAAe,EAAE,GAAG,EAAE;gBACpB,IAAI,CAAC,IAAA,yBAAM,EAAC,MAAM,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;oBACtD,eAAe,GAAG,IAAI,CAAC,KAAK,CACzB,IAAA,sBAAe,EAAC,MAAM,CAAC,YAAY,CAAC,EAAE,UAAU,CAAY,GAAG,IAAI,CACrE,CAAC;iBACH;YACH,CAAC;YACD,oBAAoB,EAAE,GAAG,EAAE;gBACzB,MAAM,QAAQ,GAAG,yBAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAA,yBAAM,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC/E,eAAe,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,eAAe,EAAE,CAAC;YAC7F,CAAC;YACD,QAAQ,EAAE,GAAG,EAAE;gBACb,eAAe,GAAG,IAAA,kBAAW,EAAC,YAAY,CAAC,CAAC;YAC9C,CAAC;YACD,kBAAkB,EAAE,GAAG,EAAE;gBACvB,MAAM,KAAK,GAA8B,YAAyC,CAAC;gBACnF,eAAe,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;YAC9C,CAAC;YACD,aAAa,EAAE,GAAG,EAAE;gBAClB,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YACjD,CAAC;YACD,sBAAsB,EAAE,GAAG,EAAE;gBAC3B,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,IAAA,kBAAW,EAAC,YAAY,CAAC,CAAC,CAAC;YAC9D,CAAC;YACD,SAAS,EAAE,GAAG,EAAE;gBACd,eAAe,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAChD,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YAC9D,CAAC;YACD,qBAAqB,EAAE,GAAG,EAAE;gBAC1B,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE;oBACpC,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;iBAChD;YACH,CAAC;YACD,gBAAgB,EAAE,GAAG,EAAE;gBACrB,IACE,CAAC,OAAO,YAAY,KAAK,QAAQ,IAAI,YAAY,YAAY,MAAM,CAAC;oBACpE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAC9B;oBACA,eAAe,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;iBAC7C;gBACD,eAAe,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7E,IAAI,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE;oBACjC,MAAM,IAAI,4CAAoB,CAAC,sCAAsC,CAAC,CAAC;iBACxE;YACH,CAAC;YACD,QAAQ,EAAE,GAAG,EAAE;gBACb,eAAe,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;YACzC,CAAC;YACD,QAAQ,EAAE,GAAG,EAAE;gBACb,eAAe,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;YACzC,CAAC;YACD,OAAO,EAAE,GAAG,EAAE;gBACZ,eAAe,GAAG,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;YACrD,CAAC;YACD,KAAK,EAAE,GAAG,EAAE;gBACV,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAAC;YACvD,CAAC;YACD,OAAO,EAAE,GAAG,EAAE;gBACZ,eAAe,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,WAAW,EAAE,CAAC;YACvD,CAAC;YACD,YAAY,EAAE,GAAG,EAAE;gBACjB,eAAe,GAAG,eAAe,EAAE,MAAM;oBACvC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;oBACtB,CAAC,CAAC,IAAA,mBAAY,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;YACzC,CAAC;YACD,cAAc,EAAE,GAAG,EAAE;gBACnB,eAAe,GAAG,IAAA,qBAAc,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;YACzD,CAAC;YACD,SAAS,EAAE,GAAG,EAAE;gBACd,eAAe,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;YACxF,CAAC;YACD,WAAW,EAAE,GAAG,EAAE;gBAChB,MAAM,GAAG,GAAG,IAAA,iBAAU,EAAC,YAA4B,CAAC,CAAC;gBACrD,IAAI,CAAC,GAAG,EAAE;oBACR,MAAM,IAAI,4CAAoB,CAAC,gBAAgB,YAAY,EAAE,CAAC,CAAC;iBAChE;gBACD,eAAe,GAAG,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YACrD,CAAC;YACD,SAAS,EAAE,GAAG,EAAE;gBACd,eAAe,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,CAAC,OAAO,YAAY,KAAK,SAAS,CAAC,EAAE;oBACxC,MAAM,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC;oBACtD,eAAe,GAAG,KAAK,CAAC;iBACzB;YACH,CAAC;YACD,IAAI,EAAE,GAAG,EAAE;gBACT,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE;oBACpC,eAAe,GAAG,YAAY,CAAC,IAAI,EAAE,CAAC;iBACvC;YACH,CAAC;SACF,CAAC;QAEF,IAAI,cAAc,IAAI,mBAAmB,EAAE;YACzC,MAAM,kBAAkB,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAC;YAC/D,kBAAkB,EAAE,CAAC;SACtB;QAED,OAAO,eAAe,CAAC;IACzB,CAAC;IAEO,MAAM,CAAC,cAAc,CAC3B,KAAc,EACd,QAAkB,EAClB,YAAoC;QAEpC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,2CAA2C;YAC3C,QAAQ,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;gBACvB,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC;YAC3B,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,oEAAoE,CAAC,CAAC;SACnF;IACH,CAAC;IAED,8CAA8C;IAC9C,wDAAwD;IACxD,0DAA0D;IAC1D,+DAA+D;IAC/D,0FAA0F;IAC1F,kDAAkD;IAC1C,MAAM,CAAC,sBAAsB,CACnC,KAAc,EACd,QAAyB,EACzB,OAAe,EACf,eAAwB;QAExB,IAAI,CAAC,QAAQ,EAAE;YACb,OAAO,KAAK,CAAC;SACd;QAED,gCAAgC;QAChC,MAAM,EACJ,IAAI,EACJ,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,GAAG,QAAQ,CAAC;QAEb,2DAA2D;QAC3D,IAAI,CAAC,IAAA,0BAAmB,EAAC,KAAK,CAAC,EAAE;YAC/B,OAAO,YAAY,IAAI,KAAK,CAAC;SAC9B;QACD,8CAA8C;QAC9C,IAAI,YAAY,GAAG,KAAK,CAAC;QAEzB;;WAEG;QACH,IAAI,iBAAiB,EAAE;YACrB,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;YACpC,IAAI,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE;gBAC9B,MAAM,IAAI,0CAAmB,CAAC,4CAA4C,CAAC,CAAC;aAC7E;YACD,SAAS,CAAC,cAAc,CAAC,iBAAiB,EAAE,YAAsB,CAAC,CAAC;SACrE;QAED,IAAI,IAAI,EAAE;YACR,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACvB,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;oBACxB,YAAY,GAAG,SAAS,CAAC,YAAY,CACnC,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,eAA6C,CAC9C,CAAC;gBACJ,CAAC,CAAC,CAAC;aACJ;iBAAM;gBACL,YAAY,GAAG,SAAS,CAAC,YAAY,CACnC,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,eAA6C,CAC9C,CAAC;aACH;SACF;QAED,kBAAkB;QAClB,IAAI,QAAQ,EAAE;YACZ,YAAY,GAAG,SAAS,CAAC,cAAc,CAAC,QAAQ,EAAE,KAAe,CAAC,CAAC;SACpE;QAED,kBAAkB;QAClB,IAAI,QAAQ,EAAE;YACZ,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,YAAsC,CAAC,CAAC;SACnF;QAED,qBAAqB;QACrB,IAAI,WAAW,IAAI,cAAc,EAAE;YACjC,YAAY,GAAG,SAAS,CAAC,iBAAiB,CACxC,WAAW,EACX,cAAc,EACd,YAAY,EACZ,OAAO,CACR,CAAC;SACH;QAED,IAAI,eAAe,EAAE;YACnB,IAAI,QAAQ,GAAG,KAAK,CAAC;YACrB,IAAI,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE;gBAClC,eAAe,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;oBAC3B,QAAQ,GAAG,CAAC,IAAI,EAAE;wBAChB,KAAK,aAAa;4BAChB,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,WAAW,EAAE,CAAC;4BAClD,MAAM;wBACR,KAAK,aAAa;4BAChB,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,WAAW,EAAE,CAAC;4BAClD,MAAM;wBACR;4BACE,MAAM;qBACT;oBACD,IAAI,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,YAAmB,CAAC,EAAE;wBAC/C,QAAQ,GAAG,IAAI,CAAC;wBAChB,OAAO,IAAI,CAAC;qBACb;oBACD,OAAO,KAAK,CAAC;gBACf,CAAC,CAAC,CAAC;aACJ;YACD,IAAI,CAAC,QAAQ,EAAE;gBACb,YAAY,GAAG,SAAS,CAAC;aAC1B;SACF;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,MAAM,CAAC,cAAc,CAAC,QAAgB,EAAE,KAAa;QAC3D,MAAM,SAAS,GAAG,oBAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QACtD,MAAM,YAAY,GAAG,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACjD,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,MAAM,CAAC,iBAAiB,CAC9B,WAIa,EACb,cAKa,EACb,YAAqB,EACrB,OAAe;QAEf,uCAAuC;QACvC,wDAAwD;QACxD,kCAAkC;QAClC,8BAA8B;QAC9B,mBAAmB;QACnB,MAAM;QACN,+CAA+C;QAC/C,qBAAqB;QACrB,OAAO;QACP,MAAM;QACN,mDAAmD;QACnD,qBAAqB;QACrB,MAAM;QACN,IAAI;QACJ,IAAI,eAAe,GAAG,YAAY,CAAC;QACnC,MAAM,WAAW,GAAG,WAAW,IAAI,cAAc,CAAC;QAClD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;YAC9B,WAAW,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;gBACvB,IAAI,CAAC,GAAG,CAAC,SAAS,IAAI,CAAC,IAAA,0BAAmB,EAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;oBACxF,MAAM,CAAC,IAAI,CAAC,kEAAkE,CAAC,CAAC;oBAChF,QAAQ,GAAG,IAAI,CAAC;oBAChB,OAAO,IAAI,CAAC;iBACb;gBAED,IAAI,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE;oBAChD,eAAe,GAAG,GAAG,CAAC,OAAO,CAAC;oBAC9B,QAAQ,GAAG,IAAI,CAAC;oBAChB,OAAO,IAAI,CAAC;iBACb;gBAED,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;SAClE;QACD,IAAI,CAAC,QAAQ,EAAE;YACb,IAAI,cAAc,EAAE;gBAClB,MAAM,IAAI,4CAAoB,CAAC,yBAAyB,OAAO,EAAE,CAAC,CAAC;aACpE;iBAAM;gBACL,eAAe,GAAG,SAAS,CAAC;aAC7B;SACF;QACD,OAAO,eAAe,CAAC;IACzB,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,mBAAmB,CAC/B,OAAyB,EACzB,UAAiD;QAEjD,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;YACtD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC3B,MAAM,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;aAChF;YACD,8BAA8B;YAC9B,gDAAgD;YAChD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;gBAClC,IAAI,GAA2D,CAAC;gBAChE,+DAA+D;gBAC/D,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;oBACjC,GAAG,GAAG,SAAS,CAAC,yBAAyB,CAAC;wBACxC,OAAO;wBACP,eAAe,EAAE,SAAsB;qBACxC,CAAC,CAAC;iBACJ;qBAAM;oBACL,GAAG,GAAG,IAAA,mBAAG,EAAC,OAAO,EAAE,SAAS,CAAC,CAAC;iBAC/B;gBACD,IAAI,GAAG,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,CAAC,EAAE;oBACrC,qCAAqC;oBACrC,mDAAmD;oBACnD,OAAO,GAAG,CAAC;iBACZ;aACF;SACF;aAAM,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;YACzC,mBAAmB;YACnB,qEAAqE;YACrE,OAAO,IAAA,mBAAG,EAAC,OAAO,EAAE,UAAU,CAAC,CAAC;SACjC;aAAM,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;YACzC,+DAA+D;YAC/D,OAAO,SAAS,CAAC,yBAAyB,CAAC;gBACzC,OAAO;gBACP,eAAe,EAAE,UAAgD;aAClE,CAAC,CAAC;SACJ;aAAM;YACL,8BAA8B;YAC9B,kBAAkB;YAClB,MAAM,IAAI,8BAAa,CAAC,+CAA+C,CAAC,CAAC;SAC1E;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,wBAAwB,CAAC,OAAyB,EAAE,SAAiB;QACjF,MAAM,YAAY,GAAG,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC1D,IAAI,YAAY,EAAE;YAChB,OAAO,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;SAC7D;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,gBAAgB,CAC5B,OAAyB,EACzB,WAAkB,EAClB,kBAA0B,EAAE;QAE5B,kCAAkC;QAClC,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;YACxD,oDAAoD;YACpD,iFAAiF;YACjF,mCAAmC;YACnC,8FAA8F;YAC9F,MAAM,OAAO,GAAG,EAAE,CAAC;YAEnB,WAAW,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC9B,MAAM,EACJ,UAAU,EACV,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,oBAAoB,GACrB,GAMG,OAAO,CAAC;gBACZ,+FAA+F;gBAC/F,6GAA6G;gBAC7G,MAAM,eAAe,GAAG,IAAA,gBAAO,EAAC,eAAe,CAAC;oBAC9C,CAAC,CAAC,kBAAY,CAAC,kBAAkB,CAAC,OAAO,EAAE,eAAe,CAAC;oBAC3D,CAAC,CAAC,IAAI,CAAC;gBACT,MAAM,KAAK,GAAG,SAAS,CAAC,sBAAsB,CAC5C,oBAAoB;oBAClB,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,OAAO,EAAE,UAAoB,CAAC;oBAC9D,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC,EACjD,QAAQ,EACR,OAAO,EACP,eAAe,CAChB,CAAC;gBAEF,IAAI,KAAK,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,KAAK,EAAE;oBAC3C,IAAI,OAAO,EAAE;wBACX,gCAAgC;wBAChC,IAAA,mBAAG,EAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;qBAC9B;yBAAM;wBACL,mCAAmC;wBACnC,OAAO,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;qBACrB;iBACF;qBAAM,IAAI,QAAQ,EAAE;oBACnB,0CAA0C;oBAC1C,MAAM,IAAI,4CAAoB,CAC5B,+BAA+B,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAC5D,CAAC;iBACH;YACH,CAAC,CAAC,CAAC;YAEH,OAAO,OAAO,CAAC;SAChB;QAED,sBAAsB;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,MAAM,CAAC,SAAS,CAAC,KAAc;QACpC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;;AAhlBH,8BAilBC;AAhlBgB,yBAAe,GAAG,kCAAsB,CAAC","sourcesContent":["import Handlebars from 'handlebars';\nimport { RudderStackEvent } from '../types';\nimport get from 'get-value';\nimport set from 'set-value';\nimport { every, isEmpty, isNil, isNumber } from 'lodash';\nimport path from 'path';\nimport fs from 'fs';\nimport * as logger from '../logger';\nimport { PlatformError } from '../errors/platform_error';\nimport { SemanticUtil } from './sem';\nimport { InstrumentationError } from '../errors/instrumentation_error';\nimport {\n  flattenJson,\n  formatTimeStamp,\n  getOffsetInSec,\n  hashToSha256,\n  isDefinedAndNotNull,\n  isValidUrl,\n} from './misc';\nimport moment from 'moment-timezone';\nimport { TransformationError } from '../errors/transformation_error';\nimport { GENERIC_MAPPING_CONFIG } from '../constants';\ntype Operation = {\n  operation: string;\n  args: { sourceKeys: string[]; defaultVal?: any }[];\n};\ntype MappingMetadata = {\n  type?: string | string[];\n  typeFormat?: string;\n  template?: string;\n  defaultValue?: unknown;\n  excludes?: string[];\n  multikeyMap?: { [key: string]: string[] };\n  strictMultiMap?: { sourceVal: string[]; destVal: string }[];\n  validateTimestamp?: {\n    allowedFutureTimeDifference: number;\n    allowedFutureTimeUnit: string;\n    allowedPastTimeDifference: number;\n    allowedPastTimeUnit: string;\n  };\n  allowedKeyCheck?: { type: string; sourceVal: string[] }[];\n}\nexport class JsonUtils {\n  private static MESSAGE_MAPPING = GENERIC_MAPPING_CONFIG;\n\n  /**\n   * Description: This method is used to handle the source keys operation\n   * @param message - the message object\n   * @returns\t{any}\t- returns the value of the source key\n   * \t\t\t\t\t\tif the source key is not present in the message\n   * \t\t\t\t\t\treturns null\n   *\n   */\n  private static handleSourceKeysOperation({\n    message,\n    operationObject,\n  }: {\n    message: RudderStackEvent;\n    operationObject: Operation;\n  }): any {\n    const { operation, args } = operationObject;\n\n    // populate the values from the arguments\n    // in the same order it is populated\n    const argValues = args.map((arg) => {\n      const { sourceKeys, defaultVal } = arg;\n      const val = get(message, sourceKeys);\n      if (val || val === false || val === 0) {\n        return val;\n      }\n      return defaultVal;\n    });\n\n    // quick sanity check for the undefined values in the list.\n    // if there is any undefined values, return null\n    // without going further for operations\n    const isAllDefined = every(argValues, (v) => !isNil(v));\n    if (!isAllDefined) {\n      return null;\n    }\n\n    // start handling operations\n    let result: number;\n    switch (operation) {\n      case 'multiplication':\n        result = 1;\n        for (const v of argValues) {\n          if (isNumber(v)) {\n            result *= v;\n          } else {\n            // if there is a non number argument simply return null\n            // non numbers can't be operated arithmatically\n            return null;\n          }\n        }\n        return result;\n      case 'addition':\n        result = 0;\n        for (const v of argValues) {\n          if (isNumber(v)) {\n            result += v;\n          } else {\n            // if there is a non number argument simply return null\n            // non numbers can't be operated arithmatically\n            return null;\n          }\n        }\n        return result;\n      default:\n        return null;\n    }\n  }\n\n  private static checkTimestamp(\n    validateTimestamp: {\n      allowedFutureTimeDifference: number;\n      allowedFutureTimeUnit: string;\n      allowedPastTimeDifference: number;\n      allowedPastTimeUnit: string;\n    },\n    formattedVal: number,\n  ) {\n    const {\n      allowedPastTimeDifference,\n      allowedPastTimeUnit, // seconds, minutes, hours\n      allowedFutureTimeDifference,\n      allowedFutureTimeUnit, // seconds, minutes, hours\n    } = validateTimestamp;\n\n    let pastTimeDifference;\n    let futureTimeDifference;\n\n    const currentTime = moment.unix(Number(moment().format('X')));\n    const time = moment.unix(Number(moment(formattedVal).format('X')));\n\n    switch (allowedPastTimeUnit) {\n      case 'seconds':\n        pastTimeDifference = Math.ceil(moment.duration(currentTime.diff(time)).asSeconds());\n        break;\n      case 'minutes':\n        pastTimeDifference = Math.ceil(moment.duration(currentTime.diff(time)).asMinutes());\n        break;\n      case 'hours':\n        pastTimeDifference = Math.ceil(moment.duration(currentTime.diff(time)).asHours());\n        break;\n      default:\n        break;\n    }\n\n    if (pastTimeDifference > allowedPastTimeDifference) {\n      throw new InstrumentationError(\n        `Allowed timestamp is [${allowedPastTimeDifference} ${allowedPastTimeUnit}] into the past`,\n      );\n    }\n\n    if (pastTimeDifference <= 0) {\n      switch (allowedFutureTimeUnit) {\n        case 'seconds':\n          futureTimeDifference = Math.ceil(moment.duration(time.diff(currentTime)).asSeconds());\n          break;\n        case 'minutes':\n          futureTimeDifference = Math.ceil(moment.duration(time.diff(currentTime)).asMinutes());\n          break;\n        case 'hours':\n          futureTimeDifference = Math.ceil(moment.duration(time.diff(currentTime)).asHours());\n          break;\n        default:\n          break;\n      }\n\n      if (futureTimeDifference > allowedFutureTimeDifference) {\n        throw new InstrumentationError(\n          `Allowed timestamp is [${allowedFutureTimeDifference} ${allowedFutureTimeUnit}] into the future`,\n        );\n      }\n    }\n  }\n\n  private static formatValues(\n    formattedVal: unknown,\n    formattingType: string,\n    typeFormat?: string,\n    integrationsObj?: { [key: string]: any },\n  ) {\n    let curFormattedVal = formattedVal;\n\n    const formattingFunctions = {\n      timestamp: () => {\n        curFormattedVal = formatTimeStamp(String(formattedVal), typeFormat);\n      },\n      secondTimestamp: () => {\n        if (!moment(String(formattedVal), 'x', true).isValid()) {\n          curFormattedVal = Math.floor(\n            (formatTimeStamp(String(formattedVal), typeFormat) as number) / 1000,\n          );\n        }\n      },\n      microSecondTimestamp: () => {\n        const temp_val = moment.unix(Number(moment(String(formattedVal)).format('X')));\n        curFormattedVal = temp_val.toDate().getTime() * 1000 + temp_val.toDate().getMilliseconds();\n      },\n      flatJson: () => {\n        curFormattedVal = flattenJson(formattedVal);\n      },\n      encodeURIComponent: () => {\n        const t_val: string | number | boolean = formattedVal as string | number | boolean;\n        curFormattedVal = encodeURIComponent(t_val);\n      },\n      jsonStringify: () => {\n        curFormattedVal = JSON.stringify(formattedVal);\n      },\n      jsonStringifyOnFlatten: () => {\n        curFormattedVal = JSON.stringify(flattenJson(formattedVal));\n      },\n      dobInMMDD: () => {\n        curFormattedVal = String(formattedVal).slice(5);\n        curFormattedVal = String(curFormattedVal).replace('-', '/');\n      },\n      jsonStringifyOnObject: () => {\n        if (typeof formattedVal !== 'string') {\n          curFormattedVal = JSON.stringify(formattedVal);\n        }\n      },\n      numberForRevenue: () => {\n        if (\n          (typeof formattedVal === 'string' || formattedVal instanceof String) &&\n          formattedVal.charAt(0) === '$'\n        ) {\n          curFormattedVal = formattedVal.substring(1);\n        }\n        curFormattedVal = Number.parseFloat(Number(curFormattedVal || 0).toFixed(2));\n        if (Number.isNaN(curFormattedVal)) {\n          throw new InstrumentationError('Revenue is not in the correct format');\n        }\n      },\n      toString: () => {\n        curFormattedVal = String(formattedVal);\n      },\n      toNumber: () => {\n        curFormattedVal = Number(formattedVal);\n      },\n      toFloat: () => {\n        curFormattedVal = parseFloat(String(formattedVal));\n      },\n      toInt: () => {\n        curFormattedVal = parseInt(String(formattedVal), 10);\n      },\n      toLower: () => {\n        curFormattedVal = String(formattedVal).toLowerCase();\n      },\n      hashToSha256: () => {\n        curFormattedVal = integrationsObj?.hashed\n          ? String(formattedVal)\n          : hashToSha256(String(formattedVal));\n      },\n      getOffsetInSec: () => {\n        curFormattedVal = getOffsetInSec(String(formattedVal));\n      },\n      domainUrl: () => {\n        curFormattedVal = String(formattedVal).replace('https://', '').replace('http://', '');\n      },\n      domainUrlV2: () => {\n        const url = isValidUrl(formattedVal as string | URL);\n        if (!url) {\n          throw new InstrumentationError(`Invalid URL: ${formattedVal}`);\n        }\n        curFormattedVal = url.hostname.replace('www.', '');\n      },\n      IsBoolean: () => {\n        curFormattedVal = true;\n        if (!(typeof formattedVal === 'boolean')) {\n          logger.debug('Boolean value missing, so dropping it');\n          curFormattedVal = false;\n        }\n      },\n      trim: () => {\n        if (typeof formattedVal === 'string') {\n          curFormattedVal = formattedVal.trim();\n        }\n      },\n    };\n\n    if (formattingType in formattingFunctions) {\n      const formattingFunction = formattingFunctions[formattingType];\n      formattingFunction();\n    }\n\n    return curFormattedVal;\n  }\n\n  private static handleExcludes(\n    value: unknown,\n    excludes: string[],\n    formattedVal: { [key: string]: any },\n  ) {\n    if (typeof value === 'object') {\n      // exclude the fields from the formattedVal\n      excludes.forEach((key) => {\n        delete formattedVal[key];\n      });\n    } else {\n      logger.warn(\"excludes doesn't work with non-object data type. Ignoring excludes\");\n    }\n  }\n\n  // format the value as per the metadata values\n  // Expected metadata keys are: (according to precedence)\n  // - - type, typeFormat: expected data type and its format\n  // - - template : need to have a handlebar expression {{value}}\n  // - - excludes : fields you want to strip of from the final value (works only for object)\n  // - - - - ex: \"anonymousId\", \"userId\" from traits\n  private static handleMetadataForValue(\n    value: unknown,\n    metadata: MappingMetadata,\n    destKey: string,\n    integrationsObj: unknown,\n  ) {\n    if (!metadata) {\n      return value;\n    }\n\n    // get information from metadata\n    const {\n      type,\n      typeFormat,\n      template,\n      defaultValue,\n      excludes,\n      multikeyMap,\n      strictMultiMap,\n      validateTimestamp,\n      allowedKeyCheck,\n    } = metadata;\n\n    // if value is null and defaultValue is supplied - use that\n    if (!isDefinedAndNotNull(value)) {\n      return defaultValue || value;\n    }\n    // we've got a correct value. start processing\n    let formattedVal = value;\n\n    /**\n     * validate allowed time difference\n     */\n    if (validateTimestamp) {\n      formattedVal = Number(formattedVal);\n      if (Number.isNaN(formattedVal)) {\n        throw new TransformationError('Timestamp is not a number, cannot validate');\n      }\n      JsonUtils.checkTimestamp(validateTimestamp, formattedVal as number);\n    }\n\n    if (type) {\n      if (Array.isArray(type)) {\n        type.forEach((eachType) => {\n          formattedVal = JsonUtils.formatValues(\n            formattedVal,\n            eachType,\n            typeFormat,\n            integrationsObj as { [key: string]: unknown },\n          );\n        });\n      } else {\n        formattedVal = JsonUtils.formatValues(\n          formattedVal,\n          type,\n          typeFormat,\n          integrationsObj as { [key: string]: unknown },\n        );\n      }\n    }\n\n    // handle template\n    if (template) {\n      formattedVal = JsonUtils.handleTemplate(template, value as string);\n    }\n\n    // handle excludes\n    if (excludes) {\n      JsonUtils.handleExcludes(value, excludes, formattedVal as { [key: string]: any });\n    }\n\n    // handle multikeyMap\n    if (multikeyMap || strictMultiMap) {\n      formattedVal = JsonUtils.handleMultikeyMap(\n        multikeyMap,\n        strictMultiMap,\n        formattedVal,\n        destKey,\n      );\n    }\n\n    if (allowedKeyCheck) {\n      let foundVal = false;\n      if (Array.isArray(allowedKeyCheck)) {\n        allowedKeyCheck.some((key) => {\n          switch (key.type) {\n            case 'toLowerCase':\n              formattedVal = String(formattedVal).toLowerCase();\n              break;\n            case 'toUpperCase':\n              formattedVal = String(formattedVal).toUpperCase();\n              break;\n            default:\n              break;\n          }\n          if (key.sourceVal.includes(formattedVal as any)) {\n            foundVal = true;\n            return true;\n          }\n          return false;\n        });\n      }\n      if (!foundVal) {\n        formattedVal = undefined;\n      }\n    }\n\n    return formattedVal;\n  }\n\n  private static handleTemplate(template: string, value: string) {\n    const hTemplate = Handlebars.compile(template.trim());\n    const formattedVal = hTemplate({ value }).trim();\n    return formattedVal;\n  }\n\n  private static handleMultikeyMap(\n    multikeyMap:\n      | {\n          [key: string]: string[];\n        }\n      | undefined,\n    strictMultiMap:\n      | {\n          sourceVal: string[];\n          destVal: string;\n        }[]\n      | undefined,\n    formattedVal: unknown,\n    destKey: string,\n  ) {\n    // sourceVal is expected to be an array\n    // if value is present in sourceVal, returns the destVal\n    // else returns the original value\n    // Expected multikeyMap value:\n    // \"multikeyMap\": [\n    //   {\n    //     \"sourceVal\": [\"m\", \"M\", \"Male\", \"male\"],\n    //     \"destVal\": \"M\"\n    //   },\n    //   {\n    //     \"sourceVal\": [\"f\", \"F\", \"Female\", \"female\"],\n    //     \"destVal\": \"F\"\n    //   }\n    // ]\n    let curFormattedVal = formattedVal;\n    const finalKeyMap = multikeyMap || strictMultiMap;\n    let foundVal = false;\n    if (Array.isArray(finalKeyMap)) {\n      finalKeyMap.some((map) => {\n        if (!map.sourceVal || !isDefinedAndNotNull(map.destVal) || !Array.isArray(map.sourceVal)) {\n          logger.warn('multikeyMap skipped: sourceVal and destVal must be of valid type');\n          foundVal = true;\n          return true;\n        }\n\n        if (map.sourceVal.includes(String(formattedVal))) {\n          curFormattedVal = map.destVal;\n          foundVal = true;\n          return true;\n        }\n\n        return false;\n      });\n    } else {\n      logger.warn('multikeyMap skipped: multikeyMap must be an array');\n    }\n    if (!foundVal) {\n      if (strictMultiMap) {\n        throw new InstrumentationError(`Invalid entry for key ${destKey}`);\n      } else {\n        curFormattedVal = undefined;\n      }\n    }\n    return curFormattedVal;\n  }\n\n  /**\n   * Description: This method is used to get the value from the message\n   * \t\t\t\t\t\t  based on the source keys\n   * @param message - the message object\n   * @param sourceKeys - the source keys to be used to get the value from the message\n   * @returns  {any} - returns the value of the source key\n   *             if the source key is not present in the message\n   *            returns null\n   */\n  public static getValueFromMessage(\n    message: RudderStackEvent,\n    sourceKeys: (string | object)[] | string | object,\n  ): any {\n    if (Array.isArray(sourceKeys) && sourceKeys.length > 0) {\n      if (sourceKeys.length === 1) {\n        logger.warn('List with single element is not ideal. Use it as string instead');\n      }\n      // got the possible sourceKeys\n      // eslint-disable-next-line no-restricted-syntax\n      for (const sourceKey of sourceKeys) {\n        let val: number | string | boolean | Array<any> | Object | null;\n        // if the sourceKey is an object we expect it to be a operation\n        if (typeof sourceKey === 'object') {\n          val = JsonUtils.handleSourceKeysOperation({\n            message,\n            operationObject: sourceKey as Operation,\n          });\n        } else {\n          val = get(message, sourceKey);\n        }\n        if (val || val === false || val === 0) {\n          // return only if the value is valid.\n          // else look for next possible source in precedence\n          return val;\n        }\n      }\n    } else if (typeof sourceKeys === 'string') {\n      // got a single key\n      // - we don't need to iterate over a loop for a single possible value\n      return get(message, sourceKeys);\n    } else if (typeof sourceKeys === 'object') {\n      // if the sourceKey is an object we expect it to be a operation\n      return JsonUtils.handleSourceKeysOperation({\n        message,\n        operationObject: sourceKeys as { operation: string; args: any[] },\n      });\n    } else {\n      // wrong sourceKey type. abort\n      // DEVELOPER ERROR\n      throw new PlatformError('Wrong sourceKey type or blank sourceKey array');\n    }\n    return null;\n  }\n\n  /**\n   * Description: This method is used to get the value from the message\n   *               based on the source key\n   * @param message - the message object\n   * @param sourceKey - the source key to be used to get the value from the message\n   * @returns  {any} - returns the value of the source key\n   *            if the source key is not present in the message\n   *           returns null\n   */\n  public static getFieldValueFromMessage(message: RudderStackEvent, sourceKey: string): any {\n    const sourceKeyMap = JsonUtils.MESSAGE_MAPPING[sourceKey];\n    if (sourceKeyMap) {\n      return JsonUtils.getValueFromMessage(message, sourceKeyMap);\n    }\n    return null;\n  }\n\n  /**\n   * Description: This method is used to construct the payload based on the mappingJson\n   * @param message - the message object\n   * @param mappingJson - the mappingJson to be used to construct the payload\n   * @param destinationName - the destination name to be used to get the mappingJson\n   * @returns  {any} - returns the payload constructed based on the mappingJson\n   *           if the mappingJson is not present in the message or blank\n   *           returns null\n   */\n  public static constructPayload(\n    message: RudderStackEvent,\n    mappingJson: any[],\n    destinationName: string = '',\n  ): any {\n    // Mapping JSON should be an array\n    if (Array.isArray(mappingJson) && mappingJson.length > 0) {\n      // - construct a blank payload and return at the end\n      // - if you to need merge multiple constructPayload do it on the transformer code\n      // - - will give a cleaner approach\n      // - - you don't need to iterate over multiple loops to construct a payload for a single event\n      const payload = {};\n\n      mappingJson.forEach((mapping) => {\n        const {\n          sourceKeys,\n          destKey,\n          required,\n          metadata,\n          sourceFromGenericMap,\n        }: {\n          sourceKeys: (string | object)[] | string | object;\n          destKey: string;\n          required: boolean;\n          metadata: MappingMetadata;\n          sourceFromGenericMap: boolean;\n        } = mapping;\n        // get the value from event, pass sourceFromGenericMap in the mapping to force this to take the\n        // sourcekeys from GenericFieldMapping, else take the sourceKeys from specific destination mapping sourceKeys\n        const integrationsObj = isEmpty(destinationName)\n          ? SemanticUtil.getIntegrationsObj(message, destinationName)\n          : null;\n        const value = JsonUtils.handleMetadataForValue(\n          sourceFromGenericMap\n            ? this.getFieldValueFromMessage(message, sourceKeys as string)\n            : this.getValueFromMessage(message, sourceKeys),\n          metadata,\n          destKey,\n          integrationsObj,\n        );\n\n        if (value || value === 0 || value === false) {\n          if (destKey) {\n            // set the value only if correct\n            set(payload, destKey, value);\n          } else {\n            // to set to root and flatten later\n            payload[''] = value;\n          }\n        } else if (required) {\n          // throw error if reqired value is missing\n          throw new InstrumentationError(\n            `Missing required value from ${JSON.stringify(sourceKeys)}`,\n          );\n        }\n      });\n\n      return payload;\n    }\n\n    // invalid mappingJson\n    return null;\n  }\n\n  public static stringify(value: unknown): string {\n    return JSON.stringify(value);\n  }\n}\n"]}

package/build/utils/json.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json.test.d.ts.map

package/build/utils/json.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.test.d.ts","sourceRoot":"","sources":["../../src/utils/json.test.ts"],"names":[],"mappings":""}