@contentstack/cli-cm-import-setup 1.0.0-beta.1

package/lib/types/default-config.d.ts

@@ -0,0 +1,55 @@
+import { Modules } from '.';
+export default interface DefaultConfig {
+    host: string;
+    developerHubBaseUrl: string;
+    modules: {
+        'custom-roles': {
+            dirName: string;
+            fileName: string;
+            dependencies: Modules[];
+        };
+        environments: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        extensions: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        assets: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+            fetchConcurrency: number;
+        };
+        'content-types': {
+            dirName: string;
+            fileName: string;
+            dependencies: Modules[];
+        };
+        entries: {
+            dirName: string;
+            fileName: string;
+            dependencies: Modules[];
+        };
+        'global-fields': {
+            dirName: string;
+            fileName: string;
+            dependencies: Modules[];
+        };
+        'marketplace-apps': {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        taxonomies: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+            invalidKeys: string[];
+        };
+    };
+    fetchConcurrency: number;
+}

package/lib/types/default-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/import-config.d.ts

@@ -0,0 +1,55 @@
+import { Modules } from '.';
+import DefaultConfig from './default-config';
+export interface ExternalConfig {
+    source_stack?: string;
+    data: string;
+    fetchConcurrency: number;
+    writeConcurrency: number;
+    email?: string;
+    password?: string;
+}
+export default interface ImportConfig extends DefaultConfig, ExternalConfig {
+    cliLogsPath?: string;
+    contentDir: string;
+    data: string;
+    management_token?: string;
+    apiKey: string;
+    forceStopMarketplaceAppsPrompt: boolean;
+    auth_token?: string;
+    contentTypes?: string[];
+    branches?: branch[];
+    branchEnabled?: boolean;
+    branchDir?: string;
+    moduleName?: Modules;
+    master_locale: masterLocale;
+    headers?: {
+        api_key: string;
+        access_token?: string;
+        authtoken?: string;
+        'X-User-Agent': string;
+    };
+    access_token?: string;
+    isAuthenticated?: boolean;
+    target_stack?: string;
+    masterLocale: masterLocale;
+    backupConcurrency?: number;
+    authtoken?: string;
+    destinationStackName?: string;
+    org_uid?: string;
+    contentVersion: number;
+    stackName?: string;
+    branchName: string;
+    selectedModules: Modules[];
+    useBackedupDir?: string;
+    backupDir: string;
+    createBackupDir?: string;
+    region: any;
+}
+type branch = {
+    uid: string;
+    source: string;
+};
+type masterLocale = {
+    code: string;
+};
+export {};

package/lib/types/import-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,115 @@
+import { ContentstackClient } from '@contentstack/cli-utilities';
+import ImportConfig from './import-config';
+export type ModuleClassParams = {
+    stackAPIClient: ReturnType<ContentstackClient['stack']>;
+    config: ImportConfig;
+    dependencies: Modules;
+};
+export interface AuthOptions {
+    contentstackClient: ContentstackClient;
+}
+export interface ContentStackManagementClient {
+    contentstackClient: object;
+}
+export interface PrintOptions {
+    color?: string;
+}
+export type AdditionalKeys = {
+    backupDir: string;
+};
+export type ApiModuleType = 'fetch-assets';
+export type ApiOptions = {
+    uid?: string;
+    url?: string;
+    entity: ApiModuleType;
+    apiData?: Record<any, any> | any;
+    resolve: (value: any) => Promise<void> | void;
+    reject: (error: any) => Promise<void> | void;
+    additionalInfo?: Record<any, any>;
+    includeParamOnCompletion?: boolean;
+    serializeData?: (input: ApiOptions) => any;
+};
+export type EnvType = {
+    processName: string;
+    totalCount?: number;
+    indexerCount?: number;
+    currentIndexer?: number;
+    apiParams?: ApiOptions;
+    concurrencyLimit?: number;
+    apiContent: Record<string, any>[];
+};
+export type CustomPromiseHandlerInput = {
+    index: number;
+    batchIndex: number;
+    element?: Record<string, unknown>;
+    apiParams?: ApiOptions;
+    isLastRequest: boolean;
+};
+export type CustomPromiseHandler = (input: CustomPromiseHandlerInput) => Promise<any>;
+export interface InquirePayload {
+    type: string;
+    name: string;
+    message: string;
+    choices?: Array<any>;
+    transformer?: Function;
+}
+export interface User {
+    email: string;
+    authtoken: string;
+}
+export type Modules = 'stack' | 'assets' | 'locales' | 'environments' | 'extensions' | 'webhooks' | 'global-fields' | 'entries' | 'content-types' | 'custom-roles' | 'workflows' | 'labels' | 'marketplace-apps' | 'taxonomies';
+export interface ExtensionsRecord {
+    title: string;
+    uid: string;
+}
+export interface MarketplaceAppsConfig {
+    dirName: string;
+    fileName: string;
+    dependencies?: Modules[];
+}
+export interface EnvironmentConfig {
+    dirName: string;
+    fileName: string;
+    dependencies?: Modules[];
+}
+export interface LabelConfig {
+    dirName: string;
+    fileName: string;
+}
+export interface WebhookConfig {
+    dirName: string;
+    fileName: string;
+}
+export interface WorkflowConfig {
+    dirName: string;
+    fileName: string;
+    invalidKeys: string[];
+}
+export interface CustomRoleConfig {
+    dirName: string;
+    fileName: string;
+    customRolesLocalesFileName: string;
+}
+export type AssetRecord = {
+    uid: string;
+    url: string;
+    title: string;
+};
+export interface TaxonomiesConfig {
+    dirName: string;
+    fileName: string;
+    dependencies?: Modules[];
+}
+export { default as DefaultConfig } from './default-config';
+export { default as ImportConfig } from './import-config';
+export type ExtensionType = {
+    uid: string;
+    scope: Record<string, unknown>;
+    title: string;
+};
+export type TaxonomyQueryParams = {
+    include_count: boolean;
+    limit: number;
+    skip: number;
+    depth?: number;
+};

