@contentstack/cli-cm-import 1.28.1 → 2.0.1-beta

package/lib/import/modules-js/workflows.js

@@ -1,170 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
- * MIT Licensed
- */
-const fs = require('fs');
-const path = require('path');
-const chalk = require('chalk');
-const mkdirp = require('mkdirp');
-const Promise = require('bluebird');
-const { isEmpty, merge, filter, map, cloneDeep, find } = require('lodash');
-let { default: config } = require('../../config');
-const { fileHelper, log, formatError } = require('../../utils');
-module.exports = class importWorkflows {
-    constructor(importConfig, stackAPIClient) {
-        this.fails = [];
-        this.success = [];
-        this.workflowUidMapper = {};
-        this.workflowConfig = config.modules.workflows;
-        this.reqConcurrency = config.concurrency || config.fetchConcurrency || 1;
-        this.config = merge(config, importConfig);
-        this.stackAPIClient = stackAPIClient;
-    }
-    start() {
-        log(this.config, chalk.white('Migrating workflows'), 'success');
-        let self = this;
-        let workflowMapperPath = path.resolve(this.config.data, 'mapper', 'workflows');
-        let workflowFailsPath = path.resolve(this.config.data, 'workflows', 'fails.json');
-        let workflowSuccessPath = path.resolve(this.config.data, 'workflows', 'success.json');
-        let workflowUidMapperPath = path.resolve(this.config.data, 'mapper', 'workflows', 'uid-mapping.json');
-        let workflowFolderPath = path.resolve(this.config.data, this.workflowConfig.dirName);
-        self.workflows = fileHelper.readFileSync(path.resolve(workflowFolderPath, this.workflowConfig.fileName));
-        if (fs.existsSync(workflowUidMapperPath)) {
-            this.workflowUidMapper = fileHelper.readFileSync(workflowUidMapperPath);
-            this.workflowUidMapper = this.workflowUidMapper || {};
-        }
-        mkdirp.sync(workflowMapperPath);
-        return new Promise(function (resolve, reject) {
-            if (self.workflows == undefined || isEmpty(self.workflows)) {
-                log(self.config, chalk.white('No workflow Found'), 'success');
-                return resolve({ empty: true });
-            }
-            self.workflowsUids = Object.keys(self.workflows);
-            return Promise.map(self.workflowsUids, async function (workflowUid) {
-                let workflow = self.workflows[workflowUid];
-                if (!self.workflowUidMapper.hasOwnProperty(workflowUid)) {
-                    const roleNameMap = {};
-                    const workflowStages = workflow.workflow_stages;
-                    const oldWorkflowStages = cloneDeep(workflow.workflow_stages);
-                    const roles = await self.stackAPIClient.role().fetchAll();
-                    for (const role of roles.items) {
-                        roleNameMap[role.name] = role.uid;
-                    }
-                    for (const stage of workflowStages) {
-                        delete stage.uid;
-                        if (!isEmpty(stage.next_available_stages)) {
-                            stage.next_available_stages = ['$all'];
-                        }
-                        if (stage.SYS_ACL.users.uids.length && stage.SYS_ACL.users.uids[0] !== '$all') {
-                            stage.SYS_ACL.users.uids = ['$all'];
-                        }
-                        if (stage.SYS_ACL.roles.uids.length) {
-                            try {
-                                for (let i = 0; i < stage.SYS_ACL.roles.uids.length; i++) {
-                                    const roleData = stage.SYS_ACL.roles.uids[i];
-                                    if (!roleNameMap[roleData.name]) {
-                                        // rules.branch is required to create custom roles.
-                                        const branchRuleExists = roleData.rules.find((rule) => rule.module === 'branch');
-                                        if (!branchRuleExists) {
-                                            roleData.rules.push({
-                                                module: 'branch',
-                                                branches: ['main'],
-                                                acl: { read: true },
-                                            });
-                                        }
-                                        const role = await self.stackAPIClient.role().create({ role: roleData });
-                                        stage.SYS_ACL.roles.uids[i] = role.uid;
-                                        roleNameMap[roleData.name] = role.uid;
-                                    }
-                                    else {
-                                        stage.SYS_ACL.roles.uids[i] = roleNameMap[roleData.name];
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                log(self.config, `Error while importing workflows roles. ${formatError(error)}`, 'error');
-                                reject({ message: 'Error while importing workflows roles' });
-                            }
-                        }
-                    }
-                    if (workflow.admin_users !== undefined) {
-                        log(self.config, chalk.yellow('We are skipping import of `Workflow superuser(s)` from workflow'), 'info');
-                        delete workflow.admin_users;
-                    }
-                    // One branch is required to create workflow.
-                    if (!workflow.branches) {
-                        workflow.branches = ['main'];
-                    }
-                    return self.stackAPIClient
-                        .workflow()
-                        .create({ workflow })
-                        .then(async function (response) {
-                        if (!isEmpty(filter(oldWorkflowStages, ({ next_available_stages }) => !isEmpty(next_available_stages)))) {
-                            let updateRresponse = await self
-                                .updateNextAvailableStagesUid(response, response.workflow_stages, oldWorkflowStages)
-                                .catch((error) => {
-                                log(self.config, `Workflow '${workflow.name}' update failed.`, 'error');
-                                log(self.config, error, 'error');
-                            });
-                            if (updateRresponse)
-                                response = updateRresponse;
-                        }
-                        self.workflowUidMapper[workflowUid] = response;
-                        fileHelper.writeFileSync(workflowUidMapperPath, self.workflowUidMapper);
-                    })
-                        .catch(function (error) {
-                        self.fails.push(workflow);
-                        if (error.errors.name) {
-                            log(self.config, `workflow '${workflow.name}' already exist`, 'error');
-                        }
-                        else if (error.errors['workflow_stages.0.users']) {
-                            log(self.config, "Failed to import Workflows as you've specified certain roles in the Stage transition and access rules section. We currently don't import roles to the stack.", 'error');
-                        }
-                        else {
-                            log(self.config, `Workflow '${workflow.name}' failed.`, 'error');
-                        }
-                    });
-                }
-                else {
-                    // the workflow has already been created
-                    log(self.config, chalk.white(`The Workflows ${workflow.name} already exists. Skipping it to avoid duplicates!`), 'success');
-                }
-                // import 1 workflows at a time
-            }, { concurrency: self.reqConcurrency })
-                .then(function () {
-                fileHelper.writeFileSync(workflowSuccessPath, self.success);
-                log(self.config, chalk.green('Workflows have been imported successfully!'), 'success');
-                resolve();
-            })
-                .catch(function (error) {
-                fileHelper.writeFileSync(workflowFailsPath, self.fails);
-                log(self.config, `Workflows import failed. ${formatError(error)}`, 'error');
-                return reject(error);
-            });
-        });
-    }
-    updateNextAvailableStagesUid(workflow, newWorkflowStages, oldWorkflowStages) {
-        newWorkflowStages = map(newWorkflowStages, (newStage, index) => {
-            const oldStage = oldWorkflowStages[index];
-            if (!isEmpty(oldStage.next_available_stages)) {
-                newStage.next_available_stages = map(oldStage.next_available_stages, (stageUid) => {
-                    var _a, _b;
-                    if (stageUid === '$all')
-                        return stageUid;
-                    const stageName = (_a = find(oldWorkflowStages, { uid: stageUid })) === null || _a === void 0 ? void 0 : _a.name;
-                    return (_b = find(newWorkflowStages, { name: stageName })) === null || _b === void 0 ? void 0 : _b.uid;
-                }).filter((val) => val);
-            }
-            return newStage;
-        });
-        const updateWorkflow = this.stackAPIClient.workflow(workflow.uid);
-        Object.assign(updateWorkflow, {
-            name: workflow.name,
-            branches: workflow.branches,
-            workflow_stages: newWorkflowStages,
-            content_types: workflow.content_types
-        });
-        return updateWorkflow.update();
-    }
-};

package/lib/utils/log.d.ts

@@ -1,12 +0,0 @@
-import { LogEntry } from 'winston/index';
-import { Logger } from '@contentstack/cli-utilities';
-import { LogsType, MessageType } from '@contentstack/cli-utilities/lib/logger';
-import { ImportConfig } from '../types';
-declare let logger: Logger;
-export declare function isImportConfig(config: ImportConfig | MessageType): config is ImportConfig;
-export declare function log(entry: LogEntry): void;
-export declare function log(error: MessageType, logType: LogsType): void;
-export declare function log(error: MessageType, logType: 'error', hidden: boolean): void;
-export declare function initLogger(config?: ImportConfig | undefined): Logger;
-export { logger };
-export declare const trace: typeof log;

package/lib/utils/log.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trace = exports.logger = exports.initLogger = exports.log = exports.isImportConfig = void 0;
-const path_1 = require("path");
-const cli_utilities_1 = require("@contentstack/cli-utilities");
-let logger;
-exports.logger = logger;
-function isImportConfig(config) {
-    return config.data !== undefined && (config === null || config === void 0 ? void 0 : config.contentVersion) !== undefined;
-}
-exports.isImportConfig = isImportConfig;
-function log(entryOrMessage, logType, hidden) {
-    exports.logger = logger = initLogger();
-    if (logType === 'error') {
-        logger.log(entryOrMessage, logType, hidden);
-    }
-    else {
-        logger.log(entryOrMessage, logType);
-    }
-}
-exports.log = log;
-function initLogger(config) {
-    var _a;
-    if (!logger) {
-        const basePath = (0, cli_utilities_1.pathValidator)((0, path_1.join)((0, cli_utilities_1.sanitizePath)((_a = config === null || config === void 0 ? void 0 : config.cliLogsPath) !== null && _a !== void 0 ? _a : process.cwd()), 'logs', 'import'));
-        exports.logger = logger = new cli_utilities_1.Logger(Object.assign(config !== null && config !== void 0 ? config : {}, { basePath }));
-    }
-    return logger;
-}
-exports.initLogger = initLogger;
-exports.trace = log;