@armco/analytics 0.2.11 → 0.3.1

package/utils/validation.js

@@ -0,0 +1,146 @@
+import { z } from "zod";
+import { ValidationError } from "../core/errors";
+const configSchema = z.object({
+    apiKey: z.string().optional(),
+    endpoint: z.string().url().optional(),
+    hostProjectName: z.string().optional(),
+    trackEvents: z.array(z.string()).optional(),
+    submissionStrategy: z.enum(["ONEVENT", "DEFER"]).optional(),
+    showConsentPopup: z.boolean().optional(),
+    logLevel: z.enum(["debug", "info", "warn", "error", "none"]).optional(),
+    samplingRate: z.number().min(0).max(1).optional(),
+    enableLocation: z.boolean().optional(),
+    enableAutoTrack: z.boolean().optional(),
+    respectDoNotTrack: z.boolean().optional(),
+    batchSize: z.number().positive().optional(),
+    flushInterval: z.number().positive().optional(),
+    maxRetries: z.number().nonnegative().optional(),
+    retryDelay: z.number().positive().optional(),
+});
+const userSchema = z.object({
+    email: z.string().email("Invalid email address"),
+    id: z.string().optional(),
+    name: z.string().optional(),
+}).passthrough();
+const pageViewSchema = z.object({
+    pageName: z.string().min(1, "Page name is required"),
+    url: z.string().url("Invalid URL"),
+    referrer: z.string().optional(),
+    title: z.string().optional(),
+}).passthrough();
+const clickEventSchema = z.object({
+    elementType: z.string().min(1, "Element type is required"),
+    elementId: z.string().optional(),
+    elementText: z.string().optional(),
+    elementClasses: z.array(z.string()).optional(),
+    elementPath: z.string().optional(),
+    href: z.string().optional(),
+    value: z.string().optional(),
+}).passthrough();
+const formEventSchema = z.object({
+    formId: z.string().optional(),
+    formName: z.string().optional(),
+    formAction: z.string().optional(),
+    formMethod: z.string().optional(),
+}).passthrough();
+const errorEventSchema = z.object({
+    errorMessage: z.string().min(1, "Error message is required"),
+    errorStack: z.string().optional(),
+    errorType: z.string().optional(),
+}).passthrough();
+export function validateConfig(config) {
+    try {
+        return configSchema.parse(config);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const messages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+            throw new ValidationError(`Configuration validation failed: ${messages.join(", ")}`);
+        }
+        throw error;
+    }
+}
+export function validateUser(user) {
+    try {
+        return userSchema.parse(user);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const messages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+            throw new ValidationError(`User validation failed: ${messages.join(", ")}`);
+        }
+        throw error;
+    }
+}
+export function validatePageView(data) {
+    try {
+        return pageViewSchema.parse(data);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const messages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+            throw new ValidationError(`Page view validation failed: ${messages.join(", ")}`);
+        }
+        throw error;
+    }
+}
+export function validateClickEvent(data) {
+    try {
+        return clickEventSchema.parse(data);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const messages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+            throw new ValidationError(`Click event validation failed: ${messages.join(", ")}`);
+        }
+        throw error;
+    }
+}
+export function validateFormEvent(data) {
+    try {
+        return formEventSchema.parse(data);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const messages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+            throw new ValidationError(`Form event validation failed: ${messages.join(", ")}`);
+        }
+        throw error;
+    }
+}
+export function validateErrorEvent(data) {
+    try {
+        return errorEventSchema.parse(data);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const messages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+            throw new ValidationError(`Error event validation failed: ${messages.join(", ")}`);
+        }
+        throw error;
+    }
+}
+export function validateEventType(eventType) {
+    if (typeof eventType !== "string" || eventType.trim().length === 0) {
+        throw new ValidationError("Event type must be a non-empty string");
+    }
+    return eventType.trim();
+}
+export function sanitizeEventData(data) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (typeof value === "function" || value === undefined) {
+            continue;
+        }
+        if (typeof value === "string") {
+            sanitized[key] = value.trim();
+        }
+        else if (Array.isArray(value)) {
+            sanitized[key] = value.map((item) => typeof item === "string" ? item.trim() : item);
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}