react-native-event-logger/dist/utils/eventValidation.js

A React Native event tracking library with debug capabilities

// Regular expression for alphanumeric and underscore validation
const alphanumericUnderscoreRegex = /^[a-zA-Z0-9_]+$/;
const MAX_PARAM_LENGTH = 100;
const MAX_PARAM_COUNT = 100;
const MAX_PARAM_NAME_LENGTH = 40;
const reservedEventName = [
    'ad_activeview',
    'ad_click',
    'ad_exposure',
    'ad_query',
    'ad_reward',
    'adunit_exposure',
    'app_background',
    'app_clear_data',
    'app_exception',
    'app_remove',
    'app_store_refund',
    'app_store_subscription_cancel',
    'app_store_subscription_convert',
    'app_store_subscription_renew',
    'app_update',
    'app_upgrade',
    'dynamic_link_app_open',
    'dynamic_link_app_update',
    'dynamic_link_first_open',
    'error',
    'transient',
    'volatile',
    'synchronized',
    'first_open',
    'first_visit',
    'in_app_purchase',
    'notification_dismiss',
    'notification_foreground',
    'notification_open',
    'notification_receive',
    'os_update',
    'session_start',
    'session_start_with_rollout',
    'user_engagement',
];
const restrictedPrefixes = ['firebase_', 'google_', 'ga_', 'AD_'];
const validateStringLength = (value, minLength, maxLength) => value.length >= minLength && value.length <= maxLength;
const isAlphanumericUnderscore = (value) => alphanumericUnderscoreRegex.test(value);
const isValidParamKey = (key) => !(!key ||
    !validateStringLength(key, 1, MAX_PARAM_NAME_LENGTH) ||
    !isAlphanumericUnderscore(key) ||
    restrictedPrefixes.some(prefix => key.startsWith(prefix)));
const isValidParamValue = (value) => {
    if (typeof value === 'string') {
        return validateStringLength(value, 0, MAX_PARAM_LENGTH);
    }
    else if (typeof value === 'boolean' || typeof value === 'number' || value === null) {
        return true;
    }
    else {
        return false;
    }
};
const validateParamObject = (name, params) => {
    if (!params || typeof params !== 'object' || Array.isArray(params)) {
        return {
            validName: name,
            validParams: params,
            errorMsg: 'Parameter must be a valid object',
        };
    }
    const keys = Object.keys(params);
    if (keys.length > MAX_PARAM_COUNT) {
        return {
            validName: name,
            validParams: params,
            errorMsg: 'Parameter keys should not exceed 100',
        };
    }
    for (const key of keys) {
        if (!isValidParamKey(key)) {
            return {
                validName: name,
                validParams: params,
                errorMsg: `Invalid key or value for key '${key} ${params[key]}'`,
            };
        }
        if (!isValidParamValue(params[key])) {
            return {
                validName: name,
                validParams: params,
                errorMsg: `Invalid value for key '${key} ${params[key]}'`,
            };
        }
    }
    return {
        validName: name,
        validParams: params,
        errorMsg: '',
    };
};
const validateEventName = (value, params) => {
    if (!value || typeof value !== 'string') {
        return {
            validName: value,
            validParams: params,
            errorMsg: 'Event name is invalid or empty',
        };
    }
    if (!validateStringLength(value, 1, MAX_PARAM_NAME_LENGTH)) {
        return {
            validName: value,
            validParams: params,
            errorMsg: 'Event name length should be between 1 and 40 characters',
        };
    }
    if (!isAlphanumericUnderscore(value)) {
        return {
            validName: value,
            validParams: params,
            errorMsg: 'Event name should only contain alphanumeric characters and underscores, and must start with an alphanumeric character',
        };
    }
    if (reservedEventName.includes(value) ||
        restrictedPrefixes.some(prefix => value.startsWith(prefix))) {
        return {
            validName: value,
            validParams: params,
            errorMsg: 'Event name is reserved or starts with a restricted prefix',
        };
    }
    return validateParamObject(value, params);
};
export const validateFirebaseEvent = (name, params) => {
    return validateEventName(name, params);
};
//# sourceMappingURL=eventValidation.js.map