package/lib/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/backup-handler.d.ts

@@ -0,0 +1,2 @@
+import { ImportConfig } from '../types';
+export default function backupHandler(importConfig: ImportConfig): Promise<string>;

package/lib/utils/backup-handler.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs_extra_1 = require("fs-extra");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const index_1 = require("./index");
+async function backupHandler(importConfig) {
+    if (importConfig.hasOwnProperty('useBackedupDir')) {
+        return importConfig.useBackedupDir;
+    }
+    let backupDirPath;
+    const subDir = isSubDirectory(importConfig);
+    if (subDir) {
+        backupDirPath = path.resolve((0, cli_utilities_1.sanitizePath)(importConfig.contentDir), '..', '_backup_' + Math.floor(Math.random() * 1000));
+        if (importConfig.createBackupDir) {
+            cli_utilities_1.cliux.print(`Warning!!! Provided backup directory path is a sub directory of the content directory, Cannot copy to a sub directory. Hence new backup directory created - ${backupDirPath}`, {
+                color: 'yellow',
+            });
+        }
+    }
+    else {
+        // NOTE: If the backup folder's directory is provided, create it at that location; otherwise, the default path (working directory).
+        backupDirPath = path.join(process.cwd(), '_backup_' + Math.floor(Math.random() * 1000));
+        if (importConfig.createBackupDir) {
+            if (index_1.fileHelper.fileExistsSync(importConfig.createBackupDir)) {
+                index_1.fileHelper.removeDirSync(importConfig.createBackupDir);
+            }
+            index_1.fileHelper.makeDirectory(importConfig.createBackupDir);
+            backupDirPath = importConfig.createBackupDir;
+        }
+    }
+    if (backupDirPath) {
+        cli_utilities_1.cliux.print('Copying content to the backup directory...');
+        return new Promise((resolve, reject) => {
+            return (0, fs_extra_1.copy)(importConfig.contentDir, backupDirPath, (error) => {
+                if (error) {
+                    (0, index_1.trace)(error, 'error', true);
+                    return reject(error);
+                }
+                resolve(backupDirPath);
+            });
+        });
+    }
+}
+exports.default = backupHandler;
+/**
+ * Check whether provided backup directory path is sub directory or not
+ * @param importConfig
+ * @returns
+ */
+function isSubDirectory(importConfig) {
+    const parent = importConfig.contentDir;
+    const child = importConfig.createBackupDir ? importConfig.createBackupDir : process.cwd();
+    const relative = path.relative(parent, child);
+    if (relative) {
+        return !relative.startsWith('..') && !path.isAbsolute(relative);
+    }
+    // true if both parent and child have same path
+    return true;
+}

package/lib/utils/file-helper.d.ts

