@blotoutio/edgetag-sdk-browser 0.24.2 → 0.26.0

package/index.js

@@ -13,147 +13,6 @@
         get user () { return user; }
     });
 
-    const getMessage = (error) => {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        if (typeof error === 'string') {
-            return error;
-        }
-        try {
-            return JSON.stringify(error);
-        }
-        catch {
-            return error;
-        }
-    };
-    const log = (data) => {
-        console.log('[EdgeTag]', getMessage(data));
-    };
-    const error = (data) => {
-        console.error('[EdgeTag]', getMessage(data));
-    };
-
-    let endpointUrl = '';
-    const generateUrl = (path) => {
-        const endpoint = getUrl();
-        if (!endpoint) {
-            log('URL is not valid');
-            return '';
-        }
-        return `${endpoint}${path}`;
-    };
-    const getUrl = () => {
-        return endpointUrl;
-    };
-    const setUrl = (url) => {
-        if (url == null) {
-            return;
-        }
-        endpointUrl = url;
-    };
-    const getTagURL = () => {
-        return generateUrl('/tag');
-    };
-    const getInitURL = () => {
-        return generateUrl('/init');
-    };
-    const getConsentURL = () => {
-        return generateUrl('/consent');
-    };
-    const getUserURL = () => {
-        return generateUrl('/user');
-    };
-    const getDataURL = () => {
-        return generateUrl(`/data`);
-    };
-    const getGetDataURL = (keys) => {
-        return generateUrl(`/data?keys=${encodeURIComponent(keys.join(','))}`);
-    };
-    const getKeysURL = () => {
-        return generateUrl(`/keys`);
-    };
-
-    let allowedProvider = [];
-    let initialized = false;
-    let consentDisabled = false;
-    const providersPackages = {};
-    const setPreferences = (preferences) => {
-        var _a;
-        if (!preferences) {
-            return false;
-        }
-        if (!preferences.edgeURL) {
-            error('Please provide URL for EdgeTag');
-            return false;
-        }
-        consentDisabled = !!preferences.disableConsentCheck;
-        (_a = preferences.providers) === null || _a === void 0 ? void 0 : _a.forEach((provider) => {
-            if (!provider.name) {
-                return;
-            }
-            providersPackages[provider.name] = provider;
-        });
-        try {
-            if (window && Array.isArray(window.edgetagProviders)) {
-                window.edgetagProviders.forEach((provider) => {
-                    if (!provider.name) {
-                        return;
-                    }
-                    providersPackages[provider.name] = provider;
-                });
-            }
-        }
-        catch {
-            // do nothing
-        }
-        setUrl(preferences.edgeURL);
-        return true;
-    };
-    const isConsentDisabled = () => consentDisabled;
-    const getProvidersPackage = () => providersPackages;
-    const isInitialized = () => initialized;
-    const setInitialized = () => {
-        initialized = true;
-    };
-    const getAllowedProviders = () => allowedProvider;
-    const setAllowedProviders = (providers) => {
-        allowedProvider = providers;
-    };
-
-    const checkConsent = (providers) => {
-        if (isConsentDisabled()) {
-            return true;
-        }
-        const consent = getConsent();
-        if (!consent) {
-            return false;
-        }
-        const consentLength = Object.keys(consent).length;
-        if (!consentLength || (consentLength === 1 && consent['all'] === false)) {
-            return false;
-        }
-        const providersLength = Object.keys(providers || {}).length;
-        if (!providers ||
-            providersLength === 0 ||
-            (providersLength === 1 && providers['all'])) {
-            return (Object.values(consent).find((isAllowed) => isAllowed) || false);
-        }
-        for (const [key, value] of Object.entries(providers)) {
-            if (value === false || consent[key] === false) {
-                continue;
-            }
-            // we have consent
-            if (consent[key] ||
-                (consent['all'] === true && consent[key] === undefined)) {
-                // we have provider
-                if (value || (providers['all'] && providers[key] === undefined)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
     const getUserAgent = () => {
         try {
             const nav = navigator;
@@ -211,81 +70,33 @@
             return '';
         }
     };
-    const isProviderIncluded = (providers, providerValue) => {
-        return (providerValue || (providers['all'] === true && providerValue === undefined));
-    };
-    const allowTag = (providers) => {
-        if (!checkConsent(providers)) {
-            return false;
-        }
-        const providersLength = Object.values(providers || {}).length;
-        if (!providers || providersLength === 0) {
-            return true;
-        }
-        const allProviders = getAllowedProviders();
-        const allProvidersLength = Object.keys(allProviders || {}).length;
-        if (allProvidersLength === 0) {
-            return true;
+
+    const tagStorage = 'edgeTag';
+    const consentKey = 'consent';
+    const keyPrefix = `_worker`;
+    const cookieKey = 'tag_user_id';
+
+    const getMessage = (error) => {
+        if (error instanceof Error) {
+            return error.message;
         }
-        for (const provider of allProviders) {
-            if (isProviderIncluded(providers, providers[provider])) {
-                return true;
-            }
+        if (typeof error === 'string') {
+            return error;
         }
-        return false;
-    };
-    const allowProviders = (providers) => {
-        if (!providers || Object.keys(providers).length === 0 || providers['all']) {
-            return true;
+        try {
+            return JSON.stringify(error);
         }
-        const allowedProvider = getAllowedProviders();
-        if (allowedProvider && allowedProvider.length > 0) {
-            let found = false;
-            Object.entries(providers).forEach(([key, value]) => {
-                if (!value) {
-                    return;
-                }
-                if (allowedProvider.includes(key)) {
-                    found = true;
-                }
-            });
-            return found;
+        catch {
+            return error;
         }
-        return true;
     };
-    const allowProvider = (providerId) => {
-        if (!providerId) {
-            return true;
-        }
-        const allowedProvider = getAllowedProviders();
-        if (allowedProvider && allowedProvider.length > 0) {
-            return allowedProvider.includes(providerId);
-        }
-        return true;
-    };
-    const allowProviderWithConsent = (providers, providerId) => {
-        if (!allowProvider(providerId)) {
-            return false;
-        }
-        if (!checkConsent(providers)) {
-            return false;
-        }
-        if (providers && Object.keys(providers).length) {
-            if (!isProviderIncluded(providers, providers[providerId])) {
-                return false;
-            }
-        }
-        return true;
+    const log = (data) => {
+        console.log('[EdgeTag]', getMessage(data));
     };
-    const checkProviderConsent = (providerId) => {
-        return checkConsent({ [providerId]: true });
+    const error = (data) => {
+        console.error('[EdgeTag]', getMessage(data));
     };
 
-    const tagStorage = 'edgeTag';
-    const consentKey = 'consent';
-    const keyPrefix = `_worker`;
-    const cookieKey = 'tag_user_id';
-
     const initKey = `${keyPrefix}Store`;
     const saveDataPerKey = (persistType, provider, value, key) => {
         const storage = getData$1(persistType);
@@ -513,7 +324,7 @@
             referrer: getReferrer(),
             search: getSearch(),
             locale: getLocale(),
-            sdkVersion: "0.24.2" ,
+            sdkVersion: "0.26.0" ,
             ...(payload || {}),
         };
         let storage = {};
@@ -556,6 +367,46 @@
         return await ajax('GET', url);
     }
 
+    let endpointUrl = '';
+    const generateUrl = (path) => {
+        const endpoint = getUrl();
+        if (!endpoint) {
+            log('URL is not valid');
+            return '';
+        }
+        return `${endpoint}${path}`;
+    };
+    const getUrl = () => {
+        return endpointUrl;
+    };
+    const setUrl = (url) => {
+        if (url == null) {
+            return;
+        }
+        endpointUrl = url;
+    };
+    const getTagURL = () => {
+        return generateUrl('/tag');
+    };
+    const getInitURL = () => {
+        return generateUrl('/init');
+    };
+    const getConsentURL = () => {
+        return generateUrl('/consent');
+    };
+    const getUserURL = () => {
+        return generateUrl('/user');
+    };
+    const getDataURL = () => {
+        return generateUrl(`/data`);
+    };
+    const getGetDataURL = (keys) => {
+        return generateUrl(`/data?keys=${encodeURIComponent(keys.join(','))}`);
+    };
+    const getKeysURL = () => {
+        return generateUrl(`/keys`);
+    };
+
     let memoryConsent;
     const saveConsent = (consent) => {
         setConsent(consent);
@@ -581,6 +432,53 @@
         return memoryConsent;
     };
 
+    const allowedProvider = new Set();
+    let initialized = false;
+    const providersPackages = {};
+    const setPreferences = (preferences) => {
+        var _a;
+        if (!preferences) {
+            return false;
+        }
+        if (!preferences.edgeURL) {
+            error('Please provide URL for EdgeTag');
+            return false;
+        }
+        !!preferences.disableConsentCheck;
+        (_a = preferences.providers) === null || _a === void 0 ? void 0 : _a.forEach((provider) => {
+            if (!provider.name) {
+                return;
+            }
+            providersPackages[provider.name] = provider;
+        });
+        try {
+            if (window && Array.isArray(window.edgetagProviders)) {
+                window.edgetagProviders.forEach((provider) => {
+                    if (!provider.name) {
+                        return;
+                    }
+                    providersPackages[provider.name] = provider;
+                });
+            }
+        }
+        catch {
+            // do nothing
+        }
+        setUrl(preferences.edgeURL);
+        return true;
+    };
+    const getProvidersPackage = () => providersPackages;
+    const isInitialized = () => initialized;
+    const setInitialized = () => {
+        initialized = true;
+    };
+    const getAllowedProviders = () => allowedProvider;
+    const setAllowedProviders = (providers) => {
+        for (const provider of providers) {
+            allowedProvider.add(provider);
+        }
+    };
+
     const manifestVariables = {};
     const addProviderVariable = (name, variables, tagName) => {
         manifestVariables[name] = {
@@ -614,11 +512,60 @@
         }
     };
 
-    const sendTag = ({ eventName, eventId, data, providerData, providers, options, }) => {
-        if (!allowProviders(providers)) {
-            log('Provider is not allowed.');
-            return;
+    const isBool = (v) => typeof v == 'boolean';
+    const isRecord = (v) => !!v && typeof v == 'object';
+    /**
+     * This function validates user consent for a given provider and tag name.
+     * It should be used in conjunction with `UserConsent`, not `ProvidersConfig`.
+     */
+    const hasUserConsent = (consent, provider, tagName) => {
+        if (!isRecord(consent)) {
+            return false;
+        }
+        let allowed = isBool(consent.all) ? consent.all : false;
+        if (provider in consent) {
+            const providerSpecific = consent[provider];
+            if (isBool(providerSpecific)) {
+                allowed = providerSpecific;
+            }
+            else if (isRecord(providerSpecific)) {
+                if ('all' in providerSpecific && isBool(providerSpecific.all)) {
+                    allowed = providerSpecific.all;
+                }
+                if (tagName in providerSpecific && isBool(providerSpecific[tagName])) {
+                    allowed = providerSpecific[tagName];
+                }
+            }
+        }
+        return allowed;
+    };
+    /**
+     * This function validates provider allowance for a given provider and tag name.
+     * It should not be used to validate `UserConsent`.
+     */
+    const isProviderInstanceAllowed = (providersConfig, provider, tagName) => {
+        if (!isRecord(providersConfig)) {
+            return true;
         }
+        let allowed = isBool(providersConfig.all) ? providersConfig.all : true;
+        if (provider in providersConfig) {
+            const providerSpecific = providersConfig[provider];
+            if (isBool(providerSpecific)) {
+                allowed = providerSpecific;
+            }
+            else if (isRecord(providerSpecific)) {
+                if ('all' in providerSpecific && isBool(providerSpecific.all)) {
+                    allowed = providerSpecific.all;
+                }
+                if (tagName in providerSpecific && isBool(providerSpecific[tagName])) {
+                    allowed = providerSpecific[tagName];
+                }
+            }
+        }
+        return allowed;
+    };
+
+    const sendTag = ({ eventName, eventId, data, providerData, providers, options, }) => {
         const payload = {
             eventName,
             eventId,
@@ -639,14 +586,6 @@
             });
             return;
         }
-        if (!allowProviders(providers)) {
-            log('Provider is not allowed.');
-            return;
-        }
-        if (!allowTag(providers)) {
-            log('Consent is missing.');
-            return;
-        }
         let eventId = data['eventId'];
         if (!eventId) {
             eventId = generateEventId(eventName);
@@ -654,18 +593,32 @@
         const providerPackages = getProvidersPackage();
         const userId = handleGetUserId();
         const providerData = {};
+        const consent = getConsent();
+        const allowedProviders = getAllowedProviders();
+        let anyProviderCalled = false;
         if (providerPackages) {
-            Object.values(providerPackages).forEach((pkg) => {
-                if (!pkg ||
-                    !pkg.name ||
-                    !pkg.tag ||
-                    !checkProviderConsent(pkg.name) ||
-                    !allowProviderWithConsent(providers, pkg.name)) {
-                    return;
+            for (const pkg of Object.values(providerPackages)) {
+                if (!pkg || !pkg.name || !pkg.tag) {
+                    continue;
+                }
+                if (!allowedProviders.has(pkg.name)) {
+                    log(`Provider ${pkg.name} is not in allow list`);
+                    continue;
                 }
                 const variables = getProviderVariables(pkg.name);
                 const result = {};
-                for (const [tagName, variableSet] of Object.entries(variables)) {
+                const providerVariables = Object.entries(variables);
+                const executionContext = new Map();
+                for (const [tagName, variableSet] of providerVariables) {
+                    if (!isProviderInstanceAllowed(providers, pkg.name, tagName)) {
+                        log(`Provider instance is not allowed (${pkg.name}: ${tagName})`);
+                        continue;
+                    }
+                    if (!hasUserConsent(consent, pkg.name, tagName)) {
+                        log(`Consent is missing (${pkg.name}: ${tagName})`);
+                        continue;
+                    }
+                    anyProviderCalled = true;
                     result[tagName] = pkg.tag({
                         userId,
                         eventName,
@@ -673,10 +626,14 @@
                         data: JSON.parse(JSON.stringify(data)),
                         sendTag,
                         manifestVariables: variableSet,
+                        executionContext,
                     });
                 }
                 providerData[pkg.name] = result;
-            });
+            }
+        }
+        if (!anyProviderCalled) {
+            return;
         }
         sendTag({
             eventName,
@@ -696,23 +653,34 @@
         saveKV(data);
         const providerPackages = getProvidersPackage();
         const userId = handleGetUserId();
+        const consent = getConsent();
+        const allowedProviders = getAllowedProviders();
         if (providerPackages) {
-            Object.values(providerPackages).forEach((pkg) => {
-                if (!pkg ||
-                    !pkg.user ||
-                    !pkg.name ||
-                    !allowProviderWithConsent(providers, pkg.name)) {
-                    return;
+            for (const pkg of Object.values(providerPackages)) {
+                if (!pkg || !pkg.user || !pkg.name) {
+                    continue;
+                }
+                if (!allowedProviders.has(pkg.name)) {
+                    log(`Provider ${pkg.name} is not in allow list`);
+                    continue;
                 }
                 const variables = getProviderVariables(pkg.name);
-                for (const variableSet of Object.values(variables)) {
+                for (const [tagName, variableSet] of Object.entries(variables)) {
+                    if (!isProviderInstanceAllowed(providers, pkg.name, tagName)) {
+                        log(`Data not allowed for ${pkg.name} (${tagName})`);
+                        continue;
+                    }
+                    if (!hasUserConsent(consent, pkg.name, tagName)) {
+                        log(`Consent is missing for ${pkg.name} (${tagName})`);
+                        continue;
+                    }
                     pkg.user({
                         userId,
                         data,
                         manifestVariables: variableSet,
                     });
                 }
-            });
+            }
         }
         postRequest(getDataURL(), { data, providers }, options).catch(error);
     };
@@ -829,16 +797,15 @@
             }
             if (providerPackages) {
                 const pkg = providerPackages[provider.package];
-                if (pkg && pkg.name && pkg.init && allowProvider(pkg.name)) {
-                    const initData = {
+                if (pkg && pkg.name && pkg.init) {
+                    pkg.init({
                         userId,
                         manifest: provider,
                         sendTag,
                         sendEdgeData: handleData,
                         getEdgeData: handleGetData,
                         keyName: `${keyPrefix}Store`,
-                    };
-                    pkg.init(initData);
+                    });
                 }
             }
         });
@@ -889,25 +856,37 @@
         saveKV({
             [key]: value,
         });
+        const consent = getConsent();
+        const allowedProviders = getAllowedProviders();
         const providerPackages = getProvidersPackage();
         const userId = handleGetUserId();
         if (providerPackages) {
-            Object.values(providerPackages).forEach((pkg) => {
-                if (!pkg ||
-                    !pkg.name ||
-                    !pkg.user ||
-                    !allowProviderWithConsent(providers, pkg.name)) {
-                    return;
+            for (const pkg of Object.values(providerPackages)) {
+                if (!pkg || !pkg.name || !pkg.user) {
+                    continue;
+                }
+                if (!allowedProviders.has(pkg.name)) {
+                    log(`Provider ${pkg.name} is not in allow list`);
+                    continue;
                 }
                 const variables = getProviderVariables(pkg.name);
-                for (const variableSet of Object.values(variables)) {
+                for (const [tagName, variableSet] of Object.entries(variables)) {
+                    if (!isProviderInstanceAllowed(providers, pkg.name, tagName)) {
+                        // should we be logging this?
+                        log(`User not allowed for ${pkg.name} (${tagName})`);
+                        continue;
+                    }
+                    if (!hasUserConsent(consent, pkg.name, tagName)) {
+                        log(`User doesn't have consent for ${pkg.name} (${tagName})`);
+                        continue;
+                    }
                     pkg.user({
                         userId,
                         data: { [key]: value },
                         manifestVariables: variableSet,
                     });
                 }
-            });
+            }
         }
         postRequest(getUserURL(), {
             key,
@@ -930,14 +909,14 @@
     const tag = (name, data, providers, options) => {
         handleTag(name, data, providers, options);
     };
-    const consent = (consent, options) => {
-        handleConsent(consent, options);
+    const consent = (value, options) => {
+        handleConsent(value, options);
     };
     const user = (key, value, providers, options) => {
         handleUser(key, value, providers, options);
     };
-    const data = (data, providers, options) => {
-        handleData(data, providers, options);
+    const data = (value, providers, options) => {
+        handleData(value, providers, options);
     };
     const getData = (keys, callback) => {
         handleGetData(keys, callback);

package/package.json

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