@magentrix-corp/magentrix-cli 1.0.0

package/actions/publish.js

@@ -0,0 +1,567 @@
+import { walkFiles } from "../utils/cacher.js";
+import { ensureValidCredentials } from "../utils/cli/helpers/ensureCredentials.js";
+import Config from "../utils/config.js";
+import { withSpinner } from "../utils/spinner.js";
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import {
+    ENTITY_FIELD_MAP,
+    ENTITY_TYPE_MAP,
+    EXPORT_ROOT,
+    TYPE_DIR_MAP,
+} from "../vars/global.js";
+import {
+    getFileTag,
+} from "../utils/filetag.js";
+import { sha256 } from "../utils/hash.js";
+import { createEntity } from "../utils/magentrix/api/createEntity.js";
+import { updateEntity } from "../utils/magentrix/api/updateEntity.js";
+import { deleteEntity } from "../utils/magentrix/api/deleteEntity.js";
+import { setFileTag } from "../utils/filetag.js";
+import { removeFromBase, updateBase } from "../utils/updateFileBase.js";
+import { deleteAsset, uploadAsset } from "../utils/magentrix/api/assets.js";
+import { decompressString } from "../utils/compress.js";
+
+const config = new Config();
+
+/* ---------- Helper utilities ---------- */
+
+/**
+ * Given a file path, return { type, entity, contentField } for Magentrix.
+ */
+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 read file content and hash; returns null on failure.
+ */
+const readFileSafe = (filePath) => {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return { content, hash: sha256(content) };
+    } catch (err) {
+        console.error(
+            chalk.red.bold("Error:") +
+            " Unable to read file " +
+            chalk.white.bold(filePath)
+        );
+        console.error(
+            chalk.gray("→ Please verify the file exists and you have read permissions.")
+        );
+        return null;
+    }
+};
+
+const formatMultilineError = (err) => {
+    // Ensure it's a string and split into lines
+    const lines = String(err).split(/\r?\n/);
+    // First line gets the bullet, rest get indentation
+    return lines
+        .map((line, i) => {
+            const prefix = i === 0 ? `${chalk.redBright('  •')} ` : '    '; // 4 spaces indent
+            return prefix + chalk.whiteBright(line);
+        })
+        .join('\n');
+};
+
+const getFolderFromPath = (filePath) => {
+    const fileFolderPath = filePath
+        .split("/")
+        .filter((x, i) => !(x === EXPORT_ROOT && i === 0))
+        .slice(0, -1)
+        .join("/");
+
+    return fileFolderPath;
+}
+
+/* ---------- Network operations ---------- */
+
+/**
+ * Executes all actions in the queue in parallel and handles results/errors.
+ * Updates cache after successful operations.
+ */
+const performNetworkRequest = async (actionQueue) => {
+    const { instanceUrl, token } = await ensureValidCredentials();
+
+    // Execute all operations in parallel
+    const results = await Promise.allSettled(
+        actionQueue.map(async (action, index) => {
+            try {
+                let result;
+                switch (action.action) {
+                    case "create":
+                        result = await handleCreateAction(instanceUrl, token.value, action);
+                        break;
+                    case "update":
+                        result = await handleUpdateAction(instanceUrl, token.value, action);
+                        break;
+                    case "delete":
+                        result = await handleDeleteAction(instanceUrl, token.value, action);
+                        break;
+                    case "create_static_asset":
+                        result = await handleCreateStaticAssetAction(instanceUrl, token.value, action);
+                        break;
+                    case "delete_static_asset":
+                        result = await handleDeleteStaticAssetAction(instanceUrl, token.value, action);
+                        break;
+                    default:
+                        throw new Error(`Unknown action: ${action.action}`);
+                }
+                return { index, action, result, success: true };
+            } catch (error) {
+                return { index, action, error: error.message, success: false };
+            }
+        })
+    );
+
+    // Process results
+    let successCount = 0;
+    let errorCount = 0;
+    const errors = [];
+
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            const { index, action, success, error, result: operationResult } = result.value;
+            if (success) {
+                successCount++;
+                console.log(
+                    chalk.green(`✓ [${index + 1}]`) +
+                    ` ${chalk.yellow(action.action.toUpperCase())} ${chalk.cyan(action.type || action?.names?.join(", ") || path.basename(action.filePath) || '')} ` +
+                    (operationResult?.recordId ? chalk.magenta(operationResult.recordId) : "")
+                );
+
+                // Update cache and file tags after successful operations
+                await updateCacheAfterSuccess(action, operationResult);
+            } else {
+                errorCount++;
+                errors.push({ index: index + 1, action, error });
+
+                // Enhanced error display matching autopublish.js style
+                console.log();
+                console.log(chalk.bgRed.bold.white('  ✖ Operation Failed  '));
+                console.log(chalk.redBright('─'.repeat(48)));
+                console.log(
+                    chalk.red.bold(`[${index + 1}] ${action.action.toUpperCase()} ${action.type || action?.names?.join(", ") || ''} (${action.filePath || action.folder}):`)
+                );
+                // console.log(`${chalk.redBright('  •')} ${chalk.whiteBright(error)}`);
+                console.log(formatMultilineError(error));
+                console.log(chalk.redBright('─'.repeat(48)));
+            }
+        } else {
+            // Promise rejection (shouldn't happen with allSettled, but just in case)
+            errorCount++;
+            console.log();
+            console.log(chalk.bgRed.bold.white('  ✖ Unexpected Error  '));
+            console.log(chalk.redBright('─'.repeat(48)));
+            console.log(`${chalk.redBright('  •')} ${chalk.whiteBright(result.reason)}`);
+            console.log(chalk.redBright('─'.repeat(48)));
+        }
+    }
+
+    // Summary
+    console.log(chalk.blue("\n--- Publish Summary ---"));
+    console.log(chalk.green(`✓ Successful: ${successCount}`));
+    if (errorCount > 0) {
+        console.log(chalk.red(`✗ Failed: ${errorCount}`));
+        // console.log(chalk.yellow("\nErrors encountered:"));
+        // errors.forEach(({ index, action, error }) => {
+        //     console.log(`  [${index}] ${action.action.toUpperCase()} ${action.type}: ${error}`);
+        // });
+    } else {
+        console.log(chalk.green("All operations completed successfully! 🎉"));
+    }
+};
+
+const handleCreateStaticAssetAction = async (instanceUrl, apiKey, action) => {
+    const r = await uploadAsset(
+        instanceUrl,
+        apiKey,
+        `/${action.folder}`,
+        [action.filePath]
+    ).catch(err => ({ error: err.message }));
+    if (r?.error) throw new Error(r.error);
+    return r;
+}
+
+const handleDeleteStaticAssetAction = async (instanceUrl, apiKey, action) => {
+    const response = await deleteAsset(instanceUrl, apiKey, `/${action.folder}`, action.names).catch(err => ({ error: err.message }));
+    if (response?.error) throw new Error(response.error);
+    return response;
+}
+
+/**
+ * Handle create action
+ */
+const handleCreateAction = async (instanceUrl, apiKey, action) => {
+    const data = {
+        Name: path.basename(action.filePath, path.extname(action.filePath)),
+        Type: action.type,
+        ...action.fields
+    };
+
+    const result = await createEntity(instanceUrl, apiKey, action.entity, data);
+    return { recordId: result.recordId || result.id };
+};
+
+/**
+ * Handle update action
+ */
+const handleUpdateAction = async (instanceUrl, apiKey, action) => {
+    const data = {
+        ...action.fields
+    };
+
+    // If renamed, update the Name field
+    if (action.renamed) {
+        data.Name = path.basename(action.filePath, path.extname(action.filePath));
+    }
+
+    const result = await updateEntity(instanceUrl, apiKey, action.entity, action.recordId, data);
+    return { recordId: action.recordId };
+};
+
+/**
+ * Handle delete action
+ */
+const handleDeleteAction = async (instanceUrl, apiKey, action) => {
+    const r = await deleteEntity(instanceUrl, apiKey, action.entity, action.recordId);
+    return r;
+};
+
+/**
+ * Update cache and file tags after successful operations
+ */
+const updateCacheAfterSuccess = async (action, operationResult) => {
+    try {
+        switch (action.action) {
+            case "create":
+                // Tag the file and update base with the content that was actually published
+                const createSnapshot = action.fields && Object.values(action.fields)[0]
+                    ? { content: Object.values(action.fields)[0], hash: action.contentHash }
+                    : null;
+                await setFileTag(action.filePath, operationResult.recordId);
+                updateBase(
+                    action.filePath,
+                    { Id: operationResult.recordId, Type: action.type },
+                    '',
+                    createSnapshot
+                );
+                break;
+
+            case "update":
+                // Pass the content snapshot that was actually published to prevent race conditions
+                const updateSnapshot = action.fields && Object.values(action.fields)[0]
+                    ? { content: Object.values(action.fields)[0], hash: sha256(Object.values(action.fields)[0]) }
+                    : null;
+                updateBase(
+                    action.filePath,
+                    { Id: action.recordId, Type: Object.keys(ENTITY_TYPE_MAP).find(key => ENTITY_TYPE_MAP[key] === action.entity) },
+                    '',
+                    updateSnapshot
+                );
+                break;
+
+            case "delete":
+                removeFromBase(action.recordId);
+                break;
+
+            case "delete_static_asset":
+                for (const name of action.names) {
+                    removeFromBase(`${EXPORT_ROOT}/${action.folder}/${name}`);
+                }
+                break;
+
+            case "create_static_asset":
+                updateBase(action.filePath, { Id: action.filePath, Type: "File" });
+                break;
+        }
+    } catch (error) {
+        console.warn(chalk.yellow(`Warning: Failed to update cache for ${action.action}: ${error.message}`));
+    }
+};
+
+/* ---------- Main publish routine ---------- */
+
+/**
+ * Core publish logic - can be called from autopublish or directly
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.silent - If true, suppress summary output
+ * @param {boolean} options.skipAuth - If true, skip authentication (caller handles it)
+ * @param {Object} options.credentials - Pre-authenticated credentials {instanceUrl, token}
+ * @returns {Promise<{actionQueue: Array, results: Object}>}
+ */
+export const runPublish = async (options = {}) => {
+    const { silent = false, skipAuth = false, credentials = null } = options;
+
+    /* 1 — Authenticate (unless skipped) */
+    let authCreds;
+    if (skipAuth && credentials) {
+        authCreds = credentials;
+    } else {
+        authCreds = await ensureValidCredentials().catch((err) => {
+            if (!silent) {
+                console.error(
+                    chalk.red.bold("Authentication failed:"),
+                    chalk.white(err.message)
+                );
+            }
+            throw err;
+        });
+    }
+
+    /* 2 — Load previous cache */
+    const hits = await config.searchObject({}, { filename: "base.json", global: false });
+    const cachedResults = hits?.[0]?.value || {};
+
+    if (!Object.keys(cachedResults).length) {
+        if (!silent) {
+            console.log(chalk.red.bold("No file cache found!"));
+            console.log(
+                `Run ${chalk.cyan("magentrix pull")} to initialize your workspace.`
+            );
+        }
+        throw new Error("No file cache found");
+    }
+
+    const cachedFiles = Object.values(cachedResults).map((c) => ({
+        ...c,
+        tag: c.recordId,
+    }));
+
+    /* 3 — Scan current local workspace */
+    const localPaths = await walkFiles(EXPORT_ROOT, { ignore: [path.join(EXPORT_ROOT, 'Contents')] });
+    const localFiles = await Promise.all(
+        localPaths.map(async (p) => {
+            try {
+                const tag = await getFileTag(p);
+                return { tag, path: p };
+            } catch {
+                // console.log(
+                //     chalk.yellow(
+                //         `Warning: Could not retrieve tag for ${p}. Treating as new file.`
+                //     )
+                // );
+                return { tag: null, path: p };
+            }
+        })
+    );
+
+    /* 4 — Fast lookup maps */
+    const cacheById = Object.fromEntries(
+        cachedFiles.map((c) => [c.tag, c])
+    );
+    const localById = Object.fromEntries(
+        localFiles.filter((f) => f.tag).map((f) => [f.tag, f])
+    );
+    const newLocalNoId = localFiles.filter((f) => !f.tag);
+
+    /* 5 — Determine action per recordId */
+    const allIds = new Set([
+        ...Object.keys(cacheById),
+        ...Object.keys(localById),
+    ]);
+    const actionQueue = [];
+
+    // HANDLE ASSET CREATION SEPERATELY
+    const assetPaths = await walkFiles(path.join(EXPORT_ROOT, 'Contents/Assets'));
+    for (const assetPath of assetPaths) {
+        // The file is already being handled in the next part
+        if (cachedFiles.find(cr => cr.filePath.toLowerCase() === assetPath.toLowerCase())) {
+            continue;
+        }
+
+        const fileFolderPath = getFolderFromPath(assetPath);
+
+        actionQueue.push({
+            action: "create_static_asset",
+            folder: fileFolderPath,
+            filePath: assetPath
+        });
+    }
+
+    for (const id of allIds) {
+        try {
+            const cacheFile = cacheById[id];
+            const curFile = localById[id];
+
+            // This is an asset so it needs to be treated differently
+            // Assets only have CREATE & DELETE & UPDATE actions no rename, if a files content is changed just reupload it essentially.
+            // We may have to explore the option of listing all the files from the server first and validating against those instead of the cache
+            if (cacheFile.type === 'File') {
+                const localAssetExists = fs.existsSync(cacheFile.filePath);
+
+                // DELETE
+                if (!localAssetExists) {
+                    actionQueue.push({
+                        action: 'delete_static_asset',
+                        folder: getFolderFromPath(cacheFile.filePath),
+                        names: [path.basename(cacheFile.filePath)]
+                    });
+
+                    continue;
+                }
+
+                // UPDATE
+                const contentHash = sha256(fs.readFileSync(cacheFile.filePath, 'utf-8'));
+                if (contentHash !== cacheFile.contentHash) {
+                    // This can be handled as a file creation since the Magentrix Upload API will just overwrite the file
+                    actionQueue.push({
+                        aliasAction: 'update_static_asset',
+                        action: "create_static_asset",
+                        folder: getFolderFromPath(cacheFile.filePath),
+                        filePath: cacheFile.filePath
+                    });
+                }
+
+                continue;
+            }
+
+            /* DELETE */
+            if (cacheFile && !curFile) {
+                const { type, entity } = inferMeta(cacheFile.lastKnownPath);
+                actionQueue.push({
+                    action: "delete",
+                    recordId: id,
+                    filePath: cacheFile.lastKnownPath,
+                    type,
+                    entity,
+                });
+                continue;
+            }
+
+            /* CREATE */
+            if (!cacheFile && curFile) {
+                const safe = readFileSafe(curFile.path);
+                if (!safe) continue;
+                const { content, hash } = safe;
+                const { type, entity, contentField } = inferMeta(curFile.path);
+                actionQueue.push({
+                    action: "create",
+                    filePath: curFile.path,
+                    recordId: id || null,
+                    type,
+                    entity,
+                    fields: { [contentField]: content },
+                    contentHash: hash,
+                });
+                continue;
+            }
+
+            /* UPDATE */
+            if (cacheFile && curFile) {
+                const safe = readFileSafe(curFile.path);
+                if (!safe) continue;
+                const { content, hash } = safe;
+
+                const renamed = cacheFile.lastKnownPath !== path.resolve(curFile.path);
+                const contentChanged = hash !== cacheFile.contentHash;
+                if (renamed || contentChanged) {
+                    const { type, entity, contentField } = inferMeta(curFile.path);
+                    actionQueue.push({
+                        action: "update",
+                        recordId: id,
+                        type,
+                        entity,
+                        fields: { [contentField]: content },
+                        renamed,
+                        oldPath: cacheFile.lastKnownPath,
+                        filePath: curFile.path,
+                    });
+                }
+            }
+        } catch (err) {
+            console.log(err)
+        }
+    }
+
+    /* 6 — Handle brand-new, tag-less files */
+    for (const f of newLocalNoId) {
+        const safe = readFileSafe(f.path);
+        if (!safe) {
+            console.log(
+                chalk.yellow(`Skipping unreadable file: ${f.path}`)
+            );
+            continue;
+        }
+        const { content, hash } = safe;
+        const { type, entity, contentField } = inferMeta(f.path);
+        actionQueue.push({
+            action: "create",
+            recordId: null,
+            type,
+            entity,
+            fields: { [contentField]: content },
+            contentHash: hash,
+        });
+    }
+
+    /* 7 — Summary and execution */
+    if (!silent) {
+        console.log(chalk.blue("\n--- Publish Action Queue ---"));
+        if (!actionQueue.length) {
+            console.log(
+                chalk.green("All files are in sync — nothing to publish!")
+            );
+        } else {
+            actionQueue.forEach((a, i) => {
+                const num = chalk.green(`[${i + 1}]`);
+                const act = chalk.yellow(a.action.toUpperCase());
+                const type = chalk.cyan(a.type || a?.names?.join(", ") || path.basename(a.filePath));
+                const idInfo = a.recordId ? ` ${chalk.magenta(a.recordId)}` : "";
+                const renameInfo = a.renamed
+                    ? ` → ${chalk.gray(a.oldPath)} ${chalk.white("→")} ${chalk.gray(a.filePath)}`
+                    : "";
+
+                console.log(`${num} ${act} | ${a.type ? "Type" : "File"}: ${type}${idInfo}${renameInfo} (${a.filePath || a.folder})`);
+            });
+
+            console.log(chalk.blue("\n--- Publishing Changes ---"));
+        }
+    }
+
+    // Execute the action queue if there are changes
+    if (actionQueue.length > 0) {
+        if (silent) {
+            await performNetworkRequest(actionQueue);
+        } else {
+            await withSpinner(
+                "Working...",
+                async () => {
+                    await performNetworkRequest(actionQueue)
+                },
+                {
+                    showCompletion: false
+                }
+            );
+        }
+    }
+
+    return {
+        actionQueue,
+        hasChanges: actionQueue.length > 0
+    };
+};
+
+/**
+ * CLI command wrapper for publish
+ */
+export const publish = async () => {
+    process.stdout.write("\x1Bc"); // clear console
+
+    try {
+        await runPublish({ silent: false });
+    } catch (err) {
+        console.error(chalk.red.bold("Publish failed:"), err.message);
+        process.exit(1);
+    }
+};

