@magentrix-corp/magentrix-cli 1.3.16 → 1.3.17

package/utils/cli/writeRecords.js

@@ -1,262 +1,262 @@
-import { EXPORT_ROOT, TYPE_DIR_MAP } from "../../vars/global.js";
-import fs from 'fs';
-import path from "path";
-import { compareLocalAndRemote } from "../compare.js";
-import { mergeFiles } from "../merge.js";
-import Config from "../config.js";
-import chalk from "chalk";
-import { diffLines } from 'diff';
-import readlineSync from "readline-sync";
-import { updateBase } from "../updateFileBase.js";
-import { sha256 } from "../hash.js";
-import { openDiffInVSCode } from "../diff.js";
-import { tmpdir } from "os";
-import { v4 as uuidv4 } from 'uuid';
-import { findFileByTag, getFileTag, setFileTag } from "../filetag.js";
-import { decompressString } from "../compress.js";
-
-const config = new Config();
-
-/**
- * Maps an ActivePage record to its local file representation.
- * @param {Object} record - The ActivePage record from the API.
- * @returns {Object} The enriched record with 'relativePath' property.
- */
-export const mapRecordToFile = (record) => {
-    const { Type, Name, Id } = record;
-    const mapping = TYPE_DIR_MAP[Type];
-
-    if (!mapping) {
-        const errMsg = `Unrecognized type "${Type}" for record "${Name || 'UNKNOWN'}". This can be resolved in the Magentrix IDE and is likely due to a misconfiguration.`;
-        return { ...record, error: errMsg };
-    }
-
-    const safeName = Name.replace(/[<>:"/\\|?*]+/g, "_");
-    const filename = `${safeName}.${mapping.extension}`;
-
-    const foundPathByRecordId = findFileByTag(Id) || "";
-    const relativeFoundPath = foundPathByRecordId
-        ? path.join(mapping.directory, foundPathByRecordId.split(mapping.directory)[1] || "")
-        : "";
-
-    // Fix for Bug 1: If the file exists but the name doesn't match the record name, 
-    // we should treat it as a rename and use the new name.
-    let useExistingPath = false;
-    if (foundPathByRecordId) {
-        const existingName = path.basename(foundPathByRecordId);
-        // Check if existing name matches the expected filename (ignoring extension case if needed, but strict for now)
-        if (existingName === filename) {
-            useExistingPath = true;
-        }
-    }
-
-    const filePath = useExistingPath ? relativeFoundPath : path.join(mapping.directory, filename);
-
-    return {
-        ...record,
-        relativePath: filePath
-    };
-};
-
-/**
- * Writes records to disk, handling conflicts per the chosen resolution method.
- * @param {Array} records - List of entity records (ActiveClass or ActivePage)
- * @param {string} resolutionMethod - One of: "overwrite", "merge", "diff", "skip"
- * @param {Object} progress - Optional progress tracker
- * @param {Object} logger - Optional logger for warnings/errors
- */
-export const writeRecords = async (records, resolutionMethod, progress = null, logger = null) => {
-    for (let i = 0; i < records.length; i++) {
-        const record = records[i];
-        const mapping = TYPE_DIR_MAP[record.Type];
-        if (!mapping) {
-            const msg = `Skipping unknown type: ${record.Type} (record: ${record.Name})`;
-            if (logger) {
-                logger.warning(msg);
-            } else {
-                console.warn(chalk.gray(`⚠️  ${msg}`));
-            }
-            continue;
-        }
-
-        // Build output path and filename
-        const outputDir = path.join(EXPORT_ROOT, mapping.directory);
-        fs.mkdirSync(outputDir, { recursive: true }); // Ensure dir exists
-
-        const safeName = record.Name.replace(/[<>:"/\\|?*]+/g, "_");
-        const filename = `${safeName}.${mapping.extension}`;
-        const filePath = path.join(outputDir, filename);
-
-        const content = record.Content;
-        if (!content) {
-            const msg = `No content found for ${record.Name} (${record.Type}), skipping file.`;
-            if (logger) {
-                logger.warning(msg);
-            } else {
-                console.warn(`⚠️  ${msg}`);
-            }
-            continue;
-        }
-
-        // Compare local and remote to determine sync status/conflict
-        const comparison = compareLocalAndRemote(filePath, { content, ...record });
-
-        // --- Conflict Handling ---
-        let finalContent = null; // Will hold the string to write if we should write the file
-
-        if (['missing', 'in_sync'].includes(comparison.status)) {
-            // No conflict, just write server version (create if missing)
-            finalContent = content;
-        } else {
-            // Attempt to read local file (may not exist)
-            let local = "";
-
-            const base = config.read(record.Id, { global: false, filename: 'base.json' });
-            const baseContent = decompressString(base?.compressedContent) || '';
-
-            // const base = config.read(filePath);
-            try { local = fs.readFileSync(filePath, "utf8"); } catch { }
-
-            if (resolutionMethod === 'skip') {
-                // Do nothing, never create or update file
-                console.log(chalk.yellow(`⏭️  Skipped ${record.Name} (${record.Type}) due to conflict or mismatch.`));
-                continue;
-            }
-            else if (resolutionMethod === 'overwrite') {
-                // Always accept server version, creating file if missing
-                console.log(chalk.redBright(`⚠️  Overwriting local file: ${filePath} with server version.`));
-                finalContent = content;
-            }
-            else if (resolutionMethod === 'diff') {
-                // Use mergeFiles, show diff, ask user
-                let merged;
-                try {
-                    merged = mergeFiles(baseContent, local, content);
-                } catch (e) {
-                    console.log(chalk.red(`❌ Error merging: ${e.message}`));
-                    continue;
-                }
-
-                // Attempt to open the diff in vs code
-                const randomStr = (length) => Math.random().toString(36).slice(2, 2 + length);
-                const tempFileServer = path.join(tmpdir(), `${randomStr(4)}.Server${filename}`);
-                const tempFileLocal = path.join(tmpdir(), `${randomStr(4)}.Local${filename}`);
-                fs.writeFileSync(tempFileServer, content);
-                fs.writeFileSync(tempFileLocal, local);
-
-                const vsCodeDiffDisplayed = openDiffInVSCode(tempFileServer, tempFileLocal);
-
-                // If the VS Code diff failed, show in terminal
-                if (!vsCodeDiffDisplayed) {
-                    // Show diff (local vs merged)
-                    const diff = diffLines(local, merged);
-                    console.log(chalk.magenta.bold(`\n======= REVIEW MERGED for ${filename} =======`));
-                    diff.forEach(part => {
-                        const color = part.added ? 'green' :
-                            part.removed ? 'red' : 'gray';
-                        process.stdout.write(chalk[color](part.value));
-                    });
-                    console.log(chalk.magenta.bold("\n======= END REVIEW ======="));
-
-                    // Warn if there are still unresolved conflict markers
-                    if (merged.includes('<<<<<<<')) {
-                        console.log(chalk.red.bold("\n⚠️  Merge conflict markers present. Please resolve manually after accepting."));
-                    }
-                }
-
-                // Prompt user to accept or skip writing merged content
-                const choice = readlineSync.question(
-                    chalk.yellow("\nAccept merged changes and write to file? (y/n): ")
-                );
-
-                // Delete the temp files
-                fs.unlinkSync(tempFileLocal);
-                fs.unlinkSync(tempFileServer);
-
-                if (choice.trim().toLowerCase() === 'y') {
-                    finalContent = merged;
-                } else {
-                    console.log(chalk.yellow("⏭️  Skipped due to user choice."));
-                    continue;
-                }
-            }
-            else if (resolutionMethod === 'merge') {
-                // No prompt: always write merged result (may contain conflict markers)
-                let merged;
-
-                try {
-                    merged = mergeFiles(baseContent, local, content);
-                } catch (e) {
-                    console.log(chalk.red(`❌ Error merging: ${e.message}`));
-                    continue;
-                }
-                if (merged.includes('<<<<<<<')) {
-                    console.log(chalk.red.bold(`⚠️  Merge conflict markers written to ${filename}. Manual review required.`));
-                } else {
-                    console.log(chalk.green(`✔️  Merged ${filename} automatically.`));
-                }
-                finalContent = merged;
-            }
-            else {
-                // Unknown or unsupported mode (should not occur)
-                console.log(chalk.red(`❌ Unknown resolution method: ${resolutionMethod}`));
-                continue;
-            }
-        }
-
-        // --- Actually Write File (if required by resolution) ---
-        if (finalContent !== null) {
-            try {
-                // Lookup a matching file dir in our cache, in case the file was renamed
-                const cachedFilePath = findFileByTag(record.Id) || path.resolve(filePath);
-
-                // Ensure the directory exists (paranoia for deeply nested files)
-                fs.mkdirSync(path.dirname(cachedFilePath), { recursive: true });
-                fs.writeFileSync(cachedFilePath, finalContent, "utf8");
-
-                // Add a file tag so we can keep track of file changes
-                await setFileTag(cachedFilePath, record.Id);
-
-                // Set mtime/atime for reproducible syncs (optional, best effort)
-                let mtimeMs = null;
-                if (record.ModifiedOn) {
-                    mtimeMs = new Date(record.ModifiedOn).getTime();
-                } else if (record.CreatedOn) {
-                    mtimeMs = new Date(record.CreatedOn).getTime();
-                }
-                if (mtimeMs) {
-                    const mtimeSeconds = mtimeMs / 1000;
-                    try {
-                        fs.utimesSync(cachedFilePath, mtimeSeconds, mtimeSeconds);
-                    } catch (e) {
-                        const msg = `Could not set times for ${cachedFilePath}: ${e.message}`;
-                        if (logger) {
-                            logger.warning(msg);
-                        } else {
-                            console.warn(`⚠️  ${msg}`);
-                        }
-                    }
-                }
-
-
-                // If the server records content and the local files content match then we can update the base
-                if (sha256(finalContent) === sha256(record.Content)) {
-                    // We still need to use the expected filePath as the rename might be local only
-                    updateBase(filePath, record, cachedFilePath);
-                }
-            } catch (err) {
-                const msg = `Failed to write file ${filePath}: ${err.message}`;
-                if (logger) {
-                    logger.error(msg, err);
-                } else {
-                    console.error(chalk.red(`❌ ${msg}`));
-                }
-            }
-        }
-
-        // Update progress (outside try-catch so it always updates)
-        if (progress && (i % 10 === 0 || i === records.length - 1)) {
-            progress.updateProgress('write', i + 1, records.length, `Writing files...`);
-        }
-    }
-};
+import { EXPORT_ROOT, TYPE_DIR_MAP } from "../../vars/global.js";
+import fs from 'fs';
+import path from "path";
+import { compareLocalAndRemote } from "../compare.js";
+import { mergeFiles } from "../merge.js";
+import Config from "../config.js";
+import chalk from "chalk";
+import { diffLines } from 'diff';
+import readlineSync from "readline-sync";
+import { updateBase } from "../updateFileBase.js";
+import { sha256 } from "../hash.js";
+import { openDiffInVSCode } from "../diff.js";
+import { tmpdir } from "os";
+import { v4 as uuidv4 } from 'uuid';
+import { findFileByTag, getFileTag, setFileTag } from "../filetag.js";
+import { decompressString } from "../compress.js";
+
+const config = new Config();
+
+/**
+ * Maps an ActivePage record to its local file representation.
+ * @param {Object} record - The ActivePage record from the API.
+ * @returns {Object} The enriched record with 'relativePath' property.
+ */
+export const mapRecordToFile = (record) => {
+    const { Type, Name, Id } = record;
+    const mapping = TYPE_DIR_MAP[Type];
+
+    if (!mapping) {
+        const errMsg = `Unrecognized type "${Type}" for record "${Name || 'UNKNOWN'}". This can be resolved in the Magentrix IDE and is likely due to a misconfiguration.`;
+        return { ...record, error: errMsg };
+    }
+
+    const safeName = Name.replace(/[<>:"/\\|?*]+/g, "_");
+    const filename = `${safeName}.${mapping.extension}`;
+
+    const foundPathByRecordId = findFileByTag(Id) || "";
+    const relativeFoundPath = foundPathByRecordId
+        ? path.join(mapping.directory, foundPathByRecordId.split(mapping.directory)[1] || "")
+        : "";
+
+    // Fix for Bug 1: If the file exists but the name doesn't match the record name, 
+    // we should treat it as a rename and use the new name.
+    let useExistingPath = false;
+    if (foundPathByRecordId) {
+        const existingName = path.basename(foundPathByRecordId);
+        // Check if existing name matches the expected filename (ignoring extension case if needed, but strict for now)
+        if (existingName === filename) {
+            useExistingPath = true;
+        }
+    }
+
+    const filePath = useExistingPath ? relativeFoundPath : path.join(mapping.directory, filename);
+
+    return {
+        ...record,
+        relativePath: filePath
+    };
+};
+
+/**
+ * Writes records to disk, handling conflicts per the chosen resolution method.
+ * @param {Array} records - List of entity records (ActiveClass or ActivePage)
+ * @param {string} resolutionMethod - One of: "overwrite", "merge", "diff", "skip"
+ * @param {Object} progress - Optional progress tracker
+ * @param {Object} logger - Optional logger for warnings/errors
+ */
+export const writeRecords = async (records, resolutionMethod, progress = null, logger = null) => {
+    for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        const mapping = TYPE_DIR_MAP[record.Type];
+        if (!mapping) {
+            const msg = `Skipping unknown type: ${record.Type} (record: ${record.Name})`;
+            if (logger) {
+                logger.warning(msg);
+            } else {
+                console.warn(chalk.gray(`⚠️  ${msg}`));
+            }
+            continue;
+        }
+
+        // Build output path and filename
+        const outputDir = path.join(EXPORT_ROOT, mapping.directory);
+        fs.mkdirSync(outputDir, { recursive: true }); // Ensure dir exists
+
+        const safeName = record.Name.replace(/[<>:"/\\|?*]+/g, "_");
+        const filename = `${safeName}.${mapping.extension}`;
+        const filePath = path.join(outputDir, filename);
+
+        const content = record.Content;
+        if (!content) {
+            const msg = `No content found for ${record.Name} (${record.Type}), skipping file.`;
+            if (logger) {
+                logger.warning(msg);
+            } else {
+                console.warn(`⚠️  ${msg}`);
+            }
+            continue;
+        }
+
+        // Compare local and remote to determine sync status/conflict
+        const comparison = compareLocalAndRemote(filePath, { content, ...record });
+
+        // --- Conflict Handling ---
+        let finalContent = null; // Will hold the string to write if we should write the file
+
+        if (['missing', 'in_sync'].includes(comparison.status)) {
+            // No conflict, just write server version (create if missing)
+            finalContent = content;
+        } else {
+            // Attempt to read local file (may not exist)
+            let local = "";
+
+            const base = config.read(record.Id, { global: false, filename: 'base.json' });
+            const baseContent = decompressString(base?.compressedContent) || '';
+
+            // const base = config.read(filePath);
+            try { local = fs.readFileSync(filePath, "utf8"); } catch { }
+
+            if (resolutionMethod === 'skip') {
+                // Do nothing, never create or update file
+                console.log(chalk.yellow(`⏭️  Skipped ${record.Name} (${record.Type}) due to conflict or mismatch.`));
+                continue;
+            }
+            else if (resolutionMethod === 'overwrite') {
+                // Always accept server version, creating file if missing
+                console.log(chalk.redBright(`⚠️  Overwriting local file: ${filePath} with server version.`));
+                finalContent = content;
+            }
+            else if (resolutionMethod === 'diff') {
+                // Use mergeFiles, show diff, ask user
+                let merged;
+                try {
+                    merged = mergeFiles(baseContent, local, content);
+                } catch (e) {
+                    console.log(chalk.red(`❌ Error merging: ${e.message}`));
+                    continue;
+                }
+
+                // Attempt to open the diff in vs code
+                const randomStr = (length) => Math.random().toString(36).slice(2, 2 + length);
+                const tempFileServer = path.join(tmpdir(), `${randomStr(4)}.Server${filename}`);
+                const tempFileLocal = path.join(tmpdir(), `${randomStr(4)}.Local${filename}`);
+                fs.writeFileSync(tempFileServer, content);
+                fs.writeFileSync(tempFileLocal, local);
+
+                const vsCodeDiffDisplayed = openDiffInVSCode(tempFileServer, tempFileLocal);
+
+                // If the VS Code diff failed, show in terminal
+                if (!vsCodeDiffDisplayed) {
+                    // Show diff (local vs merged)
+                    const diff = diffLines(local, merged);
+                    console.log(chalk.magenta.bold(`\n======= REVIEW MERGED for ${filename} =======`));
+                    diff.forEach(part => {
+                        const color = part.added ? 'green' :
+                            part.removed ? 'red' : 'gray';
+                        process.stdout.write(chalk[color](part.value));
+                    });
+                    console.log(chalk.magenta.bold("\n======= END REVIEW ======="));
+
+                    // Warn if there are still unresolved conflict markers
+                    if (merged.includes('<<<<<<<')) {
+                        console.log(chalk.red.bold("\n⚠️  Merge conflict markers present. Please resolve manually after accepting."));
+                    }
+                }
+
+                // Prompt user to accept or skip writing merged content
+                const choice = readlineSync.question(
+                    chalk.yellow("\nAccept merged changes and write to file? (y/n): ")
+                );
+
+                // Delete the temp files
+                fs.unlinkSync(tempFileLocal);
+                fs.unlinkSync(tempFileServer);
+
+                if (choice.trim().toLowerCase() === 'y') {
+                    finalContent = merged;
+                } else {
+                    console.log(chalk.yellow("⏭️  Skipped due to user choice."));
+                    continue;
+                }
+            }
+            else if (resolutionMethod === 'merge') {
+                // No prompt: always write merged result (may contain conflict markers)
+                let merged;
+
+                try {
+                    merged = mergeFiles(baseContent, local, content);
+                } catch (e) {
+                    console.log(chalk.red(`❌ Error merging: ${e.message}`));
+                    continue;
+                }
+                if (merged.includes('<<<<<<<')) {
+                    console.log(chalk.red.bold(`⚠️  Merge conflict markers written to ${filename}. Manual review required.`));
+                } else {
+                    console.log(chalk.green(`✔️  Merged ${filename} automatically.`));
+                }
+                finalContent = merged;
+            }
+            else {
+                // Unknown or unsupported mode (should not occur)
+                console.log(chalk.red(`❌ Unknown resolution method: ${resolutionMethod}`));
+                continue;
+            }
+        }
+
+        // --- Actually Write File (if required by resolution) ---
+        if (finalContent !== null) {
+            try {
+                // Lookup a matching file dir in our cache, in case the file was renamed
+                const cachedFilePath = findFileByTag(record.Id) || path.resolve(filePath);
+
+                // Ensure the directory exists (paranoia for deeply nested files)
+                fs.mkdirSync(path.dirname(cachedFilePath), { recursive: true });
+                fs.writeFileSync(cachedFilePath, finalContent, "utf8");
+
+                // Add a file tag so we can keep track of file changes
+                await setFileTag(cachedFilePath, record.Id);
+
+                // Set mtime/atime for reproducible syncs (optional, best effort)
+                let mtimeMs = null;
+                if (record.ModifiedOn) {
+                    mtimeMs = new Date(record.ModifiedOn).getTime();
+                } else if (record.CreatedOn) {
+                    mtimeMs = new Date(record.CreatedOn).getTime();
+                }
+                if (mtimeMs) {
+                    const mtimeSeconds = mtimeMs / 1000;
+                    try {
+                        fs.utimesSync(cachedFilePath, mtimeSeconds, mtimeSeconds);
+                    } catch (e) {
+                        const msg = `Could not set times for ${cachedFilePath}: ${e.message}`;
+                        if (logger) {
+                            logger.warning(msg);
+                        } else {
+                            console.warn(`⚠️  ${msg}`);
+                        }
+                    }
+                }
+
+
+                // If the server records content and the local files content match then we can update the base
+                if (sha256(finalContent) === sha256(record.Content)) {
+                    // We still need to use the expected filePath as the rename might be local only
+                    updateBase(filePath, record, cachedFilePath);
+                }
+            } catch (err) {
+                const msg = `Failed to write file ${filePath}: ${err.message}`;
+                if (logger) {
+                    logger.error(msg, err);
+                } else {
+                    console.error(chalk.red(`❌ ${msg}`));
+                }
+            }
+        }
+
+        // Update progress (outside try-catch so it always updates)
+        if (progress && (i % 10 === 0 || i === records.length - 1)) {
+            progress.updateProgress('write', i + 1, records.length, `Writing files...`);
+        }
+    }
+};