@magentrix-corp/magentrix-cli 1.0.0

package/actions/autopublish.js

@@ -0,0 +1,283 @@
+import chokidar from 'chokidar';
+import { ensureValidCredentials } from '../utils/cli/helpers/ensureCredentials.js';
+import { withSpinner } from '../utils/spinner.js';
+import { EXPORT_ROOT } from '../vars/global.js';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { runPublish } from './publish.js';
+
+const LOCK_FILE = path.join(process.cwd(), '.magentrix', 'autopublish.lock');
+
+let credentials = {};
+let isProcessing = false;
+let pendingFiles = new Set(); // Track files that have changed while processing
+
+/**
+ * Creates a lock file to prevent multiple autopublish instances
+ * @returns {boolean} True if lock was acquired, false if already locked
+ */
+const acquireLock = () => {
+    try {
+        if (fs.existsSync(LOCK_FILE)) {
+            // Check if the lock is stale (process might have crashed)
+            const lockData = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+            const lockAge = Date.now() - lockData.timestamp;
+
+            // If lock is older than 1 hour, consider it stale
+            if (lockAge < 3600000) {
+                return false;
+            }
+        }
+
+        // Create lock file
+        fs.mkdirSync(path.dirname(LOCK_FILE), { recursive: true });
+        fs.writeFileSync(LOCK_FILE, JSON.stringify({
+            pid: process.pid,
+            timestamp: Date.now()
+        }));
+
+        return true;
+    } catch (err) {
+        console.error(chalk.red(`Failed to acquire lock: ${err.message}`));
+        return false;
+    }
+};
+
+/**
+ * Releases the lock file
+ */
+const releaseLock = () => {
+    try {
+        if (fs.existsSync(LOCK_FILE)) {
+            fs.unlinkSync(LOCK_FILE);
+        }
+    } catch (err) {
+        console.error(chalk.red(`Failed to release lock: ${err.message}`));
+    }
+};
+
+/**
+ * Debounce timer for batching changes
+ */
+let debounceTimer = null;
+const DEBOUNCE_DELAY = 1000; // 1 second
+
+/**
+ * Shows the current queue status by updating the header
+ */
+const showQueueStatus = () => {
+    if (pendingFiles.size > 0) {
+        // Save cursor position, move to top of screen, update queue line, restore cursor
+        process.stdout.write('\x1b[s'); // Save cursor position
+        process.stdout.write('\x1b[4;1H'); // Move to line 4, column 1
+        process.stdout.write('\x1b[2K'); // Clear entire line
+        process.stdout.write(chalk.yellow(`Queued for next publish: ${pendingFiles.size} file(s)`));
+        process.stdout.write('\x1b[u'); // Restore cursor position
+    }
+};
+
+/**
+ * Processes pending changes by running the publish command
+ */
+const processPendingChanges = async () => {
+    if (isProcessing) {
+        return;
+    }
+
+    isProcessing = true;
+
+    // Clear the pending files set and capture what we're processing
+    const filesToProcess = new Set(pendingFiles);
+    pendingFiles.clear();
+
+    // Clear console and show header
+    process.stdout.write('\x1Bc');
+    console.log(chalk.cyan.bold('🔄 Auto-Publishing Changes...'));
+    console.log(chalk.gray('─'.repeat(48)));
+
+    if (filesToProcess.size > 0) {
+        console.log(chalk.yellow(`Processing ${filesToProcess.size} file change(s):`));
+        for (const file of filesToProcess) {
+            console.log(chalk.gray(`  ${file}`));
+        }
+    }
+
+    // Reserve a line for the queue status that will be updated during processing
+    console.log(); // Empty line that will show queue status when files are added
+    console.log(); // Extra spacing
+
+    try {
+        // Run the publish logic with our pre-authenticated credentials
+        const result = await runPublish({
+            silent: false,
+            skipAuth: true,
+            credentials
+        });
+
+        // Show completion message
+        console.log();
+        console.log(chalk.gray('─'.repeat(48)));
+        if (result.hasChanges) {
+            console.log(chalk.green('✓ Changes published successfully'));
+        } else {
+            console.log(chalk.green('✓ No changes detected'));
+        }
+        console.log(chalk.gray('─'.repeat(48)));
+
+        // Show queued changes if any came in during processing
+        if (pendingFiles.size > 0) {
+            console.log(chalk.yellow(`⏳ ${pendingFiles.size} file change(s) queued for next publish:`));
+            for (const file of pendingFiles) {
+                console.log(chalk.gray(`  ${file}`));
+            }
+        } else {
+            console.log(chalk.cyan('Watching for file changes...'));
+        }
+        console.log(chalk.gray('Press Ctrl+C to stop'));
+        console.log();
+    } catch (error) {
+        console.log();
+        console.log(chalk.bgRed.bold.white('  ✖ Auto-Publish Failed  '));
+        console.log(chalk.redBright('─'.repeat(48)));
+        console.log(chalk.red(error.message));
+        console.log(chalk.redBright('─'.repeat(48)));
+
+        // Show queued changes if any
+        if (pendingFiles.size > 0) {
+            console.log(chalk.yellow(`⏳ ${pendingFiles.size} file change(s) queued for next publish`));
+        } else {
+            console.log(chalk.cyan('Watching for file changes...'));
+        }
+        console.log(chalk.gray('Press Ctrl+C to stop'));
+        console.log();
+    }
+
+    isProcessing = false;
+
+    // If changes came in while processing, start a fresh debounce timer
+    // This gives the user time to finish their edits before we publish again
+    if (pendingFiles.size > 0) {
+        // Clear any existing timer and start fresh
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+
+        debounceTimer = setTimeout(() => {
+            processPendingChanges();
+        }, DEBOUNCE_DELAY);
+    }
+};
+
+/**
+ * Queue a file change for processing
+ */
+const queueChange = (filePath, operation) => {
+    const relativePath = path.relative(process.cwd(), filePath);
+    const displayPath = `${operation} ${relativePath}`;
+
+    // Add to pending files
+    pendingFiles.add(displayPath);
+
+    // Update queue display if currently processing
+    if (isProcessing) {
+        showQueueStatus();
+        // Don't start timer yet - wait for current batch to complete
+        return;
+    }
+
+    // Not currently processing - start/reset the debounce timer
+    // Each new change resets the timer, ensuring we wait for editing to stop
+    if (debounceTimer) {
+        clearTimeout(debounceTimer);
+    }
+
+    debounceTimer = setTimeout(() => {
+        processPendingChanges();
+    }, DEBOUNCE_DELAY);
+};
+
+/**
+ * File watcher event handlers
+ */
+const onAdd = (filePath) => {
+    queueChange(filePath, '[+]');
+};
+
+const onChange = (filePath) => {
+    queueChange(filePath, '[~]');
+};
+
+const onUnlink = (filePath) => {
+    queueChange(filePath, '[-]');
+};
+
+/**
+ * Starts the file watcher
+ */
+const startWatcher = () => {
+    console.log(chalk.cyan.bold('🔄 Auto-Publish Mode Activated'));
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log(chalk.green('Watching for file changes in:'));
+    console.log(chalk.cyan(`  ${path.join(process.cwd(), EXPORT_ROOT)}`));
+    console.log(chalk.gray('Press Ctrl+C to stop'));
+    console.log();
+
+    const watchPath = path.join(process.cwd(), EXPORT_ROOT);
+
+    const watcher = chokidar.watch(watchPath, {
+        ignored: /(^|[\/\\])\../, // Ignore dotfiles
+        persistent: true,
+        ignoreInitial: true, // Don't fire events for existing files
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100
+        }
+    });
+
+    watcher
+        .on('add', onAdd)
+        .on('change', onChange)
+        .on('unlink', onUnlink);
+
+    // Handle cleanup on exit
+    const cleanup = () => {
+        console.log(chalk.yellow('\n\nStopping auto-publish...'));
+        watcher.close();
+        releaseLock();
+        process.exit(0);
+    };
+
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+};
+
+/**
+ * Main autopublish function
+ */
+export const autoPublish = async () => {
+    process.stdout.write('\x1Bc');
+
+    // Check for existing lock
+    if (!acquireLock()) {
+        console.log(chalk.bgRed.bold.white('  ✖ Already Running  '));
+        console.log(chalk.redBright('─'.repeat(48)));
+        console.log(chalk.red('Another instance of autopublish is already running.'));
+        console.log(chalk.gray('Only one autopublish instance can run at a time.'));
+        console.log(chalk.redBright('─'.repeat(48)));
+        console.log();
+        console.log(chalk.yellow('If you believe this is an error, delete the lock file:'));
+        console.log(chalk.cyan(LOCK_FILE));
+        process.exit(1);
+    }
+
+    // Authenticate
+    credentials = await withSpinner('Authenticating...', async () => {
+        return await ensureValidCredentials();
+    });
+
+    console.log();
+
+    // Start watching
+    startWatcher();
+};

