@tracelog/lib 0.5.4 → 0.6.0

package/dist/cjs/utils/security/sanitize.utils.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeMetadata = exports.sanitizeApiConfig = exports.sanitizePathString = exports.sanitizeString = void 0;
+exports.sanitizeMetadata = exports.sanitizeString = void 0;
 const constants_1 = require("../../constants");
-const logging_1 = require("../logging");
+const logging_utils_1 = require("../logging.utils");
 /**
  * Sanitizes a string value to prevent XSS attacks
  * @param value - The string to sanitize
@@ -10,19 +10,13 @@ const logging_1 = require("../logging");
  */
 const sanitizeString = (value) => {
     if (!value || typeof value !== 'string' || value.trim().length === 0) {
-        logging_1.debugLog.debug('Sanitize', 'String sanitization skipped - empty or invalid input', { value, type: typeof value });
         return '';
     }
-    const originalLength = value.length;
     let sanitized = value;
     // Limit string length
     if (value.length > constants_1.MAX_STRING_LENGTH) {
         sanitized = value.slice(0, Math.max(0, constants_1.MAX_STRING_LENGTH));
-        logging_1.debugLog.warn('Sanitize', 'String truncated due to length limit', {
-            originalLength,
-            maxLength: constants_1.MAX_STRING_LENGTH,
-            truncatedLength: sanitized.length,
-        });
+        // Silent truncation - this is expected behavior for long strings
     }
     // Remove potential XSS patterns
     let xssPatternMatches = 0;
@@ -34,9 +28,11 @@ const sanitizeString = (value) => {
         }
     }
     if (xssPatternMatches > 0) {
-        logging_1.debugLog.warn('Sanitize', 'XSS patterns detected and removed', {
-            patternMatches: xssPatternMatches,
-            originalValue: value.slice(0, 100), // Log first 100 chars for debugging
+        (0, logging_utils_1.log)('warn', 'XSS patterns detected and removed', {
+            data: {
+                patternMatches: xssPatternMatches,
+                originalValue: value.slice(0, 100),
+            },
         });
     }
     // Basic HTML entity encoding for critical characters
@@ -48,42 +44,9 @@ const sanitizeString = (value) => {
         .replaceAll("'", ''')
         .replaceAll('/', '/');
     const result = sanitized.trim();
-    if (originalLength > 50 || xssPatternMatches > 0) {
-        logging_1.debugLog.debug('Sanitize', 'String sanitization completed', {
-            originalLength,
-            sanitizedLength: result.length,
-            xssPatternMatches,
-            wasTruncated: originalLength > constants_1.MAX_STRING_LENGTH,
-        });
-    }
     return result;
 };
 exports.sanitizeString = sanitizeString;
-/**
- * Sanitizes a path string for route exclusion checks
- * @param value - The path string to sanitize
- * @returns The sanitized path string
- */
-const sanitizePathString = (value) => {
-    if (typeof value !== 'string') {
-        return '';
-    }
-    if (value.length > constants_1.MAX_STRING_LENGTH) {
-        value = value.slice(0, Math.max(0, constants_1.MAX_STRING_LENGTH));
-    }
-    let sanitized = value;
-    for (const pattern of constants_1.XSS_PATTERNS) {
-        sanitized = sanitized.replace(pattern, '');
-    }
-    sanitized = sanitized
-        .replaceAll('&', '&')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;')
-        .replaceAll("'", '&#x27;');
-    return sanitized.trim();
-};
-exports.sanitizePathString = sanitizePathString;
 /**
  * Sanitizes any value recursively with depth protection
  * @param value - The value to sanitize
@@ -93,10 +56,7 @@ exports.sanitizePathString = sanitizePathString;
 const sanitizeValue = (value, depth = 0) => {
     // Prevent infinite recursion
     if (depth > constants_1.MAX_OBJECT_DEPTH) {
-        logging_1.debugLog.warn('Sanitize', 'Maximum object depth exceeded during sanitization', {
-            depth,
-            maxDepth: constants_1.MAX_OBJECT_DEPTH,
-        });
+        // Silent depth limit - prevents stack overflow
         return null;
     }
     if (value === null || value === undefined) {
@@ -107,7 +67,7 @@ const sanitizeValue = (value, depth = 0) => {
     }
     if (typeof value === 'number') {
         if (!Number.isFinite(value) || value < -Number.MAX_SAFE_INTEGER || value > Number.MAX_SAFE_INTEGER) {
-            logging_1.debugLog.warn('Sanitize', 'Invalid number sanitized to 0', { value, isFinite: Number.isFinite(value) });
+            // Silent normalization - invalid numbers become 0
             return 0;
         }
         return value;
@@ -116,34 +76,17 @@ const sanitizeValue = (value, depth = 0) => {
         return value;
     }
     if (Array.isArray(value)) {
-        const originalLength = value.length;
         const limitedArray = value.slice(0, constants_1.MAX_ARRAY_LENGTH);
-        if (originalLength > constants_1.MAX_ARRAY_LENGTH) {
-            logging_1.debugLog.warn('Sanitize', 'Array truncated due to length limit', {
-                originalLength,
-                maxLength: constants_1.MAX_ARRAY_LENGTH,
-                depth,
-            });
-        }
+        // Silent array length limit
         const sanitizedArray = limitedArray.map((item) => sanitizeValue(item, depth + 1)).filter((item) => item !== null);
-        if (originalLength > 0 && sanitizedArray.length === 0) {
-            logging_1.debugLog.warn('Sanitize', 'All array items were filtered out during sanitization', { originalLength, depth });
-        }
+        // Silent filter - empty arrays are valid results
         return sanitizedArray;
     }
     if (typeof value === 'object') {
         const sanitizedObject = {};
         const entries = Object.entries(value);
-        const originalKeysCount = entries.length;
         const limitedEntries = entries.slice(0, 20);
-        if (originalKeysCount > 20) {
-            logging_1.debugLog.warn('Sanitize', 'Object keys truncated due to limit', {
-                originalKeys: originalKeysCount,
-                maxKeys: 20,
-                depth,
-            });
-        }
-        let filteredKeysCount = 0;
+        // Silent object keys limit
         for (const [key, value_] of limitedEntries) {
             const sanitizedKey = (0, exports.sanitizeString)(key);
             if (sanitizedKey) {
@@ -151,135 +94,29 @@ const sanitizeValue = (value, depth = 0) => {
                 if (sanitizedValue !== null) {
                     sanitizedObject[sanitizedKey] = sanitizedValue;
                 }
-                else {
-                    filteredKeysCount++;
-                }
-            }
-            else {
-                filteredKeysCount++;
             }
         }
-        if (filteredKeysCount > 0) {
-            logging_1.debugLog.debug('Sanitize', 'Object properties filtered during sanitization', {
-                filteredKeysCount,
-                remainingKeys: Object.keys(sanitizedObject).length,
-                depth,
-            });
-        }
         return sanitizedObject;
     }
-    logging_1.debugLog.debug('Sanitize', 'Unknown value type sanitized to null', { type: typeof value, depth });
     return null;
 };
-/**
- * Sanitizes API configuration data with strict validation
- * @param data - The API config data to sanitize
- * @returns The sanitized API config
- */
-const sanitizeApiConfig = (data) => {
-    logging_1.debugLog.debug('Sanitize', 'Starting API config sanitization');
-    const safeData = {};
-    if (typeof data !== 'object' || data === null) {
-        logging_1.debugLog.warn('Sanitize', 'API config data is not an object', { data, type: typeof data });
-        return safeData;
-    }
-    try {
-        const originalKeys = Object.keys(data);
-        let processedKeys = 0;
-        let filteredKeys = 0;
-        for (const key of originalKeys) {
-            if (constants_1.ALLOWED_API_CONFIG_KEYS.has(key)) {
-                const value = data[key];
-                if (key === 'excludedUrlPaths') {
-                    const paths = Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];
-                    const originalPathsCount = paths.length;
-                    safeData.excludedUrlPaths = paths.map((path) => (0, exports.sanitizePathString)(String(path))).filter(Boolean);
-                    const filteredPathsCount = originalPathsCount - safeData.excludedUrlPaths.length;
-                    if (filteredPathsCount > 0) {
-                        logging_1.debugLog.warn('Sanitize', 'Some excluded URL paths were filtered during sanitization', {
-                            originalCount: originalPathsCount,
-                            filteredCount: filteredPathsCount,
-                        });
-                    }
-                }
-                else if (key === 'tags') {
-                    if (Array.isArray(value)) {
-                        safeData.tags = value;
-                        logging_1.debugLog.debug('Sanitize', 'Tags processed', { count: value.length });
-                    }
-                    else {
-                        logging_1.debugLog.warn('Sanitize', 'Tags value is not an array', { value, type: typeof value });
-                    }
-                }
-                else if (key === 'samplingRate') {
-                    const sanitizedValue = sanitizeValue(value);
-                    if (typeof sanitizedValue === 'number') {
-                        safeData.samplingRate = sanitizedValue;
-                    }
-                }
-                else {
-                    const sanitizedValue = sanitizeValue(value);
-                    if (sanitizedValue !== null) {
-                        safeData[key] = sanitizedValue;
-                    }
-                    else {
-                        logging_1.debugLog.warn('Sanitize', 'API config value sanitized to null', { key, originalValue: value });
-                    }
-                }
-                processedKeys++;
-            }
-            else {
-                filteredKeys++;
-                logging_1.debugLog.debug('Sanitize', 'API config key not allowed', { key });
-            }
-        }
-        logging_1.debugLog.info('Sanitize', 'API config sanitization completed', {
-            originalKeys: originalKeys.length,
-            processedKeys,
-            filteredKeys,
-            finalKeys: Object.keys(safeData).length,
-        });
-    }
-    catch (error) {
-        logging_1.debugLog.error('Sanitize', 'API config sanitization failed', {
-            error: error instanceof Error ? error.message : error,
-        });
-        throw new Error(`API config sanitization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-    return safeData;
-};
-exports.sanitizeApiConfig = sanitizeApiConfig;
 /**
  * Sanitizes user metadata for custom events
  * @param metadata - The metadata to sanitize
  * @returns The sanitized metadata
  */
 const sanitizeMetadata = (metadata) => {
-    logging_1.debugLog.debug('Sanitize', 'Starting metadata sanitization', { hasMetadata: metadata != null });
     if (typeof metadata !== 'object' || metadata === null) {
-        logging_1.debugLog.debug('Sanitize', 'Metadata is not an object, returning empty object', {
-            metadata,
-            type: typeof metadata,
-        });
         return {};
     }
     try {
-        const originalKeys = Object.keys(metadata).length;
         const sanitized = sanitizeValue(metadata);
         const result = typeof sanitized === 'object' && sanitized !== null ? sanitized : {};
-        const finalKeys = Object.keys(result).length;
-        logging_1.debugLog.debug('Sanitize', 'Metadata sanitization completed', {
-            originalKeys,
-            finalKeys,
-            keysFiltered: originalKeys - finalKeys,
-        });
         return result;
     }
     catch (error) {
-        logging_1.debugLog.error('Sanitize', 'Metadata sanitization failed', {
-            error: error instanceof Error ? error.message : error,
-        });
-        throw new Error(`Metadata sanitization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`[TraceLog] Metadata sanitization failed: ${errorMessage}`);
     }
 };
 exports.sanitizeMetadata = sanitizeMetadata;

package/dist/cjs/utils/validations/config-validations.utils.d.ts

@@ -1,4 +1,4 @@
-import { AppConfig, ApiConfig } from '../../types';
+import { Config } from '../../types';
 /**
  * Validates the app configuration object (before normalization)
  * This validates the structure and basic types but allows for normalization afterward
@@ -6,7 +6,7 @@ import { AppConfig, ApiConfig } from '../../types';
  * @throws {ProjectIdValidationError} If project ID validation fails
  * @throws {AppConfigValidationError} If other configuration validation fails
  */
-export declare const validateAppConfig: (config: AppConfig) => void;
+export declare const validateAppConfig: (config: Config) => void;
 /**
  * Validates and normalizes the app configuration
  * This is the primary validation entry point that ensures consistent behavior
@@ -15,10 +15,4 @@ export declare const validateAppConfig: (config: AppConfig) => void;
  * @throws {ProjectIdValidationError} If project ID validation fails after normalization
  * @throws {AppConfigValidationError} If other configuration validation fails
  */
-export declare const validateAndNormalizeConfig: (config: AppConfig) => AppConfig;
-/**
- * Type guard to check if a JSON response is a valid API config
- * @param json - The JSON to validate
- * @returns True if the JSON is a valid API config
- */
-export declare const isValidConfigApiResponse: (json: unknown) => json is ApiConfig;
+export declare const validateAndNormalizeConfig: (config: Config) => Config;

package/dist/cjs/utils/validations/config-validations.utils.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidConfigApiResponse = exports.validateAndNormalizeConfig = exports.validateAppConfig = void 0;
+exports.validateAndNormalizeConfig = exports.validateAppConfig = void 0;
 const constants_1 = require("../../constants");
-const types_1 = require("../../types");
 const validation_error_types_1 = require("../../types/validation-error.types");
-const logging_1 = require("../logging");
+const logging_utils_1 = require("../logging.utils");
 /**
  * Validates the app configuration object (before normalization)
  * This validates the structure and basic types but allows for normalization afterward
@@ -13,42 +12,18 @@ const logging_1 = require("../logging");
  * @throws {AppConfigValidationError} If other configuration validation fails
  */
 const validateAppConfig = (config) => {
-    // Validate config exists and has id property
     if (!config || typeof config !== 'object') {
-        logging_1.debugLog.clientError('ConfigValidation', 'Configuration must be an object', { config });
         throw new validation_error_types_1.AppConfigValidationError('Configuration must be an object', 'config');
     }
-    // Check if id property exists (allow falsy values to be handled by normalization)
-    if (!('id' in config)) {
-        logging_1.debugLog.clientError('ConfigValidation', 'Project ID is missing from configuration');
-        throw new validation_error_types_1.ProjectIdValidationError(constants_1.VALIDATION_MESSAGES.MISSING_PROJECT_ID, 'config');
-    }
-    // Check basic type - null, undefined, or non-string values should fail here
-    if (config.id === null || config.id === undefined || typeof config.id !== 'string') {
-        logging_1.debugLog.clientError('ConfigValidation', 'Project ID must be a non-empty string', {
-            providedId: config.id,
-            type: typeof config.id,
-        });
-        throw new validation_error_types_1.ProjectIdValidationError(constants_1.VALIDATION_MESSAGES.MISSING_PROJECT_ID, 'config');
-    }
     if (config.sessionTimeout !== undefined) {
         if (typeof config.sessionTimeout !== 'number' ||
             config.sessionTimeout < constants_1.MIN_SESSION_TIMEOUT_MS ||
             config.sessionTimeout > constants_1.MAX_SESSION_TIMEOUT_MS) {
-            logging_1.debugLog.clientError('ConfigValidation', 'Invalid session timeout', {
-                provided: config.sessionTimeout,
-                min: constants_1.MIN_SESSION_TIMEOUT_MS,
-                max: constants_1.MAX_SESSION_TIMEOUT_MS,
-            });
             throw new validation_error_types_1.SessionTimeoutValidationError(constants_1.VALIDATION_MESSAGES.INVALID_SESSION_TIMEOUT, 'config');
         }
     }
     if (config.globalMetadata !== undefined) {
         if (typeof config.globalMetadata !== 'object' || config.globalMetadata === null) {
-            logging_1.debugLog.clientError('ConfigValidation', 'Global metadata must be an object', {
-                provided: config.globalMetadata,
-                type: typeof config.globalMetadata,
-            });
             throw new validation_error_types_1.AppConfigValidationError(constants_1.VALIDATION_MESSAGES.INVALID_GLOBAL_METADATA, 'config');
         }
     }
@@ -60,31 +35,29 @@ const validateAppConfig = (config) => {
     }
     if (config.sensitiveQueryParams !== undefined) {
         if (!Array.isArray(config.sensitiveQueryParams)) {
-            logging_1.debugLog.clientError('ConfigValidation', 'Sensitive query params must be an array', {
-                provided: config.sensitiveQueryParams,
-                type: typeof config.sensitiveQueryParams,
-            });
             throw new validation_error_types_1.AppConfigValidationError(constants_1.VALIDATION_MESSAGES.INVALID_SENSITIVE_QUERY_PARAMS, 'config');
         }
         for (const param of config.sensitiveQueryParams) {
             if (typeof param !== 'string') {
-                logging_1.debugLog.clientError('ConfigValidation', 'All sensitive query params must be strings', {
-                    param,
-                    type: typeof param,
-                });
                 throw new validation_error_types_1.AppConfigValidationError('All sensitive query params must be strings', 'config');
             }
         }
     }
     if (config.errorSampling !== undefined) {
         if (typeof config.errorSampling !== 'number' || config.errorSampling < 0 || config.errorSampling > 1) {
-            logging_1.debugLog.clientError('ConfigValidation', 'Invalid error sampling rate', {
-                provided: config.errorSampling,
-                expected: '0-1',
-            });
             throw new validation_error_types_1.SamplingRateValidationError(constants_1.VALIDATION_MESSAGES.INVALID_ERROR_SAMPLING_RATE, 'config');
         }
     }
+    if (config.samplingRate !== undefined) {
+        if (typeof config.samplingRate !== 'number' || config.samplingRate < 0 || config.samplingRate > 1) {
+            throw new validation_error_types_1.SamplingRateValidationError(constants_1.VALIDATION_MESSAGES.INVALID_SAMPLING_RATE, 'config');
+        }
+    }
+    if (config.allowHttp !== undefined) {
+        if (typeof config.allowHttp !== 'boolean') {
+            throw new validation_error_types_1.AppConfigValidationError('allowHttp must be a boolean', 'config');
+        }
+    }
 };
 exports.validateAppConfig = validateAppConfig;
 /**
@@ -136,19 +109,25 @@ const validateScrollContainerSelectors = (selectors) => {
     const selectorsArray = Array.isArray(selectors) ? selectors : [selectors];
     for (const selector of selectorsArray) {
         if (typeof selector !== 'string' || selector.trim() === '') {
-            logging_1.debugLog.clientError('ConfigValidation', 'Invalid scroll container selector', {
-                selector,
-                type: typeof selector,
-                isEmpty: selector === '' || (typeof selector === 'string' && selector.trim() === ''),
+            (0, logging_utils_1.log)('error', 'Invalid scroll container selector', {
+                showToClient: true,
+                data: {
+                    selector,
+                    type: typeof selector,
+                    isEmpty: selector === '' || (typeof selector === 'string' && selector.trim() === ''),
+                },
             });
             throw new validation_error_types_1.AppConfigValidationError(constants_1.VALIDATION_MESSAGES.INVALID_SCROLL_CONTAINER_SELECTORS, 'config');
         }
         // Validate CSS selector syntax using regex-based validation (XSS prevention)
         // This validates syntax WITHOUT executing document.querySelector()
         if (!isValidCssSelectorSyntax(selector)) {
-            logging_1.debugLog.clientError('ConfigValidation', 'Invalid or potentially unsafe CSS selector', {
-                selector,
-                reason: 'Failed security validation',
+            (0, logging_utils_1.log)('error', 'Invalid or potentially unsafe CSS selector', {
+                showToClient: true,
+                data: {
+                    selector,
+                    reason: 'Failed security validation',
+                },
             });
             throw new validation_error_types_1.AppConfigValidationError('Invalid or potentially unsafe CSS selector', 'config');
         }
@@ -159,23 +138,34 @@ const validateScrollContainerSelectors = (selectors) => {
  * @param integrations - Integrations configuration to validate
  */
 const validateIntegrations = (integrations) => {
-    if (!integrations)
+    if (!integrations) {
         return;
+    }
+    if (integrations.tracelog) {
+        if (!integrations.tracelog.projectId ||
+            typeof integrations.tracelog.projectId !== 'string' ||
+            integrations.tracelog.projectId.trim() === '') {
+            throw new validation_error_types_1.IntegrationValidationError(constants_1.VALIDATION_MESSAGES.INVALID_TRACELOG_PROJECT_ID, 'config');
+        }
+    }
+    if (integrations.custom) {
+        if (!integrations.custom.apiUrl ||
+            typeof integrations.custom.apiUrl !== 'string' ||
+            integrations.custom.apiUrl.trim() === '') {
+            throw new validation_error_types_1.IntegrationValidationError(constants_1.VALIDATION_MESSAGES.INVALID_CUSTOM_API_URL, 'config');
+        }
+        if (!integrations.custom.apiUrl.startsWith('http')) {
+            throw new validation_error_types_1.IntegrationValidationError('Custom API URL must start with "http"', 'config');
+        }
+    }
     if (integrations.googleAnalytics) {
         if (!integrations.googleAnalytics.measurementId ||
             typeof integrations.googleAnalytics.measurementId !== 'string' ||
             integrations.googleAnalytics.measurementId.trim() === '') {
-            logging_1.debugLog.clientError('ConfigValidation', 'Invalid Google Analytics measurement ID', {
-                provided: integrations.googleAnalytics.measurementId,
-                type: typeof integrations.googleAnalytics.measurementId,
-            });
             throw new validation_error_types_1.IntegrationValidationError(constants_1.VALIDATION_MESSAGES.INVALID_GOOGLE_ANALYTICS_ID, 'config');
         }
         const measurementId = integrations.googleAnalytics.measurementId.trim();
         if (!measurementId.match(/^(G-|UA-)/)) {
-            logging_1.debugLog.clientError('ConfigValidation', 'Google Analytics measurement ID must start with "G-" or "UA-"', {
-                provided: measurementId,
-            });
             throw new validation_error_types_1.IntegrationValidationError('Google Analytics measurement ID must start with "G-" or "UA-"', 'config');
         }
     }
@@ -189,52 +179,16 @@ const validateIntegrations = (integrations) => {
  * @throws {AppConfigValidationError} If other configuration validation fails
  */
 const validateAndNormalizeConfig = (config) => {
-    // First validate the structure and basic types
     (0, exports.validateAppConfig)(config);
-    // Normalize string values
     const normalizedConfig = {
         ...config,
-        id: config.id.trim(),
+        sessionTimeout: config.sessionTimeout ?? constants_1.DEFAULT_SESSION_TIMEOUT,
         globalMetadata: config.globalMetadata ?? {},
         sensitiveQueryParams: config.sensitiveQueryParams ?? [],
+        errorSampling: config.errorSampling ?? 1,
+        samplingRate: config.samplingRate ?? 1,
+        allowHttp: config.allowHttp ?? false,
     };
-    // Validate normalized values - this catches whitespace-only IDs
-    if (!normalizedConfig.id) {
-        logging_1.debugLog.clientError('ConfigValidation', 'Project ID is empty after trimming whitespace', {
-            originalId: config.id,
-            normalizedId: normalizedConfig.id,
-        });
-        throw new validation_error_types_1.ProjectIdValidationError(constants_1.VALIDATION_MESSAGES.PROJECT_ID_EMPTY_AFTER_TRIM, 'config');
-    }
     return normalizedConfig;
 };
 exports.validateAndNormalizeConfig = validateAndNormalizeConfig;
-/**
- * Type guard to check if a JSON response is a valid API config
- * @param json - The JSON to validate
- * @returns True if the JSON is a valid API config
- */
-const isValidConfigApiResponse = (json) => {
-    try {
-        if (typeof json !== 'object' || !json) {
-            return false;
-        }
-        const response = json;
-        const result = {
-            mode: response['mode'] === undefined || [types_1.Mode.QA, types_1.Mode.DEBUG].includes(response['mode']),
-            // Zero is valid for samplingRate (means "sample nothing")
-            samplingRate: response['samplingRate'] === undefined ||
-                (typeof response['samplingRate'] === 'number' &&
-                    response['samplingRate'] >= 0 &&
-                    response['samplingRate'] <= 1),
-            tags: response['tags'] === undefined || Array.isArray(response['tags']),
-            excludedUrlPaths: response['excludedUrlPaths'] === undefined || Array.isArray(response['excludedUrlPaths']),
-            ipExcluded: response['ipExcluded'] === undefined || typeof response['ipExcluded'] === 'boolean',
-        };
-        return Object.values(result).every(Boolean);
-    }
-    catch {
-        return false;
-    }
-};
-exports.isValidConfigApiResponse = isValidConfigApiResponse;

package/dist/cjs/utils/validations/event-validations.utils.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEventValid = void 0;
+const logging_utils_1 = require("../logging.utils");
 const metadata_validations_utils_1 = require("./metadata-validations.utils");
-const logging_1 = require("../logging");
 /**
  * Validates a complete event with name and optional metadata
  * @param eventName - The event name to validate
@@ -12,7 +12,10 @@ const logging_1 = require("../logging");
 const isEventValid = (eventName, metadata) => {
     const nameValidation = (0, metadata_validations_utils_1.isValidEventName)(eventName);
     if (!nameValidation.valid) {
-        logging_1.debugLog.clientError('EventValidation', 'Event name validation failed', { eventName, error: nameValidation.error });
+        (0, logging_utils_1.log)('error', 'Event name validation failed', {
+            showToClient: true,
+            data: { eventName, error: nameValidation.error },
+        });
         return nameValidation;
     }
     if (!metadata) {
@@ -20,9 +23,12 @@ const isEventValid = (eventName, metadata) => {
     }
     const metadataValidation = (0, metadata_validations_utils_1.isValidMetadata)(eventName, metadata, 'customEvent');
     if (!metadataValidation.valid) {
-        logging_1.debugLog.clientError('EventValidation', 'Event metadata validation failed', {
-            eventName,
-            error: metadataValidation.error,
+        (0, logging_utils_1.log)('error', 'Event metadata validation failed', {
+            showToClient: true,
+            data: {
+                eventName,
+                error: metadataValidation.error,
+            },
         });
     }
     return metadataValidation;

package/dist/cjs/utils/validations/index.d.ts

@@ -2,4 +2,3 @@ export * from './config-validations.utils';
 export * from './event-validations.utils';
 export * from './metadata-validations.utils';
 export * from './type-guards.utils';
-export * from './url-validations.utils';

package/dist/cjs/utils/validations/index.js

@@ -18,4 +18,3 @@ __exportStar(require("./config-validations.utils"), exports);
 __exportStar(require("./event-validations.utils"), exports);
 __exportStar(require("./metadata-validations.utils"), exports);
 __exportStar(require("./type-guards.utils"), exports);
-__exportStar(require("./url-validations.utils"), exports);

package/dist/cjs/utils/validations/metadata-validations.utils.js

@@ -142,7 +142,6 @@ const isValidMetadata = (eventName, metadata, type) => {
                 sanitizedArray.push(itemValidation.sanitizedMetadata);
             }
         }
-        // Allow empty arrays after sanitization
         return {
             valid: true,
             sanitizedMetadata: sanitizedArray,

package/dist/cjs/utils/validations/type-guards.utils.d.ts

@@ -1,6 +1,6 @@
 /**
- * Checks if an object contains only primitive fields (string, number, boolean, or string arrays)
+ * Checks if an object contains only primitive fields, string arrays, or arrays of flat objects
  * @param object - The object to check
- * @returns True if the object contains only primitive fields
+ * @returns True if the object contains only valid fields
  */
 export declare const isOnlyPrimitiveFields: (object: Record<string, unknown>) => boolean;