@magentrix-corp/magentrix-cli 1.1.1 → 1.1.3

package/actions/publish.js

@@ -165,27 +165,98 @@ const handleCreateStaticAssetAction = async (instanceUrl, apiKey, action) => {
  * Handles DELETE_STATIC_ASSET action.
  */
 const handleDeleteStaticAssetAction = async (instanceUrl, apiKey, action) => {
-    const response = await deleteAsset(instanceUrl, apiKey, `/${action.folder}`, action.names);
-    if (response?.error) throw new Error(response.error);
-    return response;
+    try {
+        const response = await deleteAsset(instanceUrl, apiKey, `/${action.folder}`, action.names);
+        return response;
+    } catch (error) {
+        // Check if this is a "not found" error
+        const errorMessage = error?.message || String(error);
+        const errorLower = errorMessage.toLowerCase();
+        const isNotFound = errorLower.includes('404') ||
+                          errorLower.includes('not found') ||
+                          errorLower.includes('item not found');
+
+        if (isNotFound) {
+            // Clean up base.json since file doesn't exist on server
+            for (const name of action.names) {
+                const filePath = action.filePath || `${EXPORT_ROOT}/${action.folder}/${name}`;
+                removeFromBase(filePath);
+            }
+            return { cleanedFromCache: true };
+        }
+
+        // Other errors should still fail
+        throw error;
+    }
 };
 
 /**
  * Handles CREATE_FOLDER action.
  */
 const handleCreateFolderAction = async (instanceUrl, apiKey, action) => {
-    const response = await createFolder(instanceUrl, apiKey, action.parentPath, action.folderName);
-    if (response?.error) throw new Error(response.error);
-    return response;
+    try {
+        const response = await createFolder(instanceUrl, apiKey, action.parentPath, action.folderName);
+        return response;
+    } catch (error) {
+        // Check if folder already exists (likely created by file upload)
+        const errorMessage = error?.message || String(error);
+        const errorLower = errorMessage.toLowerCase();
+        const alreadyExists = errorLower.includes('already exists') ||
+                             errorLower.includes('folder exists') ||
+                             errorLower.includes('duplicate');
+
+        if (alreadyExists) {
+            // Folder already exists, update cache and treat as success
+            return { alreadyExisted: true };
+        }
+
+        // Other errors should still fail
+        throw error;
+    }
 };
 
 /**
  * Handles DELETE_FOLDER action.
  */
 const handleDeleteFolderAction = async (instanceUrl, apiKey, action) => {
-    const response = await deleteAsset(instanceUrl, apiKey, action.parentPath, [action.folderName]);
-    if (response?.error) throw new Error(response.error);
-    return response;
+    try {
+        const response = await deleteAsset(instanceUrl, apiKey, action.parentPath, [action.folderName]);
+        return response;
+    } catch (error) {
+        // Check if this is a "not found" error
+        const errorMessage = error?.message || String(error);
+        const errorLower = errorMessage.toLowerCase();
+        const isNotFound = errorLower.includes('404') ||
+                          errorLower.includes('not found') ||
+                          errorLower.includes('item not found');
+
+        if (isNotFound) {
+            // Clean up base.json since folder doesn't exist on server
+            removeFromBase(action.folderPath);
+
+            // Also remove all files and subfolders inside this folder from base
+            const hits = await config.searchObject({}, { filename: "base.json", global: false });
+            const cachedResults = hits?.[0]?.value || {};
+
+            for (const [recordId, cachedEntry] of Object.entries(cachedResults)) {
+                const entryPath = cachedEntry.filePath || cachedEntry.lastKnownPath;
+                if (entryPath && typeof entryPath === 'string') {
+                    const normalizedEntryPath = path.normalize(entryPath);
+                    const normalizedFolderPath = path.normalize(action.folderPath);
+
+                    // Check if this entry is inside the deleted folder
+                    if (normalizedEntryPath.startsWith(normalizedFolderPath + path.sep)) {
+                        removeFromBase(recordId);
+                    }
+                }
+            }
+
+            return { cleanedFromCache: true };
+        }
+
+        // Other errors should still fail
+        throw error;
+    }
 };
 
 /**
@@ -227,8 +298,12 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
                 break;
 
             case "delete_static_asset":
-                for (const name of action.names) {
-                    removeFromBase(`${EXPORT_ROOT}/${action.folder}/${name}`);
+                // Skip if already cleaned from cache during 404 handling
+                if (!operationResult?.cleanedFromCache) {
+                    for (const name of action.names) {
+                        const filePath = action.filePath || `${EXPORT_ROOT}/${action.folder}/${name}`;
+                        removeFromBase(filePath);
+                    }
                 }
                 break;
 
@@ -240,9 +315,31 @@ const updateCacheAfterSuccess = async (action, operationResult) => {
                 updateBase(action.folderPath, { Id: action.folderPath, Type: "Folder" });
                 break;
 
-            case "delete_folder":
-                removeFromBase(action.folderPath);
+            case "delete_folder": {
+                // Skip if already cleaned from cache during 404 handling
+                if (!operationResult?.cleanedFromCache) {
+                    // Remove the folder itself from base
+                    removeFromBase(action.folderPath);
+
+                    // Also remove all files and subfolders inside this folder from base
+                    const hits = await config.searchObject({}, { filename: "base.json", global: false });
+                    const cachedResults = hits?.[0]?.value || {};
+
+                    for (const [recordId, cachedEntry] of Object.entries(cachedResults)) {
+                        const entryPath = cachedEntry.filePath || cachedEntry.lastKnownPath;
+                        if (entryPath && typeof entryPath === 'string') {
+                            const normalizedEntryPath = path.normalize(entryPath);
+                            const normalizedFolderPath = path.normalize(action.folderPath);
+
+                            // Check if this entry is inside the deleted folder
+                            if (normalizedEntryPath.startsWith(normalizedFolderPath + path.sep)) {
+                                removeFromBase(recordId);
+                            }
+                        }
+                    }
+                }
                 break;
+            }
         }
     } catch (error) {
         console.warn(chalk.yellow(`Warning: Failed to update cache for ${action.action}: ${error.message}`));
@@ -472,7 +569,8 @@ export const runPublish = async (options = {}) => {
                     actionQueue.push({
                         action: 'delete_static_asset',
                         folder: toApiPath(cacheFile.filePath),
-                        names: [path.basename(cacheFile.filePath)]
+                        names: [path.basename(cacheFile.filePath)],
+                        filePath: cacheFile.filePath // Store actual file path for filtering
                     });
                     continue;
                 }
@@ -578,10 +676,17 @@ export const runPublish = async (options = {}) => {
         .map(a => a.folderPath);
 
     const filteredActionQueue = actionQueue.filter(action => {
-        if (action.action === 'delete_static_asset') {
-            const fileFolder = path.join(EXPORT_ROOT, action.folder);
+        if (action.action === 'delete_static_asset' && action.filePath) {
+            // Check if this file's directory is inside any folder being deleted
+            const fileDir = path.dirname(action.filePath);
             for (const deletedFolder of foldersBeingDeleted) {
-                if (fileFolder.startsWith(deletedFolder)) {
+                // Use path.normalize to handle trailing slashes and ensure proper comparison
+                const normalizedFileDir = path.normalize(fileDir);
+                const normalizedDeletedFolder = path.normalize(deletedFolder);
+
+                // Check if file is inside the deleted folder (or is the folder itself)
+                if (normalizedFileDir === normalizedDeletedFolder ||
+                    normalizedFileDir.startsWith(normalizedDeletedFolder + path.sep)) {
                     return false; // Skip - covered by folder deletion
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magentrix-corp/magentrix-cli",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "CLI tool for synchronizing local files with Magentrix cloud platform",
   "main": "index.js",
   "type": "module",

package/utils/magentrix/api/assets.js

@@ -80,7 +80,7 @@ export const deleteAsset = async (instanceUrl, token, path = '/contents/assets',
     if (!path) throw new Error("Path is required when deleting assets.");
     if (!Array.isArray(names) || names?.length === 0) throw new Error("At least one file name is required when deleting static assets.");
 
-    let reqPath = `/api/3.0/staticassets?path=${encodeURIComponent(path)}&names=${names.join(",")}`;
+    let reqPath = `/api/3.0/staticassets?path=${encodeURIComponent(path)}&names=${names.map(name => encodeURIComponent(name)).join(",")}`;
 
     const response = await fetchMagentrix({
         instanceUrl,