@@ -0,0 +1,15 @@
+import { FsUtility } from '@contentstack/cli-utilities';
+export declare const readFileSync: (filePath: string, parse?: boolean) => any;
+export declare const readFile: (filePath: string, options?: {
+    type: string;
+}) => Promise<any>;
+export declare const readLargeFile: (filePath: string, opts?: any) => Promise<any>;
+export declare const writeFileSync: (filePath: string, data: any) => void;
+export declare const writeFile: (filePath: string, data: any) => Promise<any>;
+export declare const writeLargeFile: (filePath: string, data: any) => Promise<any>;
+export declare const makeDirectory: (dir: string) => void;
+export declare const readdirSync: (dirPath: string) => any;
+export declare const isFolderExist: (folderPath: string) => Promise<any>;
+export declare const fileExistsSync: (path: string) => boolean;
+export declare const removeDirSync: (path: string) => void;
+export declare const fsUtil: FsUtility;

package/lib/utils/file-helper.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsUtil = exports.removeDirSync = exports.fileExistsSync = exports.isFolderExist = exports.readdirSync = exports.makeDirectory = exports.writeLargeFile = exports.writeFile = exports.writeFileSync = exports.readLargeFile = exports.readFile = exports.readFileSync = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const bigJSON = tslib_1.__importStar(require("big-json"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const readFileSync = function (filePath, parse = true) {
+    let data;
+    filePath = path.resolve((0, cli_utilities_1.sanitizePath)(filePath));
+    if (fs.existsSync(filePath)) {
+        try {
+            data = parse ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : data;
+        }
+        catch (error) {
+            return data;
+        }
+    }
+    return data;
+};
+exports.readFileSync = readFileSync;
+// by default file type is json
+const readFile = async (filePath, options = { type: 'json' }) => {
+    return new Promise((resolve, reject) => {
+        filePath = path.resolve((0, cli_utilities_1.sanitizePath)(filePath));
+        fs.readFile(filePath, 'utf-8', (error, data) => {
+            if (error) {
+                if (error.code === 'ENOENT') {
+                    return resolve('');
+                }
+                reject(error);
+            }
+            else {
+                if (options.type !== 'json') {
+                    return resolve(data);
+                }
+                resolve(JSON.parse(data));
+            }
+        });
+    });
+};
+exports.readFile = readFile;
+const readLargeFile = function (filePath, opts) {
+    if (typeof filePath !== 'string') {
+        return;
+    }
+    filePath = path.resolve((0, cli_utilities_1.sanitizePath)(filePath));
+    if (fs.existsSync(filePath)) {
+        return new Promise((resolve, reject) => {
+            const readStream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+            const parseStream = bigJSON.createParseStream();
+            parseStream.on('data', function (data) {
+                if ((opts === null || opts === void 0 ? void 0 : opts.type) === 'array') {
+                    return resolve(Object.values(data));
+                }
+                resolve(data);
+            });
+            parseStream.on('error', function (error) {
+                console.log('error', error);
+                reject(error);
+            });
+            readStream.pipe(parseStream);
+        });
+    }
+};
+exports.readLargeFile = readLargeFile;
+const writeFileSync = function (filePath, data) {
+    data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
+    fs.writeFileSync(filePath, data);
+};
+exports.writeFileSync = writeFileSync;
+const writeFile = function (filePath, data) {
+    return new Promise((resolve, reject) => {
+        data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
+        fs.writeFile(filePath, data, (error) => {
+            if (error) {
+                return reject(error);
+            }
+            resolve('done');
+        });
+    });
+};
+exports.writeFile = writeFile;
+const writeLargeFile = function (filePath, data) {
+    if (typeof filePath !== 'string' || typeof data !== 'object') {
+        return;
+    }
+    filePath = path.resolve((0, cli_utilities_1.sanitizePath)(filePath));
+    return new Promise((resolve, reject) => {
+        const stringifyStream = bigJSON.createStringifyStream({
+            body: data,
+        });
+        var writeStream = fs.createWriteStream(filePath, 'utf-8');
+        stringifyStream.pipe(writeStream);
+        writeStream.on('finish', () => {
+            resolve('');
+        });
+        writeStream.on('error', (error) => {
+            reject(error);
+        });
+    });
+};
+exports.writeLargeFile = writeLargeFile;
+const makeDirectory = function (dir) {
+    for (let key in arguments) {
+        const dirname = path.resolve(arguments[key]);
+        if (!fs.existsSync(dirname)) {
+            mkdirp_1.default.sync(dirname);
+        }
+    }
+};
+exports.makeDirectory = makeDirectory;
+const readdirSync = function (dirPath) {
+    if (fs.existsSync(dirPath)) {
+        return fs.readdirSync(dirPath);
+    }
+    else {
+        return [];
+    }
+};
+exports.readdirSync = readdirSync;
+const isFolderExist = async (folderPath) => {
+    return new Promise((resolve, reject) => {
+        folderPath = path.resolve((0, cli_utilities_1.sanitizePath)(folderPath));
+        fs.access(folderPath, (error) => {
+            if (error) {
+                return resolve(false);
+            }
+            resolve(true);
+        });
+    });
+};
+exports.isFolderExist = isFolderExist;
+const fileExistsSync = function (path) {
+    return fs.existsSync(path);
+};
+exports.fileExistsSync = fileExistsSync;
+const removeDirSync = function (path) {
+    fs.rmdirSync(path, { recursive: true });
+};
+exports.removeDirSync = removeDirSync;
+exports.fsUtil = new cli_utilities_1.FsUtility();

package/lib/utils/import-config-handler.d.ts

@@ -0,0 +1,3 @@
+import { ImportConfig } from '../types';
+declare const setupConfig: (importCmdFlags: any) => Promise<ImportConfig>;
+export default setupConfig;

package/lib/utils/import-config-handler.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const merge_1 = tslib_1.__importDefault(require("merge"));
+const path = tslib_1.__importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const config_1 = tslib_1.__importDefault(require("../config"));
+const file_helper_1 = require("./file-helper");
+const interactive_1 = require("./interactive");
+const login_handler_1 = tslib_1.__importDefault(require("./login-handler"));
+const setupConfig = async (importCmdFlags) => {
+    var _a;
+    let config = (0, merge_1.default)({}, config_1.default);
+    // setup the config
+    // if (importCmdFlags['config']) {
+    //   let externalConfig = await readFile(importCmdFlags['config']);
+    //   if (isArray(externalConfig['modules'])) {
+    //     config.modules = filter(config.modules, (module) => includes(externalConfig['modules'], module));
+    //     externalConfig = omit(externalConfig, ['modules']);
+    //   }
+    //   config = merge.recursive(config, externalConfig);
+    // }
+    config.contentDir = importCmdFlags['data'] || importCmdFlags['data-dir'] || config.data || (await (0, interactive_1.askContentDir)());
+    const pattern = /[*$%#<>{}!&?]/g;
+    if (pattern.test(config.contentDir)) {
+        cli_utilities_1.cliux.print(`\nPlease add a directory path without any of the special characters: (*,&,{,},[,],$,%,<,>,?,!)`, {
+            color: 'yellow',
+        });
+        config.contentDir = await (0, interactive_1.askContentDir)();
+    }
+    config.contentDir = config.contentDir.replace(/['"]/g, '');
+    config.contentDir = path.resolve(config.contentDir);
+    //Note to support the old key
+    config.data = config.contentDir;
+    if ((0, file_helper_1.fileExistsSync)(path.join(config.contentDir, 'export-info.json'))) {
+        config.contentVersion =
+            ((await (0, file_helper_1.readFile)(path.join(config.contentDir, 'export-info.json'))) || {}).contentVersion || 2;
+    }
+    else {
+        config.contentVersion = 1;
+    }
+    const managementTokenAlias = importCmdFlags['management-token-alias'] || importCmdFlags['alias'];
+    if (managementTokenAlias) {
+        const { token, apiKey } = (_a = cli_utilities_1.configHandler.get(`tokens.${managementTokenAlias}`)) !== null && _a !== void 0 ? _a : {};
+        config.management_token = token;
+        config.apiKey = apiKey;
+        if (!config.management_token) {
+            throw new Error(`No management token found on given alias ${managementTokenAlias}`);
+        }
+    }
+    if (!config.management_token) {
+        if (!(0, cli_utilities_1.isAuthenticated)()) {
+            if (config.email && config.password) {
+                await (0, login_handler_1.default)(config);
+            }
+            else {
+                throw new Error('Please login or provide an alias for the management token');
+            }
+        }
+        else {
+            config.apiKey =
+                importCmdFlags['stack-uid'] || importCmdFlags['stack-api-key'] || config.target_stack || (await (0, interactive_1.askAPIKey)());
+            if (typeof config.apiKey !== 'string') {
+                throw new Error('Invalid API key received');
+            }
+        }
+    }
+    config.isAuthenticated = (0, cli_utilities_1.isAuthenticated)();
+    //Note to support the old key
+    config.source_stack = config.apiKey;
+    // config.skipAudit = importCmdFlags['skip-audit'];
+    // config.forceStopMarketplaceAppsPrompt = importCmdFlags.yes;
+    // config.importWebhookStatus = importCmdFlags['import-webhook-status'];
+    // config.skipPrivateAppRecreationIfExist = importCmdFlags['skip-app-recreation'];
+    if (importCmdFlags['branch']) {
+        config.branchName = importCmdFlags['branch'];
+        config.branchDir = path.join((0, cli_utilities_1.sanitizePath)(config.contentDir), (0, cli_utilities_1.sanitizePath)(config.branchName));
+    }
+    const selectedModule = importCmdFlags['modules'] || (await (0, interactive_1.askSelectedModules)());
+    if (selectedModule === 'both') {
+        config.selectedModules = ['content-types', 'entries'];
+    }
+    else {
+        config.selectedModules = [selectedModule];
+    }
+    if (importCmdFlags['backup-dir']) {
+        config.useBackedupDir = importCmdFlags['backup-dir'];
+    }
+    return config;
+};
+exports.default = setupConfig;

package/lib/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * as interactive from './interactive';
+export { default as setupImportConfig } from './import-config-handler';
+export * as fileHelper from './file-helper';
+export { fsUtil } from './file-helper';
+export { default as backupHandler } from './backup-handler';
+export { log, unlinkFileLogger } from './logger';
+export * from './log';

package/lib/utils/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlinkFileLogger = exports.log = exports.backupHandler = exports.fsUtil = exports.fileHelper = exports.setupImportConfig = exports.interactive = void 0;
+const tslib_1 = require("tslib");
+exports.interactive = tslib_1.__importStar(require("./interactive"));
+var import_config_handler_1 = require("./import-config-handler");
+Object.defineProperty(exports, "setupImportConfig", { enumerable: true, get: function () { return tslib_1.__importDefault(import_config_handler_1).default; } });
+exports.fileHelper = tslib_1.__importStar(require("./file-helper"));
+var file_helper_1 = require("./file-helper");
+Object.defineProperty(exports, "fsUtil", { enumerable: true, get: function () { return file_helper_1.fsUtil; } });
+var backup_handler_1 = require("./backup-handler");
+Object.defineProperty(exports, "backupHandler", { enumerable: true, get: function () { return tslib_1.__importDefault(backup_handler_1).default; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return logger_1.log; } });
+Object.defineProperty(exports, "unlinkFileLogger", { enumerable: true, get: function () { return logger_1.unlinkFileLogger; } });
+tslib_1.__exportStar(require("./log"), exports);

package/lib/utils/interactive.d.ts

@@ -0,0 +1,3 @@
+export declare const askContentDir: () => Promise<string>;
+export declare const askSelectedModules: () => Promise<string>;
+export declare const askAPIKey: () => Promise<string>;

package/lib/utils/interactive.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askAPIKey = exports.askSelectedModules = exports.askContentDir = void 0;
+const tslib_1 = require("tslib");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const path = tslib_1.__importStar(require("path"));
+const askContentDir = async () => {
+    let result = await cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'Enter the path for the content',
+        name: 'dir',
+        validate: cli_utilities_1.validatePath,
+    });
+    result = result.replace(/["']/g, '');
+    return path.resolve(result);
+};
+exports.askContentDir = askContentDir;
+const askSelectedModules = async () => {
+    return cli_utilities_1.cliux.inquire({
+        type: 'list',
+        name: 'selectedModule',
+        message: 'Please select a module to generate the mapper files',
+        choices: [
+            { name: 'Content types', value: 'content-types' },
+            { name: 'Entries', value: 'entries' },
+            { name: 'Both', value: 'both' },
+        ],
+    });
+};
+exports.askSelectedModules = askSelectedModules;
+const askAPIKey = async () => {
+    return cli_utilities_1.cliux.inquire({
+        type: 'input',
+        message: 'Enter the stack api key',
+        name: 'apiKey',
+    });
+};
+exports.askAPIKey = askAPIKey;

package/lib/utils/log.d.ts

@@ -0,0 +1,12 @@
+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;