@magentrix-corp/magentrix-cli 1.3.16 → 1.3.17

package/utils/iris/validation.js

@@ -1,360 +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;
-}
+/**
+ * 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;
+}