package/actions/pull.js

@@ -0,0 +1,139 @@
+import { ensureValidCredentials } from "../utils/cli/helpers/ensureCredentials.js";
+import Config from "../utils/config.js";
+import { meqlQuery } from "../utils/magentrix/api/meqlQuery.js";
+import fs from "fs";
+import { withSpinner } from "../utils/spinner.js";
+import { EXPORT_ROOT, TYPE_DIR_MAP } from "../vars/global.js";
+import { mapRecordToFile, writeRecords } from "../utils/cli/writeRecords.js";
+import { updateBase } from "../utils/updateFileBase.js";
+import { compareAllFilesAndLogStatus, promptConflictResolution, showCurrentConflicts } from "../utils/cli/helpers/compare.js";
+import path from "path";
+import { compareLocalAndRemote } from "../utils/compare.js";
+import chalk from 'chalk';
+import { getFileTag } from "../utils/filetag.js";
+import { downloadAssetsZip, listAssets } from "../utils/magentrix/api/assets.js";
+import { downloadAssets, walkAssets } from "../utils/downloadAssets.js";
+import { v4 as uuidv4 } from 'uuid';
+
+const config = new Config();
+
+/**
+ * Pulls all ActiveClass and ActivePage records from Magentrix, 
+ * saving them to categorized local directories with appropriate extensions.
+ *
+ * Output Structure:
+ *   /test/
+ *     Controllers/
+ *     Triggers/
+ *     Classes/
+ *     Pages/
+ *       <Name>.<ext>
+ *
+ * @async
+ * @function pull
+ * @returns {Promise<void>}
+ */
+export const pull = async () => {
+    // Step 1: Authenticate and retrieve instance URL and token
+    const { instanceUrl, token } = await withSpinner('Authenticating...', async () => {
+        return await ensureValidCredentials();
+    });
+
+    // Clear the terminal
+    process.stdout.write('\x1Bc');
+
+    // Step 2: Prepare queries for both ActiveClass and ActivePage
+    const queries = [
+        {
+            name: "ActiveClass",
+            query: "SELECT Id,Body,Name,CreatedOn,Description,ModifiedOn,Type FROM ActiveClass",
+            contentField: "Body",
+        },
+        {
+            name: "ActivePage",
+            query: "SELECT Id,Content,Name,CreatedOn,Description,ModifiedOn,Type FROM ActivePage",
+            contentField: "Content",
+        }
+    ];
+
+    // Step 3: Download records in parallel with spinner
+    const [activeClassResult, activePageResult, assets] = await withSpinner("Downloading files...", async () => {
+        const meqlResults = await Promise.all(
+            queries.map(q => meqlQuery(instanceUrl, token.value, q.query))
+        );
+
+        const assetTree = await downloadAssets(instanceUrl, token.value);
+       
+        return [
+            ...meqlResults,
+            assetTree
+        ]
+    });
+
+    // Update assets base
+    const processAssets = (records) => {
+        for (const record of records) {
+            if (record?.Type === 'Folder') {
+                if (record?.Children?.length === 0) continue;
+                processAssets(record.Children);
+                continue;
+            }
+
+            updateBase(
+                path.join(EXPORT_ROOT, record?.Path), 
+                {
+                    ...record,
+                    Id: path.join(EXPORT_ROOT, record?.Path)
+                }
+            );
+        }
+    }
+
+    processAssets(assets.tree);
+
+    // Remove (clean) the export root directory
+    // fs.rmSync(EXPORT_ROOT, { recursive: true, force: true });
+
+    // Check for conflicts and have user select conflict resolution
+    const activeClassRecords = (activeClassResult.Records || []).map(record => {
+        record.Content = record.Body;
+        delete record.Body;
+        return record;
+    });
+
+    const activePageRecords = (activePageResult.Records || []);
+    const allRecords = [...activeClassRecords, ...activePageRecords].map(mapRecordToFile);
+
+    const issues = [];
+    for (const record of allRecords) {
+        if (record?.error) {
+            continue;
+        }
+
+        const status = compareLocalAndRemote(
+            path.join(EXPORT_ROOT, record.relativePath),
+            { ...record, content: record.Content }
+        );
+
+        // Missing files will just be written
+        if (!['in_sync', 'missing'].includes(status.status)) {
+            issues.push({ relativePath: record.relativePath, status: status.status });
+        }
+    }
+
+    let resolutionMethod = 'skip';
+
+    if (issues.length > 0) {
+        resolutionMethod = await promptConflictResolution(issues);
+    }
+
+    // Step 5: Write all ActiveClass and ActivePage records
+    await writeRecords(allRecords, resolutionMethod);
+
+    // Step 7: Success message
+    console.log(`\n✅ Successfully pulled:`);
+    console.log(`   • ${activeClassResult.Records.length} ActiveClass records`);
+    console.log(`   • ${activePageResult.Records.length} ActivePage records`);
+    console.log(`📁 Saved to: ./${EXPORT_ROOT}/ (organized into Controllers, Triggers, Classes, Pages)`);
+    // console.log(`🔍 Tip: Run 'magentrix status' to see local vs server differences.`);
+};