@magentrix-corp/magentrix-cli 1.2.0 → 1.2.1

package/actions/publish.js

@@ -185,8 +185,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 +214,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 +239,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 +273,80 @@ const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
     }
 };
 
+/**
+ * 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]