package/actions/autopublish.old.js

@@ -0,0 +1,293 @@
+import chokidar from 'chokidar';
+import { ensureValidCredentials } from '../utils/cli/helpers/ensureCredentials.js';
+import { withSpinner } from '../utils/spinner.js';
+import { ENTITY_FIELD_MAP, ENTITY_TYPE_MAP, TYPE_DIR_MAP } from '../vars/global.js';
+import fs from 'fs';
+import Config from '../utils/config.js';
+import { updateEntity } from '../utils/magentrix/api/updateEntity.js';
+import chalk from 'chalk';
+import { deleteEntity } from '../utils/magentrix/api/deleteEntity.js';
+import { decompressString } from '../utils/compress.js';
+
+const config = new Config();
+
+let credentials = {};
+let isUpdating = null;
+let alreadyWarned = false;
+
+/**
+ * Handler for file creation events.
+ * Triggered when a new file is added to the watched directory.
+ *
+ * @async
+ * @function onAdd
+ * @param {string} path - The path of the newly added file.
+ */
+const onAdd = async (path) => {
+    // TODO: Ensure it doesn't try and create a file that has already been created using CLI
+    // TODO: Handle file addition logic (e.g., queue for remote sync)
+    // console.log(`[+] File created: ${path}`);
+
+    const pathParts = path.split("\\");
+    const acceptedTypes = Object.keys(TYPE_DIR_MAP).map(key => TYPE_DIR_MAP[key].directory);
+    const fileName = pathParts[pathParts.length - 1];
+    const name = fileName.split(".")[0];
+
+    const fileContent = fs.readFileSync(path, 'utf-8');
+
+    let pathType = null;
+
+    for (const part of pathParts) {
+        if (acceptedTypes.includes(part)) {
+            pathType = part;
+        }
+    }
+
+    let formattedData;
+
+    if (['Classes', 'Trigger', 'Controllers'].includes(pathType)) {
+        formattedData = {
+            Name: name,
+            Body: fileContent,
+            Description: "",
+            Type: ({
+                "Classes": "Class",
+                "Triggers": "Trigger",
+                "Controllers": "Controller"
+            })[pathType]
+        };
+    } else if (['Templates', 'Pages'].includes(pathType)) {
+        formattedData = {
+            Name: name,
+            Content: fileContent,
+            Description: "",
+            Type: "Active Page"
+        };
+    }
+
+    console.log(formattedData)
+    // Uncomment to perform creation via API:
+    // const creationResponse = await withSpinner('Creating file...', async () => {
+    //     return await createEntity(credentials.instanceUrl, credentials.token.value, entityType, formattedData);
+    // });
+};
+
+/**
+ * Handler for file modification events.
+ * Triggered when an existing file is changed.
+ *
+ * @async
+ * @function onChange
+ * @param {string} path - The path of the modified file.
+ */
+const onChange = async (path) => {
+    if (isUpdating) {
+        if (!alreadyWarned) {
+            process.stdout.write(chalk.yellow('\r⚠  File is currently compiling. Please wait...\n'));
+            alreadyWarned = true;
+        }
+        return;
+    }
+
+    alreadyWarned = false;
+
+    const fileDataQuery = config.searchObject({ filePath: path }, { global: false, filename: 'base.json' });
+    const fileData = fileDataQuery?.[0];
+    if (!fileData) {
+        // No file found in the base index, no action needed here
+        return;
+    }
+
+    process.stdout.write('\x1Bc'); // Clear the console
+    console.log('🔄 Watching for file changes... Any edits will be detected and queued for remote update.');
+    console.log();
+
+    const recordId = fileData.value.recordId;
+    const fileType = fileData.value.type;
+    const fileContents = fs.readFileSync(path, 'utf-8');
+
+    const updateField = ENTITY_FIELD_MAP[fileType];
+    const entityName = ENTITY_TYPE_MAP[fileType];
+
+    const updateBody = {
+        Id: recordId,
+        [updateField]: fileContents
+    }
+
+    isUpdating = true;
+    const response = await withSpinner(chalk.gray(`Compiling ${path}...`), async () => {
+        return await updateEntity(
+            credentials.instanceUrl,
+            credentials.token.value,
+            entityName,
+            recordId,
+            updateBody
+        ).catch(err => {
+            return { ...err, hasErrors: true }
+        });
+    });
+    isUpdating = false;
+
+    if (response?.hasErrors) {
+        const err = response;
+
+        // Clear line and provide an error heading
+        console.log();
+        console.log(chalk.bgRed.bold.white('  ✖ Magentrix API Error  '));
+        console.log(chalk.redBright('─'.repeat(48)));
+
+        if (err.response && Array.isArray(err.response.errors)) {
+            const errors = err.response.errors;
+            console.log(
+                chalk.red.bold(
+                    `Found ${errors.length} error${errors.length !== 1 ? 's' : ''}:`
+                )
+            );
+            errors.forEach((error, idx) => {
+                // Show error status (if available), code, and message, all prettified
+                const code = error.code ? chalk.gray(`[${error.code}] `) : '';
+                const status = error.status ? chalk.yellow(`[${error.status}] `) : '';
+                const msg = chalk.whiteBright(error.message);
+                console.log(
+                    `${chalk.redBright('  •')} ${status}${code}${msg}`
+                );
+            });
+        } else if (err.response && err.response.message) {
+            // Single message fallback
+            console.log(chalk.red('  • ') + chalk.whiteBright(err.response.message));
+        } else if (err.message) {
+            // Any unexpected error
+            console.log(chalk.red('  • ') + chalk.whiteBright(err.message));
+        } else {
+            console.log(chalk.red('  • ') + chalk.whiteBright('An unexpected error has occurred.'));
+        }
+
+        console.log(chalk.redBright('─'.repeat(48)));
+    } else {
+        // Clean, celebratory message!
+        console.log();
+        console.log(
+            chalk.bgGreen.bold.white('  ✔ File Compiled & Saved!  ')
+        );
+        console.log(chalk.greenBright('─'.repeat(48)));
+        console.log(
+            chalk.greenBright.bold('Your file was compiled and saved on the remote Magentrix server.')
+        );
+        // Optionally: include file info or extra details if available
+        if (response.fileName) {
+            console.log(chalk.whiteBright(`File: ${chalk.cyan(response.fileName)}`));
+        }
+        if (response.lastModified) {
+            console.log(
+                chalk.gray(`Last Modified: ${new Date(response.lastModified).toLocaleString()}`)
+            );
+        }
+        if (response.recordId) {
+            console.log(chalk.gray(`Record ID: ${chalk.yellow(response.recordId)}`));
+        }
+        // Add spacing and line
+        console.log(chalk.greenBright('─'.repeat(48)));
+        console.log();
+    }
+};
+
+/**
+ * Handler for file deletion events.
+ * Triggered when a file is removed from the watched directory.
+ *
+ * @async
+ * @function onUnlink
+ * @param {string} path - The path of the deleted file.
+ */
+const onUnlink = async (path) => {
+    process.stdout.write('\x1Bc'); // Clear the console
+    console.log('🔄 Watching for file changes... Any edits will be detected and queued for remote update.');
+    console.log();
+
+    const fileDataQuery = config.searchObject({ filePath: path }, { global: false, filename: 'base.json' });
+    const fileData = fileDataQuery?.[0];
+    if (!fileData) {
+        console.log(chalk.gray(`⚠️ File removed, but not found in index: ${path}`));
+        return;
+    }
+
+    const recordId = fileData.value.recordId;
+    const fileType = fileData.value.type;
+    const entityName = ENTITY_TYPE_MAP[fileType];
+
+    const response = await withSpinner(`🗑️  Deleting remote ${entityName} for: ${path}`, async () => {
+        return await deleteEntity(
+            credentials.instanceUrl,
+            credentials.token.value,
+            entityName,
+            recordId
+        ).catch(err => {
+            return { ...err?.response, hasErrors: true };
+        });
+    });
+
+    if (response?.hasErrors) {
+        try {
+            // Put the file back with the last synced content
+            const lastContent = decompressString(fileData.value.compressedContent);
+            fs.writeFileSync(path, lastContent);
+        } catch (err) {
+            console.warn(`⚠️  Failed to restore deleted file at "${path}". Reason: ${err.message}`);
+        }
+    }
+
+    if (response?.success) {
+        console.log(chalk.green.bold(`✔ Successfully deleted remote ${entityName} for:`), chalk.whiteBright(path));
+    } else if (response?.hasErrors || response?.errors?.length > 0) {
+        console.log();
+        console.log(chalk.bgRed.bold.white('  ✖ Deletion Failed  '));
+        console.log(chalk.redBright('─'.repeat(48)));
+        const errors = response.errors || [];
+        if (errors.length > 0) {
+            errors.forEach((err, i) => {
+                const code = err.code ? chalk.gray(`[${err.code}] `) : '';
+                const status = err.status ? chalk.yellow(`[${err.status}] `) : '';
+                const msg = chalk.whiteBright(err.message);
+                console.log(`${chalk.redBright('  •')} ${status}${code}${msg}`);
+            });
+        } else {
+            console.log(chalk.red('An unknown error occurred during deletion.'));
+        }
+    } else {
+        console.log(chalk.yellow(`⚠️ Unexpected response while deleting: ${path}`));
+    }
+};
+
+const startWatcher = () => {
+    console.log('🔄 Watching for file changes... Any edits will be detected and queued for remote update.');
+    console.log();
+
+    const watcher = chokidar.watch('.', {
+        ignored: /(^|[\/\\])\../, // Ignore dotfiles and .git etc.
+        persistent: true,
+        ignoreInitial: true // Don't fire events for files already present
+    });
+
+    watcher
+        .on('add', onAdd)
+        .on('change', onChange)
+        .on('unlink', onUnlink);
+}
+
+/**
+ * Initializes and starts the file watcher for Magentrix CLI.
+ * Watches the current directory for file changes (add, change, unlink)
+ * and triggers remote sync as needed.
+ *
+ * @function watch
+ * @returns {void}
+ */
+export const autoPublish = async () => {
+    process.stdout.write('\x1Bc'); // Clear the console
+
+    credentials = await withSpinner('Authenticating...', async () => {
+        return await ensureValidCredentials();
+    });
+
+    startWatcher();
+};