@magentrix-corp/magentrix-cli 1.2.1 → 1.3.0

package/utils/iris/config-reader.js

@@ -0,0 +1,296 @@
+import { existsSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+/**
+ * Common locations where config.ts might be found in a Vue project.
+ */
+const CONFIG_LOCATIONS = [
+    'src/config.ts',
+    'config.ts',
+    'src/iris-config.ts',
+    'iris-config.ts'
+];
+
+/**
+ * Find the config.ts file in a Vue project.
+ *
+ * @param {string} projectPath - Path to the Vue project
+ * @returns {string | null} - Path to config.ts or null if not found
+ */
+export function findConfigFile(projectPath) {
+    for (const location of CONFIG_LOCATIONS) {
+        const fullPath = join(projectPath, location);
+        if (existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+
+/**
+ * Parse a config.ts file and extract Iris configuration.
+ * Uses regex parsing to avoid TypeScript compilation.
+ *
+ * @param {string} configPath - Path to the config.ts file
+ * @returns {{
+ *   slug: string | null,
+ *   appName: string | null,
+ *   siteUrl: string | null,
+ *   assets: string[],
+ *   raw: string
+ * }}
+ */
+export function parseConfigFile(configPath) {
+    const result = {
+        slug: null,
+        appName: null,
+        siteUrl: null,
+        assets: [],
+        raw: ''
+    };
+
+    if (!existsSync(configPath)) {
+        return result;
+    }
+
+    const content = readFileSync(configPath, 'utf-8');
+    result.raw = content;
+
+    // Extract slug (various patterns)
+    // slug: "dashboard", appPath: "dashboard", app_path: "dashboard"
+    // Also handles: slug: env.slug || "fallback"
+    const slugMatch = content.match(/(?:slug|appPath|app_path)\s*:\s*["'`]([^"'`]+)["'`]/);
+    if (slugMatch) {
+        result.slug = slugMatch[1];
+    } else {
+        const slugFallbackMatch = content.match(/(?:slug|appPath|app_path)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
+        if (slugFallbackMatch) {
+            result.slug = slugFallbackMatch[1];
+        }
+    }
+
+    // Extract appName (various patterns)
+    // appName: "Dashboard App", app_name: "Dashboard", name: "Dashboard"
+    // Also handles: appName: env.appName || "fallback"
+    const appNameMatch = content.match(/(?:appName|app_name)\s*:\s*["'`]([^"'`]+)["'`]/);
+    if (appNameMatch) {
+        result.appName = appNameMatch[1];
+    } else {
+        const appNameFallbackMatch = content.match(/(?:appName|app_name)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
+        if (appNameFallbackMatch) {
+            result.appName = appNameFallbackMatch[1];
+        }
+    }
+
+    // Extract siteUrl (various patterns)
+    // siteUrl: "https://...", site_url: "https://...", baseUrl: "https://..."
+    // Also handles: siteUrl: env.siteUrl || "https://..."
+    const siteUrlMatch = content.match(/(?:siteUrl|site_url|baseUrl|base_url)\s*:\s*["'`]([^"'`]+)["'`]/);
+    if (siteUrlMatch) {
+        result.siteUrl = siteUrlMatch[1];
+    } else {
+        // Try to match fallback pattern: siteUrl: env.x || "fallback"
+        const siteUrlFallbackMatch = content.match(/(?:siteUrl|site_url|baseUrl|base_url)\s*:\s*[^,\n]+\|\|\s*["'`]([^"'`]+)["'`]/);
+        if (siteUrlFallbackMatch) {
+            result.siteUrl = siteUrlFallbackMatch[1];
+        }
+    }
+
+    // Extract assets array
+    // assets: ["url1", "url2"]
+    const assetsMatch = content.match(/assets\s*:\s*\[([\s\S]*?)\]/);
+    if (assetsMatch) {
+        const assetsContent = assetsMatch[1];
+        // Extract all quoted strings from the array
+        const urlMatches = assetsContent.matchAll(/["'`]([^"'`]+)["'`]/g);
+        for (const match of urlMatches) {
+            result.assets.push(match[1]);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Read Vue project configuration.
+ *
+ * @param {string} projectPath - Path to the Vue project
+ * @returns {{
+ *   found: boolean,
+ *   configPath: string | null,
+ *   slug: string | null,
+ *   appName: string | null,
+ *   siteUrl: string | null,
+ *   assets: string[],
+ *   errors: string[]
+ * }}
+ */
+export function readVueConfig(projectPath) {
+    const result = {
+        found: false,
+        configPath: null,
+        slug: null,
+        appName: null,
+        siteUrl: null,
+        assets: [],
+        errors: []
+    };
+
+    const configPath = findConfigFile(projectPath);
+    if (!configPath) {
+        result.errors.push(`No config.ts found in ${projectPath}`);
+        result.errors.push(`Searched locations: ${CONFIG_LOCATIONS.join(', ')}`);
+        return result;
+    }
+
+    result.found = true;
+    result.configPath = configPath;
+
+    const parsed = parseConfigFile(configPath);
+    result.slug = parsed.slug;
+    result.appName = parsed.appName;
+    result.siteUrl = parsed.siteUrl;
+    result.assets = parsed.assets;
+
+    // Validate required fields
+    if (!result.slug) {
+        result.errors.push('Missing required field: slug');
+    }
+    if (!result.appName) {
+        result.errors.push('Missing required field: appName');
+    }
+
+    return result;
+}
+
+/**
+ * Create a backup of the config file.
+ *
+ * @param {string} configPath - Path to the config.ts file
+ * @returns {string} - Path to the backup file
+ */
+export function backupConfigFile(configPath) {
+    const backupPath = `${configPath}.bak`;
+    copyFileSync(configPath, backupPath);
+    return backupPath;
+}
+
+/**
+ * Restore config file from backup.
+ *
+ * @param {string} configPath - Path to the config.ts file
+ * @returns {boolean} - True if restored, false if backup not found
+ */
+export function restoreConfigFile(configPath) {
+    const backupPath = `${configPath}.bak`;
+    if (!existsSync(backupPath)) {
+        return false;
+    }
+    copyFileSync(backupPath, configPath);
+    return true;
+}
+
+/**
+ * Inject assets into config.ts file.
+ *
+ * @param {string} configPath - Path to the config.ts file
+ * @param {string[]} assets - Array of asset URLs to inject
+ * @returns {boolean} - True if successful
+ */
+export function injectAssetsIntoConfig(configPath, assets) {
+    if (!existsSync(configPath)) {
+        return false;
+    }
+
+    let content = readFileSync(configPath, 'utf-8');
+
+    // Format assets array
+    const assetsStr = assets.map(url => `    "${url}"`).join(',\n');
+    const newAssetsBlock = `assets: [\n    // Injected by magentrix iris-dev\n${assetsStr}\n  ]`;
+
+    // Check if assets array exists
+    const assetsPattern = /assets\s*:\s*\[[\s\S]*?\]/;
+    if (assetsPattern.test(content)) {
+        // Replace existing assets array
+        content = content.replace(assetsPattern, newAssetsBlock);
+    } else {
+        // Need to add assets array - find a good place
+        // Look for the end of the config object
+        const configObjectPattern = /(export\s+(?:const|let|var)\s+\w+\s*=\s*\{[\s\S]*?)(}\s*;?\s*$)/;
+        const match = content.match(configObjectPattern);
+        if (match) {
+            // Insert before closing brace
+            const beforeClose = match[1].trimEnd();
+            const needsComma = !beforeClose.endsWith(',') && !beforeClose.endsWith('{');
+            content = content.replace(
+                configObjectPattern,
+                `${match[1]}${needsComma ? ',' : ''}\n  ${newAssetsBlock}\n${match[2]}`
+            );
+        } else {
+            // Can't find a good place to inject
+            return false;
+        }
+    }
+
+    writeFileSync(configPath, content, 'utf-8');
+    return true;
+}
+
+/**
+ * Format missing config error message.
+ *
+ * @param {string} projectPath - Path to the Vue project
+ * @returns {string} - Formatted error message
+ */
+export function formatMissingConfigError(projectPath) {
+    return `Missing Configuration
+────────────────────────────────────────────────────
+
+Could not find config.ts in the Vue project.
+
+Expected location: ${join(projectPath, 'src/config.ts')}
+
+Required fields:
+  - slug: App identifier (used as folder name)
+  - appName: Display name for navigation menu
+  - siteUrl: Magentrix instance URL
+
+Example config.ts:
+  export const config = {
+    slug: "my-app",
+    appName: "My Application",
+    siteUrl: "https://yourinstance.magentrix.com",
+    assets: []
+  }`;
+}
+
+/**
+ * Format config validation errors.
+ *
+ * @param {ReturnType<typeof readVueConfig>} config - Config read result
+ * @returns {string} - Formatted error message
+ */
+export function formatConfigErrors(config) {
+    const lines = [
+        'Invalid Configuration',
+        '────────────────────────────────────────────────────',
+        '',
+        `Config file: ${config.configPath || 'not found'}`,
+        ''
+    ];
+
+    if (config.errors.length > 0) {
+        lines.push('Issues:');
+        for (const error of config.errors) {
+            lines.push(`  ✗ ${error}`);
+        }
+    }
+
+    lines.push('');
+    lines.push('Current values:');
+    lines.push(`  slug: ${config.slug || '(missing)'}`);
+    lines.push(`  appName: ${config.appName || '(missing)'}`);
+    lines.push(`  siteUrl: ${config.siteUrl || '(missing)'}`);
+
+    return lines.join('\n');
+}

package/utils/iris/deleteHelper.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+import Config from '../config.js';
+import { deleteApp } from '../magentrix/api/iris.js';
+
+const config = new Config();
+
+/**
+ * Delete an Iris app from the server and update cache.
+ * Does NOT delete local files or create backups - caller handles that.
+ *
+ * @param {string} instanceUrl - Magentrix instance URL
+ * @param {string} token - OAuth token
+ * @param {string} slug - App slug (folder name)
+ * @param {object} options - Options
+ * @param {boolean} options.updateCache - Whether to update base.json (default: true)
+ * @returns {Promise<{success: boolean, error: string | null, cleanedFromCache: boolean}>}
+ */
+export async function deleteIrisAppFromServer(instanceUrl, token, slug, options = {}) {
+    const { updateCache = true } = options;
+    const result = {
+        success: false,
+        error: null,
+        cleanedFromCache: false
+    };
+
+    try {
+        // Delete from server
+        const deleteResult = await deleteApp(instanceUrl, token, slug);
+
+        if (!deleteResult.success) {
+            result.error = deleteResult.message || deleteResult.error || 'Unknown error';
+            return result;
+        }
+
+        result.success = true;
+
+        // Update cache if requested
+        if (updateCache) {
+            config.removeKey(`iris-app:${slug}`, { filename: 'base.json' });
+            result.cleanedFromCache = true;
+        }
+
+        return result;
+    } catch (error) {
+        // Check if this is a "not found" error (app already deleted on server)
+        const errorMessage = error?.message || String(error);
+        const errorLower = errorMessage.toLowerCase();
+        const isNotFound = errorLower.includes('404') ||
+            errorLower.includes('not found') ||
+            errorLower.includes('does not exist');
+
+        if (isNotFound) {
+            // App doesn't exist on server, but clean up local cache anyway
+            if (updateCache) {
+                config.removeKey(`iris-app:${slug}`, { filename: 'base.json' });
+                result.cleanedFromCache = true;
+            }
+            result.success = true;
+            result.error = 'App not found on server (already deleted)';
+            return result;
+        }
+
+        result.error = errorMessage;
+        return result;
+    }
+}
+
+/**
+ * Delete local Iris app files.
+ *
+ * @param {string} appPath - Absolute path to the app folder
+ * @returns {{success: boolean, existed: boolean, error: string | null, isPermissionError: boolean}}
+ */
+export function deleteLocalIrisAppFiles(appPath) {
+    if (!fs.existsSync(appPath)) {
+        return {
+            success: true,
+            existed: false,
+            error: null,
+            isPermissionError: false
+        };
+    }
+
+    try {
+        fs.rmSync(appPath, { recursive: true, force: true });
+        return {
+            success: true,
+            existed: true,
+            error: null,
+            isPermissionError: false
+        };
+    } catch (error) {
+        const isPermissionError = error.code === 'EACCES' || error.code === 'EPERM';
+        return {
+            success: false,
+            existed: true,
+            error: error.message,
+            isPermissionError
+        };
+    }
+}