@magentrix-corp/magentrix-cli 1.2.0 → 1.3.0

package/actions/publish.js

@@ -11,6 +11,7 @@ import {
     ENTITY_TYPE_MAP,
     EXPORT_ROOT,
     TYPE_DIR_MAP,
+    IRIS_APPS_DIR,
 } from "../vars/global.js";
 import { getFileTag, setFileTag } from "../utils/filetag.js";
 import { sha256 } from "../utils/hash.js";
@@ -20,6 +21,11 @@ import { deleteEntity } from "../utils/magentrix/api/deleteEntity.js";
 import { removeFromBase, updateBase } from "../utils/updateFileBase.js";
 import { deleteAsset, uploadAsset, createFolder } from "../utils/magentrix/api/assets.js";
 import { toApiPath, toApiFolderPath } from "../utils/assetPaths.js";
+import { publishApp } from "../utils/magentrix/api/iris.js";
+import { createIrisZip, hashIrisAppFolder } from "../utils/iris/zipper.js";
+import { validateIrisAppFolder } from "../utils/iris/validator.js";
+import { getLinkedProjects } from "../utils/iris/linker.js";
+import { deleteIrisAppFromServer } from "../utils/iris/deleteHelper.js";
 
 const config = new Config();
 
@@ -120,6 +126,8 @@ const walkFolders = (dir) => {
  * Gets display name for an action in log messages.
  */
 const getActionDisplayName = (action) => {
+    // Iris app actions
+    if (action.slug) return `${action.appName || action.slug} (${action.slug})`;
     if (action.folderName) return action.folderName;
     if (action.names) return action.names.join(", ");
     if (action.type) return action.type;
@@ -185,8 +193,8 @@ const handleDeleteStaticAssetAction = async (instanceUrl, apiKey, action) => {
         const errorMessage = error?.message || String(error);
         const errorLower = errorMessage.toLowerCase();
         const isNotFound = errorLower.includes('404') ||
-                          errorLower.includes('not found') ||
-                          errorLower.includes('item not found');
+            errorLower.includes('not found') ||
+            errorLower.includes('item not found');
 
         if (isNotFound) {
             // Clean up base.json since file doesn't exist on server
@@ -214,8 +222,8 @@ const handleCreateFolderAction = async (instanceUrl, apiKey, action) => {
         const errorMessage = error?.message || String(error);
         const errorLower = errorMessage.toLowerCase();
         const alreadyExists = errorLower.includes('already exists') ||
-                             errorLower.includes('folder exists') ||
-                             errorLower.includes('duplicate');
+            errorLower.includes('folder exists') ||
+            errorLower.includes('duplicate');
 
         if (alreadyExists) {
             // Folder already exists, update cache and treat as success
@@ -239,8 +247,8 @@ const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
         const errorMessage = error?.message || String(error);
         const errorLower = errorMessage.toLowerCase();
         const isNotFound = errorLower.includes('404') ||
-                          errorLower.includes('not found') ||
-                          errorLower.includes('item not found');
+            errorLower.includes('not found') ||
+            errorLower.includes('item not found');
 
         if (isNotFound) {
             // Clean up base.json since folder doesn't exist on server
@@ -273,11 +281,109 @@ const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
     }
 };
 
+/**
+ * Handles CREATE_IRIS_APP or UPDATE_IRIS_APP action.
+ */
+const handlePublishIrisAppAction = async (instanceUrl, apiKey, action) => {
+    // Create zip from the app folder
+    const zipBuffer = await createIrisZip(action.appPath, action.slug);
+
+    // Publish via API with app-name parameter
+    const response = await publishApp(
+        instanceUrl,
+        apiKey,
+        zipBuffer,
+        `${action.slug}.zip`,
+        action.appName
+    );
+
+    return response;
+};
+
+/**
+ * Handles DELETE_IRIS_APP action.
+ */
+const handleDeleteIrisAppAction = async (instanceUrl, apiKey, action) => {
+    // Use shared delete utility for consistency
+    return await deleteIrisAppFromServer(instanceUrl, apiKey, action.slug, {
+        updateCache: true  // Cache will be updated by the utility
+    });
+};
+
+/**
+ * Synchronizes class name in content with filename, or vice versa.
+ */
+const syncClassAndFileNames = (action, recordId) => {
+    // Only for ActiveClass
+    if (action.entity !== 'ActiveClass') return;
+
+    const filePath = action.filePath;
+    // If file was deleted or doesn't exist, skip
+    if (!fs.existsSync(filePath)) return;
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const filename = path.basename(filePath, path.extname(filePath));
+
+    // Regex to find class/interface/enum name
+    // Matches: public class Name, public interface Name, public enum Name
+    // We assume standard formatting
+    const classRegex = /public\s+(?:class|interface|enum)\s+(\w+)/;
+    const match = content.match(classRegex);
+
+    if (match) {
+        const classNameInContent = match[1];
+
+        if (classNameInContent !== filename) {
+            // Mismatch detected
+
+            // Case 1: File was renamed (action.renamed is true) -> Update content
+            if (action.renamed) {
+                const newContent = content.replace(classRegex, (fullMatch, name) => {
+                    return fullMatch.replace(name, filename);
+                });
+                fs.writeFileSync(filePath, newContent);
+                console.log(chalk.cyan(`  ↻ Updated class name in file to: ${filename}`));
+
+                // Update cache with new content hash
+                updateBase(filePath, { Id: recordId, Type: 'ActiveClass' });
+            }
+            // Case 2: Content was updated (action.renamed is false) -> Rename file
+            else {
+                // Rename file to match class name
+                const dir = path.dirname(filePath);
+                const ext = path.extname(filePath);
+                const newFilename = `${classNameInContent}${ext}`;
+                const newFilePath = path.join(dir, newFilename);
+
+                if (fs.existsSync(newFilePath)) {
+                    console.warn(chalk.yellow(`  ⚠️  Cannot rename ${filename} to ${classNameInContent}: File already exists.`));
+                    return;
+                }
+
+                try {
+                    fs.renameSync(filePath, newFilePath);
+                    console.log(chalk.cyan(`  ↻ Renamed file to match class: ${newFilename}`));
+
+                    // Update cache: update the entry for this recordId to point to new path
+                    updateBase(newFilePath, { Id: recordId, Type: 'ActiveClass' }, newFilePath);
+                } catch (err) {
+                    console.warn(chalk.yellow(`  ⚠️  Failed to rename file: ${err.message}`));
+                }
+            }
+        }
+    }
+};
+
 /**
  * Updates cache after successful operations.
  */
 const updateCacheAfterSuccess = async (action, operationResult) => {
     try {
+        // Sync class names/filenames if needed (Bug 2 Fix)
+        if (action.action === 'update' && operationResult?.recordId) {
+            syncClassAndFileNames(action, operationResult.recordId);
+        }
+
         switch (action.action) {
             case "create": {
                 const createSnapshot = action.fields && Object.values(action.fields)[0]
@@ -356,6 +462,28 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
                 }
                 break;
             }
+
+            case "create_iris_app":
+            case "update_iris_app": {
+                // Update base.json with new/updated Iris app info including content hash
+                updateBase(action.appPath, {
+                    Id: `iris-app:${action.slug}`,
+                    Type: 'IrisApp',
+                    folderName: action.slug,
+                    appName: action.appName,
+                    modifiedOn: new Date().toISOString(),
+                    contentHash: action.contentHash  // Store hash for change detection
+                }, action.appPath);
+                break;
+            }
+
+            case "delete_iris_app": {
+                // Skip if already cleaned from cache during 404 handling
+                if (!operationResult?.cleanedFromCache) {
+                    removeFromBase(`iris-app:${action.slug}`);
+                }
+                break;
+            }
         }
     } catch (error) {
         console.warn(chalk.yellow(`Warning: Failed to update cache for ${action.action}: ${error.message}`));
@@ -375,8 +503,8 @@ const groupActionsByResource = (actionQueue) => {
     for (let i = 0; i < actionQueue.length; i++) {
         const action = { ...actionQueue[i], originalIndex: i };
 
-        // Asset operations don't need sequencing
-        if (['create_static_asset', 'delete_static_asset', 'create_folder', 'delete_folder'].includes(action.action)) {
+        // Asset and Iris app operations don't need sequencing
+        if (['create_static_asset', 'delete_static_asset', 'create_folder', 'delete_folder', 'create_iris_app', 'update_iris_app', 'delete_iris_app'].includes(action.action)) {
             assets.push(action);
             continue;
         }
@@ -475,6 +603,13 @@ const executeAction = async (instanceUrl, token, action) => {
         case "delete_folder":
             result = await handleDeleteFolderAction(instanceUrl, token, action);
             break;
+        case "create_iris_app":
+        case "update_iris_app":
+            result = await handlePublishIrisAppAction(instanceUrl, token, action);
+            break;
+        case "delete_iris_app":
+            result = await handleDeleteIrisAppAction(instanceUrl, token, action);
+            break;
         default:
             throw new Error(`Unknown action: ${action.action}`);
     }
@@ -518,7 +653,8 @@ const performNetworkRequestSequential = async (actionQueue) => {
             console.log();
             console.log(chalk.bgRed.bold.white('  ✖ Operation Failed  '));
             console.log(chalk.redBright('─'.repeat(48)));
-            console.log(chalk.red.bold(`[${i + 1}] ${action.action.toUpperCase()} ${displayName} (${action.filePath || action.folderPath || action.folder}):`));
+            const actionPath = action.filePath || action.folderPath || action.folder || action.appPath || action.slug || 'unknown';
+            console.log(chalk.red.bold(`[${i + 1}] ${action.action.toUpperCase()} ${displayName} (${actionPath}):`));
             console.log(formatMultilineError(error.message));
             console.log(chalk.redBright('─'.repeat(48)));
         }
@@ -624,7 +760,8 @@ const performNetworkRequestParallel = async (actionQueue) => {
                 console.log();
                 console.log(chalk.bgRed.bold.white('  ✖ Operation Failed  '));
                 console.log(chalk.redBright('─'.repeat(48)));
-                console.log(chalk.red.bold(`[${index + 1}] ${action.action.toUpperCase()} ${getActionDisplayName(action)} (${action.filePath || action.folderPath || action.folder}):`));
+                const actionPath = action.filePath || action.folderPath || action.folder || action.appPath || action.slug || 'unknown';
+                console.log(chalk.red.bold(`[${index + 1}] ${action.action.toUpperCase()} ${getActionDisplayName(action)} (${actionPath}):`));
                 console.log(formatMultilineError(error));
                 console.log(chalk.redBright('─'.repeat(48)));
             }
@@ -721,6 +858,7 @@ export const runPublish = async (options = {}) => {
         ...c,
         tag: c.recordId,
         filePath: c.filePath || c.lastKnownPath,
+        type: c.type || c.Type,  // Normalize Type/type property
     }));
     const mapTime = Date.now() - mapStart;
 
@@ -728,11 +866,16 @@ export const runPublish = async (options = {}) => {
         progress.completeStep('load', `✓ Loaded ${cachedFiles.length} entries (${loadTime}ms load, ${mapTime}ms map)`);
     }
 
-    // Step 3: Scan local workspace (excluding Assets folder)
+    // Step 3: Scan local workspace (excluding Assets and iris-apps folders)
     if (progress) progress.startStep('scan');
 
     const walkStart = Date.now();
-    const localPaths = await walkFiles(EXPORT_ROOT, { ignore: [path.join(EXPORT_ROOT, 'Assets')] });
+    const localPaths = await walkFiles(EXPORT_ROOT, {
+        ignore: [
+            path.join(EXPORT_ROOT, 'Assets'),
+            path.join(EXPORT_ROOT, IRIS_APPS_DIR)
+        ]
+    });
     const walkTime = Date.now() - walkStart;
 
     const tagStart = Date.now();
@@ -902,6 +1045,9 @@ export const runPublish = async (options = {}) => {
             // Skip folders - they're handled separately
             if (cacheFile?.type === 'Folder') continue;
 
+            // Skip Iris apps - they're handled separately (check both type and ID prefix)
+            if (cacheFile?.type === 'IrisApp' || id.startsWith('iris-app:')) continue;
+
             // Handle static asset files
             if (cacheFile?.type === 'File') {
                 // Use lastKnownActualPath which has the correct path (e.g., "src/Assets/...")
@@ -997,6 +1143,94 @@ export const runPublish = async (options = {}) => {
         progress.completeStep('compare-code', `✓ Compared ${allIdsArray.length} code entities`);
     }
 
+    // Step 7b: Scan and compare Iris apps
+    const irisAppsPath = path.join(EXPORT_ROOT, IRIS_APPS_DIR);
+
+    // Get cached Iris apps (always check, even if local folder doesn't exist)
+    // Also include entries with iris-app: prefix in case type wasn't properly set
+    const cachedIrisApps = cachedFiles
+        .filter(cf => cf.type === 'IrisApp' || (cf.tag && cf.tag.startsWith('iris-app:')))
+        .map(cf => {
+            // Extract slug from folderName, or from the ID (iris-app:<slug>)
+            const slug = cf.folderName || (cf.tag && cf.tag.startsWith('iris-app:') ? cf.tag.replace('iris-app:', '') : null);
+            return {
+                slug,
+                appName: cf.appName || slug,
+                modifiedOn: cf.modifiedOn,
+                contentHash: cf.contentHash || null  // Track content hash for change detection
+            };
+        })
+        .filter(app => app.slug); // Filter out any entries without a valid slug
+
+    // Get local Iris apps (empty if folder doesn't exist)
+    const localIrisApps = fs.existsSync(irisAppsPath)
+        ? fs.readdirSync(irisAppsPath, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name)
+        : [];
+
+    const cachedIrisSlugs = new Set(cachedIrisApps.map(a => a.slug));
+    const localIrisSlugs = new Set(localIrisApps);
+
+    // Detect new and modified Iris apps
+    for (const slug of localIrisApps) {
+        const appPath = path.join(irisAppsPath, slug);
+
+        // Validate the app folder has required files
+        const validation = validateIrisAppFolder(appPath);
+        if (!validation.valid) {
+            if (!silent) {
+                console.log(chalk.yellow(`⚠ Skipping invalid Iris app '${slug}': ${validation.errors.join(', ')}`));
+            }
+            continue;
+        }
+
+        // Get app name from linked project config (stored globally) or use slug
+        const linkedProjects = getLinkedProjects();
+        const linkedProject = linkedProjects.find(p => p.slug === slug);
+        const appName = linkedProject?.appName || slug;
+
+        // Calculate content hash for change detection
+        const currentHash = hashIrisAppFolder(appPath);
+
+        // Check if this is a new or existing app
+        const isNew = !cachedIrisSlugs.has(slug);
+
+        if (isNew) {
+            actionQueue.push({
+                action: 'create_iris_app',
+                slug,
+                appName,
+                appPath,
+                contentHash: currentHash
+            });
+        } else {
+            // Only update if content has changed
+            const cachedApp = cachedIrisApps.find(a => a.slug === slug);
+            const contentChanged = !cachedApp?.contentHash || cachedApp.contentHash !== currentHash;
+
+            if (contentChanged) {
+                actionQueue.push({
+                    action: 'update_iris_app',
+                    slug,
+                    appName: linkedProject?.appName || cachedApp?.appName || slug,
+                    appPath,
+                    contentHash: currentHash
+                });
+            }
+        }
+    }
+
+    // Detect deleted Iris apps (works even if iris-apps folder doesn't exist)
+    for (const cachedApp of cachedIrisApps) {
+        if (!localIrisSlugs.has(cachedApp.slug)) {
+            actionQueue.push({
+                action: 'delete_iris_app',
+                slug: cachedApp.slug
+            });
+        }
+    }
+
     // Step 8: Handle brand-new, tag-less files
     if (progress) progress.startStep('prepare');
 
@@ -1077,19 +1311,28 @@ export const runPublish = async (options = {}) => {
                 const num = chalk.green(`[${i + 1}]`);
                 const act = chalk.yellow(a.action.toUpperCase());
 
-                let type, displayPath;
-                if (a.folderName) {
+                let type, displayPath, label;
+                if (a.slug) {
+                    // Iris app action
+                    type = chalk.cyan(`${a.appName || a.slug}`);
+                    displayPath = a.appPath || a.slug;
+                    label = "App";
+                } else if (a.folderName) {
                     type = chalk.cyan(a.folderName);
                     displayPath = a.folderPath;
+                    label = "Folder";
                 } else if (a.names) {
                     type = chalk.cyan(a.names.join(", "));
                     displayPath = a.folder;
+                    label = "File";
                 } else if (a.filePath) {
                     type = chalk.cyan(a.type || path.basename(a.filePath));
                     displayPath = a.filePath;
+                    label = a.type ? "Type" : "File";
                 } else {
                     type = chalk.cyan(a.type || "Unknown");
                     displayPath = a.folder || "Unknown";
+                    label = "File";
                 }
 
                 const idInfo = a.recordId ? ` ${chalk.magenta(a.recordId)}` : "";
@@ -1097,7 +1340,7 @@ export const runPublish = async (options = {}) => {
                     ? ` → ${chalk.gray(a.oldPath)} ${chalk.white("→")} ${chalk.gray(a.filePath)}`
                     : "";
 
-                console.log(`${num} ${act} | ${a.type ? "Type" : (a.folderName ? "Folder" : "File")}: ${type}${idInfo}${renameInfo} (${displayPath})`);
+                console.log(`${num} ${act} | ${label}: ${type}${idInfo}${renameInfo} (${displayPath})`);
             });
 
             console.log(chalk.blue("\n--- Publishing Changes ---"));