@blotoutio/edgetag-sdk-browser 1.35.1 → 1.36.0

package/index.js

@@ -509,6 +509,306 @@
         return true;
     };
 
+    /**
+     * Get a nested value from an object using dot notation
+     */
+    const getNestedValue = (obj, path) => {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (typeof current !== 'object') {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    };
+    /**
+     * Set a nested value in an object using dot notation
+     */
+    const setNestedValue = (obj, path, value) => {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            const existing = current[part];
+            if (existing === undefined) {
+                current[part] = {};
+            }
+            else if (existing === null || typeof existing === 'object') {
+                // null can be overwritten with an object
+                // existing objects can be traversed
+                current[part] || (current[part] = {});
+            }
+            else {
+                // existing is a primitive type (string, number, boolean, etc.)
+                console.log(`Cannot set nested path "${path}": "${parts
+                .slice(0, i + 1)
+                .join('.')}" is already a ${typeof existing} and cannot be converted to an object`);
+                return;
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    };
+    /**
+     * Remove a nested value from an object using dot notation
+     */
+    const removeNestedValue = (obj, path) => {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            const existing = current[part];
+            if (existing !== null && typeof existing === 'object') {
+                current = current[part];
+            }
+            else {
+                return;
+            }
+        }
+        delete current[parts[parts.length - 1]];
+    };
+    /**
+     * Evaluate a single condition rule
+     */
+    const evaluateCondition = (condition, payload, userData = {}) => {
+        let fieldValue;
+        if (condition.field.startsWith('user.')) {
+            const userPath = condition.field.replace('user.', '');
+            fieldValue = getNestedValue(userData, userPath);
+        }
+        else if (condition.field.startsWith('payload.')) {
+            const payloadPath = condition.field.replace('payload.', '');
+            if (payloadPath.includes('[]')) {
+                const [arrayPath, arrayField] = payloadPath.split('[]');
+                const arrayValue = getNestedValue(payload, arrayPath);
+                if (Array.isArray(arrayValue)) {
+                    const fieldName = arrayField.startsWith('.')
+                        ? arrayField.slice(1)
+                        : arrayField;
+                    fieldValue = arrayValue.flatMap((item) => typeof item === 'object' && item !== null
+                        ? item[fieldName]
+                        : []);
+                }
+                else {
+                    fieldValue = undefined;
+                }
+            }
+            else {
+                fieldValue = getNestedValue(payload, payloadPath);
+            }
+        }
+        else {
+            fieldValue = getNestedValue(payload.data, condition.field);
+        }
+        const operator = condition.operator;
+        const conditionValue = condition.value;
+        switch (operator) {
+            case 'equals':
+                return fieldValue === conditionValue;
+            case 'notEquals':
+                return fieldValue !== conditionValue;
+            case 'greaterThan':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue > conditionValue);
+            case 'greaterThanOrEqual':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue >= conditionValue);
+            case 'lessThan':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue < conditionValue);
+            case 'lessThanOrEqual':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue <= conditionValue);
+            case 'contains':
+                if (Array.isArray(fieldValue)) {
+                    // For array fields, check if any item in the array contains the condition value
+                    return (typeof conditionValue === 'string' &&
+                        fieldValue.some((val) => typeof val === 'string' && val === conditionValue));
+                }
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    fieldValue.includes(conditionValue));
+            case 'notContains':
+                if (Array.isArray(fieldValue)) {
+                    // For array fields, check if no item in the array contains the condition value
+                    return (typeof conditionValue === 'string' &&
+                        !fieldValue.some((val) => typeof val === 'string' && val === conditionValue));
+                }
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    !fieldValue.includes(conditionValue));
+            case 'in':
+                if (Array.isArray(fieldValue)) {
+                    return (Array.isArray(conditionValue) &&
+                        fieldValue.some((val) => conditionValue.includes(val)));
+                }
+                return (Array.isArray(conditionValue) &&
+                    conditionValue.some((val) => val === fieldValue));
+            case 'notIn':
+                if (Array.isArray(fieldValue)) {
+                    return (Array.isArray(conditionValue) &&
+                        !fieldValue.some((val) => conditionValue.includes(val)));
+                }
+                return (Array.isArray(conditionValue) &&
+                    !conditionValue.some((val) => val === fieldValue));
+            case 'startsWith':
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    fieldValue.startsWith(conditionValue));
+            case 'endsWith':
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    fieldValue.endsWith(conditionValue));
+            case 'isNull':
+                return fieldValue === null || fieldValue === undefined;
+            case 'isNotNull':
+                return fieldValue !== null && fieldValue !== undefined;
+            default:
+                return false;
+        }
+    };
+    /**
+     * Evaluate conditions for a simplified rule (no nested groups)
+     */
+    const evaluateConditions = (conditions, logicalOperator, payload, userData = {}) => {
+        if (conditions.length === 0) {
+            return true;
+        }
+        if (logicalOperator === 'AND') {
+            return conditions.every((condition) => evaluateCondition(condition, payload, userData));
+        }
+        else {
+            return conditions.some((condition) => evaluateCondition(condition, payload, userData));
+        }
+    };
+    /**
+     * Apply actions to payload and providers
+     * @param actions - Array of actions to apply
+     * @param payload - The payload to modify
+     * @param providers - Optional separate providers object (if not in payload)
+     * @returns Updated payload, providers, skipEvent flag, and additional event names
+     */
+    const applyActions = (actions, payload, providers) => {
+        var _a;
+        const updatedPayload = structuredClone(payload);
+        if (!updatedPayload.data) {
+            updatedPayload.data = {};
+        }
+        const updatedProviders = ((_a = providers !== null && providers !== void 0 ? providers : updatedPayload.providers) !== null && _a !== void 0 ? _a : { all: true });
+        let skipEvent = false;
+        let skipBrowserEvent = false;
+        const additionalEvents = [];
+        for (const action of actions) {
+            switch (action.type) {
+                case 'skipEvent':
+                    skipEvent = true;
+                    break;
+                case 'skipBrowserEvent':
+                    skipBrowserEvent = true;
+                    break;
+                case 'skipProviders':
+                    if (action.providers && updatedProviders) {
+                        for (const provider of action.providers) {
+                            updatedProviders[provider] = false;
+                        }
+                    }
+                    break;
+                case 'updatePayloadField':
+                    if (action.fieldPath && action.fieldValue !== undefined) {
+                        const path = action.fieldPath.startsWith('data.')
+                            ? action.fieldPath
+                            : `data.${action.fieldPath}`;
+                        setNestedValue(updatedPayload.data, path.replace('data.', ''), action.fieldValue);
+                    }
+                    break;
+                case 'addPayloadField':
+                    if (action.fieldPath && action.fieldValue !== undefined) {
+                        const path = action.fieldPath.startsWith('data.')
+                            ? action.fieldPath
+                            : `data.${action.fieldPath}`;
+                        setNestedValue(updatedPayload.data, path.replace('data.', ''), action.fieldValue);
+                    }
+                    break;
+                case 'removePayloadField':
+                    if (action.fieldPath) {
+                        const path = action.fieldPath.startsWith('data.')
+                            ? action.fieldPath
+                            : `data.${action.fieldPath}`;
+                        removeNestedValue(updatedPayload.data, path.replace('data.', ''));
+                    }
+                    break;
+                case 'createAdditionalEvents':
+                    if (action.additionalEvents) {
+                        additionalEvents.push(...action.additionalEvents);
+                    }
+                    break;
+            }
+        }
+        if (updatedProviders !== undefined) {
+            updatedPayload.providers = updatedProviders;
+        }
+        return {
+            updatedPayload,
+            updatedProviders,
+            skipEvent,
+            skipBrowserEvent,
+            additionalEvents,
+        };
+    };
+    /**
+     * Evaluate all event rules and apply actions
+     * @param rules - Array of event rules to evaluate
+     * @param payload - The payload to evaluate and modify
+     * @param providers - Optional separate providers object (if not in payload)
+     * @param userData - Optional user data for user.* field access
+     * @returns Updated payload, providers, skipEvent flag, and additional event names
+     */
+    const evaluateEventRules = (rules, payload, providers, userData = {}) => {
+        var _a;
+        let updatedPayload = payload;
+        let updatedProviders = ((_a = providers !== null && providers !== void 0 ? providers : payload.providers) !== null && _a !== void 0 ? _a : { all: true });
+        let skipEvent = false;
+        let skipBrowserEvent = false;
+        const allAdditionalEvents = [];
+        try {
+            for (const rule of rules) {
+                const conditionMatches = evaluateConditions(rule.conditions || [], rule.logicalOperator || 'AND', updatedPayload, userData);
+                if (conditionMatches) {
+                    const actions = rule.actions || [];
+                    const result = applyActions(actions, updatedPayload, updatedProviders);
+                    updatedPayload = result.updatedPayload;
+                    updatedProviders = result.updatedProviders;
+                    allAdditionalEvents.push(...result.additionalEvents);
+                    if (result.skipEvent) {
+                        skipEvent = true;
+                    }
+                    if (result.skipBrowserEvent) {
+                        skipBrowserEvent = true;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error evaluating event rules:', error);
+        }
+        return {
+            updatedPayload,
+            updatedProviders,
+            skipEvent,
+            skipBrowserEvent,
+            additionalEvents: allAdditionalEvents,
+        };
+    };
+
     // eslint-disable-next-line @nx/enforce-module-boundaries
     const getGlobalSettings = () => {
         var _a;
@@ -965,7 +1265,7 @@
             referrer: getReferrer(destination),
             search: getSearch(destination),
             locale: getLocale(),
-            sdkVersion: "1.35.1" ,
+            sdkVersion: "1.36.0" ,
             ...(payload || {}),
         };
         let storage = {};
@@ -1139,13 +1439,14 @@
         processGetData(instances[0], keys, callback);
     };
 
-    const sendTag = (destination, { eventName, eventId, data, providerData, providers, options }) => {
+    const sendTag = (destination, { eventName, eventId, data, providerData, providers, options, configuratorProcessed, }) => {
         const payload = {
             eventName,
             eventId,
             timestamp: Date.now(),
             data,
             providerData,
+            configuratorProcessed,
         };
         if (providers) {
             payload.providers = providers;
@@ -1178,64 +1479,93 @@
         const consentCategory = getConsentCategories(destination);
         const consentSettings = getSetting(destination, 'consentSetting');
         const userConsent = { consentChannel, consentCategory, consentSettings };
+        const userProperties = getSetting(destination, 'userProperties');
         if (skipZeroPurchaseEvent && isZeroPurchaseEvent({ eventName, data })) {
             return;
         }
-        const conversion = preparePayloadWithConversion(JSON.parse(JSON.stringify(data)), getSetting(destination, 'currency'));
-        for (const pkg of providerPackages) {
-            if (!pkg || !pkg.name || !pkg.tag) {
-                continue;
+        const originalData = structuredClone(data);
+        const originalProviders = structuredClone(providers);
+        const rules = (getSetting(destination, 'configuratorSetting') ||
+            []);
+        const rulesResult = evaluateEventRules(rules, structuredClone({ eventName, data }), providers !== null && providers !== void 0 ? providers : undefined, userProperties || {});
+        if (!rulesResult.skipEvent) {
+            if (rulesResult.updatedPayload) {
+                // eslint-disable-next-line no-param-reassign
+                data = rulesResult.updatedPayload.data;
             }
-            if (!configuredTags.has(pkg.name)) {
-                logger.log(`Provider ${pkg.name} is not in allow list`);
-                continue;
+            if (rulesResult.updatedProviders) {
+                // eslint-disable-next-line no-param-reassign
+                providers = rulesResult.updatedProviders;
             }
-            const variables = getProviderVariables(destination, pkg.name);
-            const result = {};
-            const executionContext = new Map();
-            for (const variable of variables) {
-                if (!isProviderInstanceAllowed(providers, pkg.name, variable.tagName)) {
-                    logger.log(`Provider instance is not allowed (${pkg.name}: ${variable.tagName})`);
-                    continue;
-                }
-                if (!hasUserConsent(userConsent, pkg.name, variable.tagName)) {
-                    logger.log(`Consent is missing (${pkg.name}: ${variable.tagName})`);
-                    continue;
-                }
-                if (!doesGeoRequestMatchList(requestCountry, requestRegion, isEURequest, variable.geoRegions)) {
-                    logger.log('GEO request region does not match the filter, skiping');
-                    continue;
+            if (!rulesResult.skipBrowserEvent) {
+                const conversion = preparePayloadWithConversion(JSON.parse(JSON.stringify(data)), getSetting(destination, 'currency'));
+                for (const pkg of providerPackages) {
+                    if (!pkg || !pkg.name || !pkg.tag) {
+                        continue;
+                    }
+                    if (!configuredTags.has(pkg.name)) {
+                        logger.log(`Provider ${pkg.name} is not in allow list`);
+                        continue;
+                    }
+                    const variables = getProviderVariables(destination, pkg.name);
+                    const result = {};
+                    const executionContext = new Map();
+                    for (const variable of variables) {
+                        if (!isProviderInstanceAllowed(providers, pkg.name, variable.tagName)) {
+                            logger.log(`Provider instance is not allowed (${pkg.name}: ${variable.tagName})`);
+                            continue;
+                        }
+                        if (!hasUserConsent(userConsent, pkg.name, variable.tagName)) {
+                            logger.log(`Consent is missing (${pkg.name}: ${variable.tagName})`);
+                            continue;
+                        }
+                        if (!doesGeoRequestMatchList(requestCountry, requestRegion, isEURequest, variable.geoRegions)) {
+                            logger.log('GEO request region does not match the filter, skiping');
+                            continue;
+                        }
+                        const payload = ((_a = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _a === void 0 ? void 0 : _a.length) === 0 ||
+                            ((_b = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _b === void 0 ? void 0 : _b.includes(pkg.name))
+                            ? conversion.payload
+                            : data;
+                        result[variable.tagName] = pkg.tag({
+                            userId,
+                            sessionId,
+                            eventName,
+                            eventId,
+                            data: JSON.parse(JSON.stringify(payload)),
+                            sendTag: sendTag.bind(null, destination),
+                            getEdgeData: processGetData.bind(null, destination),
+                            manifestVariables: variable.variableSet,
+                            executionContext,
+                            destination,
+                        });
+                    }
+                    providerData[pkg.name] = result;
                 }
-                const payload = ((_a = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _a === void 0 ? void 0 : _a.length) === 0 ||
-                    ((_b = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _b === void 0 ? void 0 : _b.includes(pkg.name))
-                    ? conversion.payload
-                    : data;
-                result[variable.tagName] = pkg.tag({
-                    userId,
-                    sessionId,
-                    eventName,
-                    eventId,
-                    data: JSON.parse(JSON.stringify(payload)),
-                    sendTag: sendTag.bind(null, destination),
-                    getEdgeData: processGetData.bind(null, destination),
-                    manifestVariables: variable.variableSet,
-                    executionContext,
-                    destination,
-                });
             }
-            providerData[pkg.name] = result;
+            else {
+                logger.log('Browser events skipped by event rules, sending tag to server only');
+            }
+            if (!hasAllowedManifestTags(configuredTags, userConsent, providers)) {
+                return;
+            }
+            sendTag(destination, {
+                configuratorProcessed: true,
+                eventName,
+                eventId,
+                data,
+                providerData,
+                providers,
+                options,
+            });
         }
-        if (!hasAllowedManifestTags(configuredTags, userConsent, providers)) {
-            return;
+        else {
+            logger.log('Event skipped by event rules');
+        }
+        const additionalEvents = rulesResult.additionalEvents || [];
+        for (const additionalEventName of additionalEvents) {
+            handleTag(additionalEventName, structuredClone(originalData || {}), originalProviders, options);
         }
-        sendTag(destination, {
-            eventName,
-            eventId,
-            data,
-            providerData,
-            providers,
-            options,
-        });
     };
     const handleTag = (eventName, data = {}, providers, options) => {
         if (options === null || options === void 0 ? void 0 : options.destination) {
@@ -1767,6 +2097,8 @@
                 geoRegion: result.geoRegion,
                 isEURequest: result.isEURequest,
                 consentSetting: result.consentSetting,
+                configuratorSetting: result.configuratorSetting,
+                userProperties: result.userProperties,
             });
             if (result.storageId != null) {
                 savePerKey(preferences.edgeURL, 'local', tagStorage, result.storageId, storageIdKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotoutio/edgetag-sdk-browser",
-  "version": "1.35.1",
+  "version": "1.36.0",
   "description": "Browser SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",