@magentrix-corp/magentrix-cli 1.3.10 → 1.3.11

package/utils/iris/validation.js

@@ -0,0 +1,360 @@
+/**
+ * Validation utilities for Iris Vue integration.
+ * Provides input validation, format checking, and user-friendly error messages.
+ */
+
+/**
+ * Valid slug pattern: lowercase alphanumeric, can contain hyphens and underscores
+ * Must start with alphanumeric, 1-200 characters total
+ */
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-_]{0,199}$/;
+
+/**
+ * Characters not allowed in slugs (for error messages)
+ */
+const INVALID_SLUG_CHARS = /[^a-z0-9-_]/g;
+
+/**
+ * Maximum lengths for various fields
+ */
+export const MAX_LENGTHS = {
+    slug: 200,
+    appName: 255,
+    appDescription: 1000,
+    siteUrl: 500
+};
+
+/**
+ * Validate a slug format.
+ *
+ * @param {string} slug - The slug to validate
+ * @returns {{
+ *   valid: boolean,
+ *   error: string | null,
+ *   suggestion: string | null
+ * }}
+ */
+export function validateSlug(slug) {
+    const result = {
+        valid: true,
+        error: null,
+        suggestion: null
+    };
+
+    // Check for empty/null/undefined
+    if (!slug || typeof slug !== 'string') {
+        result.valid = false;
+        result.error = 'Slug is required and must be a string';
+        return result;
+    }
+
+    // Trim whitespace
+    const trimmedSlug = slug.trim();
+
+    // Check for empty after trim
+    if (trimmedSlug.length === 0) {
+        result.valid = false;
+        result.error = 'Slug cannot be empty or contain only whitespace';
+        return result;
+    }
+
+    // Check for path traversal attempts (security)
+    if (trimmedSlug.includes('..') || trimmedSlug.includes('/') || trimmedSlug.includes('\\')) {
+        result.valid = false;
+        result.error = 'Slug cannot contain path separators (.., /, \\) for security reasons';
+        return result;
+    }
+
+    // Check length
+    if (trimmedSlug.length > MAX_LENGTHS.slug) {
+        result.valid = false;
+        result.error = `Slug must be ${MAX_LENGTHS.slug} characters or less (currently ${trimmedSlug.length})`;
+        result.suggestion = trimmedSlug.substring(0, MAX_LENGTHS.slug);
+        return result;
+    }
+
+    // Check for uppercase (common mistake)
+    if (trimmedSlug !== trimmedSlug.toLowerCase()) {
+        result.valid = false;
+        result.error = 'Slug must be lowercase';
+        result.suggestion = trimmedSlug.toLowerCase();
+        return result;
+    }
+
+    // Check first character
+    if (!/^[a-z0-9]/.test(trimmedSlug)) {
+        result.valid = false;
+        result.error = 'Slug must start with a letter or number (not a hyphen or underscore)';
+        // Suggest removing leading special chars
+        const cleaned = trimmedSlug.replace(/^[-_]+/, '');
+        if (cleaned.length > 0) {
+            result.suggestion = cleaned;
+        }
+        return result;
+    }
+
+    // Check pattern
+    if (!SLUG_PATTERN.test(trimmedSlug)) {
+        const invalidChars = trimmedSlug.match(INVALID_SLUG_CHARS);
+        if (invalidChars) {
+            const uniqueChars = [...new Set(invalidChars)].join(', ');
+            result.valid = false;
+            result.error = `Slug contains invalid characters: ${uniqueChars}`;
+            result.suggestion = trimmedSlug.replace(INVALID_SLUG_CHARS, '-').replace(/--+/g, '-');
+        } else {
+            result.valid = false;
+            result.error = 'Slug format is invalid. Use only lowercase letters, numbers, hyphens, and underscores.';
+        }
+        return result;
+    }
+
+    return result;
+}
+
+/**
+ * Validate a URL format.
+ *
+ * @param {string} url - The URL to validate
+ * @param {Object} options - Validation options
+ * @param {boolean} options.requireHttps - Require HTTPS protocol (default: false)
+ * @param {boolean} options.allowTrailingSlash - Allow trailing slash (default: true)
+ * @returns {{
+ *   valid: boolean,
+ *   error: string | null,
+ *   suggestion: string | null,
+ *   normalized: string | null
+ * }}
+ */
+export function validateUrl(url, options = {}) {
+    const { requireHttps = false, allowTrailingSlash = true } = options;
+
+    const result = {
+        valid: true,
+        error: null,
+        suggestion: null,
+        normalized: null
+    };
+
+    // Check for empty/null/undefined
+    if (!url || typeof url !== 'string') {
+        result.valid = false;
+        result.error = 'URL is required and must be a string';
+        return result;
+    }
+
+    const trimmedUrl = url.trim();
+
+    // Check for empty after trim
+    if (trimmedUrl.length === 0) {
+        result.valid = false;
+        result.error = 'URL cannot be empty';
+        return result;
+    }
+
+    // Check length
+    if (trimmedUrl.length > MAX_LENGTHS.siteUrl) {
+        result.valid = false;
+        result.error = `URL must be ${MAX_LENGTHS.siteUrl} characters or less`;
+        return result;
+    }
+
+    // Check for protocol
+    if (!trimmedUrl.startsWith('http://') && !trimmedUrl.startsWith('https://')) {
+        result.valid = false;
+        result.error = 'URL must start with http:// or https://';
+        // Suggest adding https://
+        result.suggestion = `https://${trimmedUrl}`;
+        return result;
+    }
+
+    // Check for HTTPS requirement
+    if (requireHttps && trimmedUrl.startsWith('http://')) {
+        result.valid = false;
+        result.error = 'URL must use HTTPS for security';
+        result.suggestion = trimmedUrl.replace('http://', 'https://');
+        return result;
+    }
+
+    // Try to parse as URL
+    try {
+        const parsed = new URL(trimmedUrl);
+
+        // Normalize the URL (remove trailing slash if not allowed)
+        let normalized = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+        if (!allowTrailingSlash && normalized.endsWith('/') && normalized.length > parsed.protocol.length + 3) {
+            normalized = normalized.slice(0, -1);
+        }
+
+        // Add back query string and hash if present
+        if (parsed.search) {
+            normalized += parsed.search;
+        }
+        if (parsed.hash) {
+            normalized += parsed.hash;
+        }
+
+        result.normalized = normalized;
+    } catch (err) {
+        result.valid = false;
+        result.error = `Invalid URL format: ${err.message}`;
+        return result;
+    }
+
+    return result;
+}
+
+/**
+ * Validate app name format.
+ *
+ * @param {string} appName - The app name to validate
+ * @returns {{
+ *   valid: boolean,
+ *   error: string | null
+ * }}
+ */
+export function validateAppName(appName) {
+    const result = {
+        valid: true,
+        error: null
+    };
+
+    // Check for empty/null/undefined
+    if (!appName || typeof appName !== 'string') {
+        result.valid = false;
+        result.error = 'App name is required and must be a string';
+        return result;
+    }
+
+    const trimmed = appName.trim();
+
+    // Check for empty after trim
+    if (trimmed.length === 0) {
+        result.valid = false;
+        result.error = 'App name cannot be empty or contain only whitespace';
+        return result;
+    }
+
+    // Check length
+    if (trimmed.length > MAX_LENGTHS.appName) {
+        result.valid = false;
+        result.error = `App name must be ${MAX_LENGTHS.appName} characters or less (currently ${trimmed.length})`;
+        return result;
+    }
+
+    return result;
+}
+
+/**
+ * Check if a string looks like it contains a JavaScript expression.
+ * Used to detect template literals or expressions in config values.
+ *
+ * @param {string} value - The value to check
+ * @returns {{
+ *   isExpression: boolean,
+ *   type: 'template_literal' | 'variable' | 'function_call' | null
+ * }}
+ */
+export function detectExpression(value) {
+    const result = {
+        isExpression: false,
+        type: null
+    };
+
+    if (!value || typeof value !== 'string') {
+        return result;
+    }
+
+    // Check for template literal syntax
+    if (value.includes('${') && value.includes('}')) {
+        result.isExpression = true;
+        result.type = 'template_literal';
+        return result;
+    }
+
+    // Check for variable reference patterns
+    if (/^(process\.env\.|env\.|import\.meta\.)/i.test(value)) {
+        result.isExpression = true;
+        result.type = 'variable';
+        return result;
+    }
+
+    // Check for function call patterns
+    if (/\([^)]*\)$/.test(value)) {
+        result.isExpression = true;
+        result.type = 'function_call';
+        return result;
+    }
+
+    return result;
+}
+
+/**
+ * Sanitize a string to be safe for use in file paths.
+ *
+ * @param {string} input - The string to sanitize
+ * @returns {string} - Sanitized string
+ */
+export function sanitizeForPath(input) {
+    if (!input || typeof input !== 'string') {
+        return '';
+    }
+
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9-_]/g, '-')  // Replace invalid chars with hyphen
+        .replace(/--+/g, '-')          // Replace multiple hyphens with single
+        .replace(/^-|-$/g, '')         // Remove leading/trailing hyphens
+        .substring(0, MAX_LENGTHS.slug);
+}
+
+/**
+ * Validate that a value is not empty after various processing.
+ *
+ * @param {*} value - The value to check
+ * @param {string} fieldName - Name of the field for error messages
+ * @returns {{valid: boolean, error: string | null}}
+ */
+export function validateNotEmpty(value, fieldName) {
+    const result = {
+        valid: true,
+        error: null
+    };
+
+    if (value === null || value === undefined) {
+        result.valid = false;
+        result.error = `${fieldName} is required`;
+        return result;
+    }
+
+    if (typeof value === 'string' && value.trim().length === 0) {
+        result.valid = false;
+        result.error = `${fieldName} cannot be empty`;
+        return result;
+    }
+
+    if (Array.isArray(value) && value.length === 0) {
+        result.valid = false;
+        result.error = `${fieldName} cannot be empty`;
+        return result;
+    }
+
+    return result;
+}
+
+/**
+ * Format validation errors for display.
+ *
+ * @param {string} fieldName - Name of the field
+ * @param {string} error - Error message
+ * @param {string | null} suggestion - Suggested fix
+ * @returns {string} - Formatted error message
+ */
+export function formatValidationError(fieldName, error, suggestion = null) {
+    let message = `Invalid ${fieldName}: ${error}`;
+
+    if (suggestion) {
+        message += `\n  Suggestion: ${suggestion}`;
+    }
+
+    return message;
+}