@magentrix-corp/magentrix-cli 1.0.0

package/actions/autopublish.v2.js

@@ -0,0 +1,447 @@
+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, EXPORT_ROOT, TYPE_DIR_MAP } from '../vars/global.js';
+import fs from 'fs';
+import path from 'path';
+import { updateEntity } from '../utils/magentrix/api/updateEntity.js';
+import { createEntity } from '../utils/magentrix/api/createEntity.js';
+import { deleteEntity } from '../utils/magentrix/api/deleteEntity.js';
+import chalk from 'chalk';
+import { getFileTag, setFileTag } from '../utils/filetag.js';
+import { sha256 } from '../utils/hash.js';
+import { updateBase, removeFromBase } from '../utils/updateFileBase.js';
+import { uploadAsset, deleteAsset } from '../utils/magentrix/api/assets.js';
+
+const LOCK_FILE = path.join(process.cwd(), '.magentrix', 'autopublish.lock');
+
+let credentials = {};
+let isProcessing = false;
+let pendingChanges = new Map(); // Map of file paths to their operation types
+
+/**
+ * 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}`));
+    }
+};
+
+/**
+ * Formats multi-line errors for display
+ */
+const formatMultilineError = (err) => {
+    const lines = String(err).split(/\r?\n/);
+    return lines
+        .map((line, i) => {
+            const prefix = i === 0 ? `${chalk.redBright('  •')} ` : '    ';
+            return prefix + chalk.whiteBright(line);
+        })
+        .join('\n');
+};
+
+/**
+ * Gets the folder path from a file path relative to EXPORT_ROOT
+ */
+const getFolderFromPath = (filePath) => {
+    const fileFolderPath = filePath
+        .split("/")
+        .filter((x, i) => !(x === EXPORT_ROOT && i === 0))
+        .slice(0, -1)
+        .join("/");
+
+    return fileFolderPath;
+};
+
+/**
+ * Infers metadata from file path
+ */
+const inferMeta = (filePath) => {
+    const parentFolder = path.basename(path.dirname(filePath));
+    const type = Object.keys(TYPE_DIR_MAP).find(
+        (k) => TYPE_DIR_MAP[k].directory === parentFolder
+    );
+    return {
+        type,
+        entity: ENTITY_TYPE_MAP[type],
+        contentField: ENTITY_FIELD_MAP[type],
+    };
+};
+
+/**
+ * Safely reads file content and hash
+ */
+const readFileSafe = (filePath) => {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return { content, hash: sha256(content) };
+    } catch (err) {
+        return null;
+    }
+};
+
+/**
+ * Checks if file is within Contents/Assets (static asset)
+ */
+const isStaticAsset = (filePath) => {
+    const normalizedPath = path.normalize(filePath);
+    return normalizedPath.includes(path.join('Contents', 'Assets'));
+};
+
+/**
+ * Processes a batch of pending changes
+ */
+const processPendingChanges = async () => {
+    if (isProcessing || pendingChanges.size === 0) {
+        return;
+    }
+
+    isProcessing = true;
+
+    // Copy pending changes and clear the queue
+    const changesToProcess = new Map(pendingChanges);
+    pendingChanges.clear();
+
+    // Clear console and show header
+    process.stdout.write('\x1Bc');
+    console.log(chalk.cyan.bold('🔄 Auto-Publishing Changes...'));
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log();
+
+    const results = [];
+
+    for (const [filePath, operation] of changesToProcess.entries()) {
+        try {
+            let result;
+
+            switch (operation) {
+                case 'create':
+                    result = await handleCreate(filePath);
+                    break;
+                case 'update':
+                    result = await handleUpdate(filePath);
+                    break;
+                case 'delete':
+                    result = await handleDelete(filePath);
+                    break;
+            }
+
+            results.push({ filePath, operation, result, success: true });
+        } catch (error) {
+            results.push({ filePath, operation, error: error.message, success: false });
+        }
+    }
+
+    // Display results
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (const result of results) {
+        if (result.success) {
+            successCount++;
+            console.log(
+                chalk.green('✓') +
+                ` ${chalk.yellow(result.operation.toUpperCase())} ${chalk.cyan(path.basename(result.filePath))}`
+            );
+        } else {
+            errorCount++;
+            console.log();
+            console.log(chalk.bgRed.bold.white('  ✖ Operation Failed  '));
+            console.log(chalk.redBright('─'.repeat(48)));
+            console.log(chalk.red.bold(`${result.operation.toUpperCase()} ${result.filePath}:`));
+            console.log(formatMultilineError(result.error));
+            console.log(chalk.redBright('─'.repeat(48)));
+        }
+    }
+
+    // Summary
+    console.log();
+    console.log(chalk.gray('─'.repeat(48)));
+    if (errorCount === 0) {
+        console.log(chalk.green(`✓ ${successCount} change(s) published successfully`));
+    } else {
+        console.log(chalk.green(`✓ Successful: ${successCount}`) + ' ' + chalk.red(`✗ Failed: ${errorCount}`));
+    }
+    console.log(chalk.gray('─'.repeat(48)));
+    console.log(chalk.cyan('Watching for file changes...'));
+    console.log();
+
+    isProcessing = false;
+};
+
+/**
+ * Handles file creation
+ */
+const handleCreate = async (filePath) => {
+    // Check if this file already has a tag (created via magentrix create)
+    const existingTag = await getFileTag(filePath);
+    if (existingTag) {
+        // File was already created via CLI, treat as update instead
+        return await handleUpdate(filePath);
+    }
+
+    const safe = readFileSafe(filePath);
+    if (!safe) throw new Error('Unable to read file');
+
+    const { content, hash } = safe;
+
+    // Check if it's a static asset
+    if (isStaticAsset(filePath)) {
+        const folder = getFolderFromPath(filePath);
+        await uploadAsset(
+            credentials.instanceUrl,
+            credentials.token.value,
+            `/${folder}`,
+            [filePath]
+        );
+
+        updateBase(filePath, { Id: filePath, Type: "File" });
+        return { recordId: filePath };
+    }
+
+    // It's a code file
+    const { type, entity, contentField } = inferMeta(filePath);
+
+    const data = {
+        Name: path.basename(filePath, path.extname(filePath)),
+        Type: type,
+        [contentField]: content
+    };
+
+    const result = await createEntity(credentials.instanceUrl, credentials.token.value, entity, data);
+    const recordId = result.recordId || result.id;
+
+    // Tag the file and update base
+    await setFileTag(filePath, recordId);
+    updateBase(filePath, { Id: recordId, Type: type });
+
+    return { recordId };
+};
+
+/**
+ * Handles file updates
+ */
+const handleUpdate = async (filePath) => {
+    const safe = readFileSafe(filePath);
+    if (!safe) throw new Error('Unable to read file');
+
+    const { content, hash } = safe;
+
+    // Check if it's a static asset
+    if (isStaticAsset(filePath)) {
+        const folder = getFolderFromPath(filePath);
+        await uploadAsset(
+            credentials.instanceUrl,
+            credentials.token.value,
+            `/${folder}`,
+            [filePath]
+        );
+
+        updateBase(filePath, { Id: filePath, Type: "File" });
+        return { updated: true };
+    }
+
+    // Get file tag to find record ID
+    const recordId = await getFileTag(filePath);
+    if (!recordId) {
+        // No record ID found, treat as create
+        return await handleCreate(filePath);
+    }
+
+    const { type, entity, contentField } = inferMeta(filePath);
+
+    const data = {
+        [contentField]: content
+    };
+
+    await updateEntity(credentials.instanceUrl, credentials.token.value, entity, recordId, data);
+    updateBase(filePath, { Id: recordId, Type: type });
+
+    return { recordId };
+};
+
+/**
+ * Handles file deletion
+ */
+const handleDelete = async (filePath) => {
+    // Check if it's a static asset
+    if (isStaticAsset(filePath)) {
+        const folder = getFolderFromPath(filePath);
+        const fileName = path.basename(filePath);
+
+        await deleteAsset(
+            credentials.instanceUrl,
+            credentials.token.value,
+            `/${folder}`,
+            [fileName]
+        );
+
+        removeFromBase(filePath);
+        return { deleted: true };
+    }
+
+    // Get file tag to find record ID
+    const recordId = await getFileTag(filePath);
+    if (!recordId) {
+        // No record ID found, nothing to delete remotely
+        return { skipped: true };
+    }
+
+    const { entity } = inferMeta(filePath);
+
+    await deleteEntity(credentials.instanceUrl, credentials.token.value, entity, recordId);
+    removeFromBase(recordId);
+
+    return { recordId };
+};
+
+/**
+ * Debounce timer for batching changes
+ */
+let debounceTimer = null;
+const DEBOUNCE_DELAY = 1000; // 1 second
+
+/**
+ * Queue a file change for processing
+ */
+const queueChange = (filePath, operation) => {
+    // Normalize path
+    const normalizedPath = path.normalize(filePath);
+
+    // Skip dotfiles and the .magentrix directory
+    if (normalizedPath.includes(path.sep + '.') || normalizedPath.includes('.magentrix')) {
+        return;
+    }
+
+    // Add to pending changes
+    pendingChanges.set(normalizedPath, operation);
+
+    // Reset debounce timer
+    if (debounceTimer) {
+        clearTimeout(debounceTimer);
+    }
+
+    debounceTimer = setTimeout(() => {
+        processPendingChanges();
+    }, DEBOUNCE_DELAY);
+};
+
+/**
+ * File watcher event handlers
+ */
+const onAdd = (filePath) => {
+    queueChange(filePath, 'create');
+};
+
+const onChange = (filePath) => {
+    queueChange(filePath, 'update');
+};
+
+const onUnlink = (filePath) => {
+    queueChange(filePath, 'delete');
+};
+
+/**
+ * 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...'));
+    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();
+};