@contentstack/cli-cm-export 1.20.2 → 2.0.0-beta.1

package/lib/utils/progress-strategy-registry.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+/**
+ * Progress Strategy Registrations for Export Modules
+ * This file registers progress calculation strategies for all export modules
+ * to ensure correct item counts in the final summary.
+ */
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+// Wrap all registrations in try-catch to prevent module loading errors
+try {
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.CONTENT_TYPES], new cli_utilities_1.DefaultProgressStrategy());
+    // Register strategy for Assets - custom strategy to avoid double counting
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.ASSETS], new cli_utilities_1.CustomProgressStrategy((processes) => {
+        // Both ASSET_METADATA and ASSET_DOWNLOADS represent the same assets
+        // Count only the downloads process to avoid double counting in summary
+        const downloadsProcess = processes.get(constants_1.PROCESS_NAMES.ASSET_DOWNLOADS);
+        if (downloadsProcess) {
+            return {
+                total: downloadsProcess.total,
+                success: downloadsProcess.successCount,
+                failures: downloadsProcess.failureCount,
+            };
+        }
+        // Fallback to metadata process if downloads don't exist
+        const metadataProcess = processes.get(constants_1.PROCESS_NAMES.ASSET_METADATA);
+        if (metadataProcess) {
+            return {
+                total: metadataProcess.total,
+                success: metadataProcess.successCount,
+                failures: metadataProcess.failureCount,
+            };
+        }
+        return null; // Fall back to default aggregation
+    }));
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.GLOBAL_FIELDS], new cli_utilities_1.DefaultProgressStrategy());
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.EXTENSIONS], new cli_utilities_1.DefaultProgressStrategy());
+    // Register strategy for Environments - simple module
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.ENVIRONMENTS], new cli_utilities_1.DefaultProgressStrategy());
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.LOCALES], new cli_utilities_1.DefaultProgressStrategy());
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.LABELS], new cli_utilities_1.DefaultProgressStrategy());
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.WEBHOOKS], new cli_utilities_1.DefaultProgressStrategy());
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.WORKFLOWS], new cli_utilities_1.DefaultProgressStrategy());
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.CUSTOM_ROLES], new cli_utilities_1.DefaultProgressStrategy());
+    // Register strategy for Taxonomies - use Taxonomies & Terms as primary process
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.TAXONOMIES], new cli_utilities_1.PrimaryProcessStrategy(constants_1.PROCESS_NAMES.EXPORT_TAXONOMIES_TERMS));
+    // Register strategy for Marketplace Apps - complex module with app installations
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.MARKETPLACE_APPS], new cli_utilities_1.CustomProgressStrategy((processes) => {
+        // For marketplace apps, count the actual apps exported
+        const appsExport = processes.get(constants_1.PROCESS_NAMES.FETCH_APPS);
+        if (appsExport) {
+            return {
+                total: appsExport.total,
+                success: appsExport.successCount,
+                failures: appsExport.failureCount,
+            };
+        }
+        const setup = processes.get(constants_1.PROCESS_NAMES.FETCH_CONFIG_MANIFEST);
+        if (setup) {
+            return {
+                total: setup.total,
+                success: setup.successCount,
+                failures: setup.failureCount,
+            };
+        }
+        return null;
+    }));
+    // Register strategy for Stack Settings - use Settings as primary process
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.STACK], new cli_utilities_1.PrimaryProcessStrategy(constants_1.PROCESS_NAMES.STACK_SETTINGS));
+    // Register strategy for Personalize - complex module with projects/experiences
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.PERSONALIZE], new cli_utilities_1.CustomProgressStrategy((processes) => {
+        // For personalize, we want to count projects as the main metric
+        const projectExport = processes.get(constants_1.PROCESS_NAMES.PERSONALIZE_PROJECTS);
+        if (projectExport) {
+            return {
+                total: projectExport.total,
+                success: projectExport.successCount,
+                failures: projectExport.failureCount,
+            };
+        }
+        // Fallback to any other main process
+        const mainProcess = Array.from(processes.values())[0];
+        if (mainProcess) {
+            return {
+                total: mainProcess.total,
+                success: mainProcess.successCount,
+                failures: mainProcess.failureCount,
+            };
+        }
+        return null;
+    }));
+    // Register strategy for Entries - use Entries as primary process
+    cli_utilities_1.ProgressStrategyRegistry.register(constants_1.MODULE_NAMES[constants_1.MODULE_CONTEXTS.ENTRIES], new cli_utilities_1.PrimaryProcessStrategy(constants_1.PROCESS_NAMES.ENTRIES));
+}
+catch (error) {
+    // Silently ignore registration errors during module loading
+}
+exports.default = cli_utilities_1.ProgressStrategyRegistry;

package/messages/index.json

@@ -1,6 +1,6 @@
 {
 "ASSET_EXPORT_COMPLETE": "Asset export process completed successfully",
-"ASSET_FOLDERS_EXPORT_COMPLETE": "Asset folder structure exported successfully",
+"ASSET_FOLDERS_EXPORT_COMPLETE": "Asset folder structure exported successfully with %s folder(s)",
 "ASSET_METADATA_EXPORT_COMPLETE": "Asset metadata exported successfully",
 "ASSET_VERSIONED_METADATA_EXPORT_COMPLETE": "Versioned asset metadata exported successfully",
 "ASSET_DOWNLOAD_COMPLETE": "Asset download completed successfully",
@@ -65,5 +65,7 @@
 "BRANCH_EXPORT_FAILED": "Failed to export contents from branch (UID: %s)",
 
 "ROLES_NO_CUSTOM_ROLES": "No custom roles found in the current stack",
-"ROLES_EXPORTING_ROLE": "Exporting role '%s'"
+"ROLES_EXPORTING_ROLE": "Exporting role '%s'",
+
+"GLOBAL_FIELDS_NOT_FOUND": "No global fields found in the current stack"
 }

package/oclif.manifest.json

@@ -159,5 +159,5 @@
       ]
     }
   },
-  "version": "1.20.2"
+  "version": "2.0.0-beta.1"
 }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@contentstack/cli-cm-export",
   "description": "Contentstack CLI plugin to export content from stack",
-  "version": "1.20.2",
+  "version": "2.0.0-beta.1",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
     "@contentstack/cli-command": "~1.6.1",
-    "@contentstack/cli-variants": "~1.3.3",
+    "@contentstack/cli-variants": "~2.0.0-beta",
     "@oclif/core": "^4.3.3",
-    "@contentstack/cli-utilities": "~1.14.1",
+    "@contentstack/cli-utilities": "~1.15.0",
     "async": "^3.2.6",
     "big-json": "^3.2.0",
     "bluebird": "^3.7.2",

package/lib/export/modules-js/assets.d.ts

@@ -1,43 +0,0 @@
-export = ExportAssets;
-declare class ExportAssets {
-    constructor(exportConfig: any, stackAPIClient: any);
-    config: any;
-    bLimit: number;
-    vLimit: any;
-    invalidKeys: string[];
-    folderJSONPath: any;
-    folderData: any[];
-    assetsFolderPath: any;
-    assetContents: {};
-    httpClient: HttpClient;
-    assetConfig: {
-        dirName: string;
-        fileName: string;
-        batchLimit: number;
-        host: string;
-        invalidKeys: string[];
-        chunkFileSize: number;
-        downloadLimit: number;
-        fetchConcurrency: number;
-        assetsMetaKeys: string[];
-        securedAssets: boolean;
-        displayExecutionTime: boolean;
-        enableDownloadStatus: boolean;
-        includeVersionedAssets: boolean;
-        dependencies?: import("../../types").Modules[];
-    };
-    stackAPIClient: any;
-    assetDownloadRetry: {};
-    assetDownloadRetryLimit: number;
-    start(): any;
-    assetContentsFile: string;
-    exportFolders(): any;
-    getFolderJSON(skip: any, fCount: any): any;
-    getAssetCount(folder: any): any;
-    getAssetJSON(skip: any): any;
-    getVersionedAssetJSON(uid: any, version: any, bucket: any): any;
-    downloadAsset(asset: any): any;
-    getFolders(): any;
-    getFolderDetails(skip: any, tCount: any): any;
-}
-import { HttpClient } from "@contentstack/cli-utilities/lib/http-client/client";

package/lib/export/modules-js/assets.js

@@ -1,396 +0,0 @@
-/*!
- * Contentstack Export
- * Copyright (c) 2024 Contentstack LLC
- * MIT Licensed
- */
-const mkdirp = require('mkdirp');
-const path = require('path');
-const fs = require('fs');
-const Promise = require('bluebird');
-const _ = require('lodash');
-const chalk = require('chalk');
-const progress = require('progress-stream');
-const { HttpClient, configHandler, validateUids, sanitizePath, validateFileName } = require('@contentstack/cli-utilities');
-const { fileHelper, log, formatError } = require('../../utils');
-let { default: config } = require('../../config');
-module.exports = class ExportAssets {
-    constructor(exportConfig, stackAPIClient) {
-        this.folderData = [];
-        this.assetContents = {};
-        this.httpClient = HttpClient.create();
-        this.assetConfig = config.modules.assets;
-        this.stackAPIClient = stackAPIClient;
-        this.config = _.merge(config, exportConfig);
-        this.folderData = [];
-        this.assetContents = {};
-        this.assetDownloadRetry = {};
-        this.assetDownloadRetryLimit = 3;
-        this.invalidKeys = this.assetConfig.invalidKeys;
-        this.bLimit = this.assetConfig.batchLimit || 15;
-        this.vLimit = this.assetConfig.downloadLimit || this.config.fetchConcurrency || 3;
-    }
-    start() {
-        const self = this;
-        this.assetsFolderPath = path.resolve(this.config.data, this.config.branchName || '', this.assetConfig.dirName);
-        this.assetContentsFile = path.resolve(this.assetsFolderPath, 'assets.json');
-        this.folderJSONPath = path.resolve(this.assetsFolderPath, 'folders.json');
-        log(this.config, 'Starting assets export', 'success');
-        // Create asset folder
-        mkdirp.sync(this.assetsFolderPath);
-        return new Promise((resolve, reject) => {
-            // TBD: getting all the assets should have optimized
-            return self
-                .getAssetCount()
-                .then((count) => {
-                const assetBatches = [];
-                if (typeof count !== 'number' || count === 0) {
-                    log(self.config, 'No assets found', 'success');
-                    return resolve();
-                }
-                for (let i = 0; i <= count; i += self.bLimit) {
-                    assetBatches.push(i);
-                }
-                return Promise.map(assetBatches, (batch) => {
-                    return self
-                        .getAssetJSON(batch)
-                        .then((assetsJSON) => {
-                        return Promise.map(assetsJSON, (assetJSON) => {
-                            if (self.assetConfig.downloadVersionAssets) {
-                                return self
-                                    .getVersionedAssetJSON(assetJSON.uid, assetJSON._version)
-                                    .then(() => {
-                                    self.assetContents[assetJSON.uid] = assetJSON;
-                                })
-                                    .catch((error) => {
-                                    log(self.config, `Asset '${assetJSON.uid}' failed to download.\n ${formatError(error)}`, 'error');
-                                    log(self.config, error, 'error');
-                                });
-                            }
-                            else {
-                                return self
-                                    .downloadAsset(assetJSON)
-                                    .then(() => {
-                                    self.assetContents[assetJSON.uid] = assetJSON;
-                                })
-                                    .catch((err) => {
-                                    log(self.config, `Asset '${assetJSON.uid}' download failed. ${formatError(err)}`, 'error');
-                                    return err;
-                                });
-                            }
-                        }, { concurrency: self.vLimit })
-                            .then(() => {
-                            log(self.config, 'Batch no ' + (batch + 1) + ' of assets is complete', 'success');
-                            // fileHelper.writeFileSync(this.assetContentsFile, self.assetContents)
-                        })
-                            .catch((error) => {
-                            log(self.config, `Asset batch ${batch + 1} failed to download`, 'error');
-                            log(self.config, formatError(error), 'error');
-                            log(self.config, error, 'error');
-                        });
-                    })
-                        .catch((error) => {
-                        log(self.config, error, 'error');
-                        reject(error);
-                    });
-                }, { concurrency: self.assetConfig.concurrencyLimit || 1 })
-                    .then(() => {
-                    fileHelper.writeFileSync(self.assetContentsFile, self.assetContents);
-                    return self
-                        .exportFolders()
-                        .then(() => {
-                        log(self.config, chalk.green('Asset export completed successfully'), 'success');
-                        return resolve();
-                    })
-                        .catch((error) => {
-                        log(self.config, error, 'error');
-                        reject(error);
-                    });
-                })
-                    .catch((error) => {
-                    fileHelper.writeFileSync(self.assetContentsFile, self.assetContents);
-                    log(self.config, `Asset export failed. ${formatError(error)}`, 'error');
-                    log(self.config, error, 'error');
-                    reject(error);
-                });
-            })
-                .catch((error) => {
-                log(self.config, error, 'error');
-                reject(error);
-            });
-        });
-    }
-    exportFolders() {
-        const self = this;
-        return new Promise((resolve, reject) => {
-            return self
-                .getAssetCount(true)
-                .then((fCount) => {
-                if (fCount === 0) {
-                    log(self.config, 'No folders were found in the stack!', 'success');
-                    return resolve();
-                }
-                return self
-                    .getFolderJSON(0, fCount)
-                    .then(() => {
-                    // asset folders have been successfully exported
-                    log(self.config, 'Asset-folders have been successfully exported!', 'success');
-                    return resolve();
-                })
-                    .catch((error) => {
-                    log(self.config, `Error while exporting asset-folders!\n ${formatError(error)}`, 'error');
-                    return reject(error);
-                });
-            })
-                .catch((error) => {
-                log(self.config, error, 'error');
-                // error while fetching asset folder count
-                return reject(error);
-            });
-        });
-    }
-    getFolderJSON(skip, fCount) {
-        const self = this;
-        return new Promise((resolve, reject) => {
-            if (typeof skip !== 'number') {
-                skip = 0;
-            }
-            if (skip >= fCount) {
-                fileHelper.writeFileSync(self.folderJSONPath, self.folderData);
-                return resolve();
-            }
-            const queryRequestObj = {
-                skip,
-                include_folders: true,
-                query: { is_dir: true },
-            };
-            self.stackAPIClient
-                .asset()
-                .query(queryRequestObj)
-                .find()
-                .then((response) => {
-                skip += 100;
-                self.folderData.push(...response.items);
-                return self.getFolderJSON(skip, fCount).then(resolve).catch(reject);
-            })
-                .catch((error) => reject(error));
-        });
-    }
-    getAssetCount(folder) {
-        const self = this;
-        return new Promise((resolve, reject) => {
-            if (folder && typeof folder === 'boolean') {
-                const queryOptions = {
-                    skip: 99999990,
-                    include_count: true,
-                    include_folders: true,
-                    query: { is_dir: true },
-                };
-                self.stackAPIClient
-                    .asset()
-                    .query(queryOptions)
-                    .find()
-                    .then((asset) => {
-                    return resolve(asset.count);
-                })
-                    .catch((error) => {
-                    log(self.config, error, 'error');
-                });
-            }
-            else {
-                const queryOptions = { skip: 99999990, include_count: true };
-                self.stackAPIClient
-                    .asset()
-                    .query(queryOptions)
-                    .find()
-                    .then(({ count }) => resolve(count))
-                    .catch((error) => {
-                    log(self.config, error, 'error');
-                    reject(error);
-                });
-            }
-        });
-    }
-    getAssetJSON(skip) {
-        const self = this;
-        return new Promise((resolve, reject) => {
-            if (typeof skip !== 'number') {
-                skip = 0;
-            }
-            const queryRequestObj = {
-                skip: skip,
-                limit: self.bLimit,
-                include_publish_details: true,
-                except: {
-                    BASE: self.invalidKeys,
-                },
-            };
-            self.stackAPIClient
-                .asset()
-                .query(queryRequestObj)
-                .find()
-                .then(({ items }) => resolve(items))
-                .catch((error) => {
-                log(self.config, error, 'error');
-                return reject();
-            });
-        });
-    }
-    getVersionedAssetJSON(uid, version, bucket) {
-        const self = this;
-        const assetVersionInfo = bucket || [];
-        return new Promise((resolve, reject) => {
-            if (self.assetDownloadRetry[uid + version] > self.assetDownloadRetryLimit) {
-                console.log('Reached max', self.assetDownloadRetry[uid + version]);
-                return reject(new Error('Asset Max download retry limit exceeded! ' + uid));
-            }
-            if (version <= 0) {
-                if (validateUids(uid)) {
-                    const assetVersionInfoFile = path.resolve(sanitizePath(self.assetsFolderPath), sanitizePath(uid), '_contentstack_' + sanitizePath(uid) + '.json');
-                    fileHelper.writeFileSync(assetVersionInfoFile, assetVersionInfo);
-                    return resolve();
-                }
-            }
-            const queryrequestOption = {
-                version: version,
-                include_publish_details: true,
-                except: {
-                    BASE: self.invalidKeys,
-                },
-            };
-            self.stackAPIClient
-                .asset(uid)
-                .fetch(queryrequestOption)
-                .then((versionedAssetJSONResponse) => {
-                self
-                    .downloadAsset(versionedAssetJSONResponse)
-                    .then(() => {
-                    assetVersionInfo.splice(0, 0, versionedAssetJSONResponse);
-                    // Remove duplicates
-                    assetVersionInfo = _.uniqWith(assetVersionInfo, _.isEqual);
-                    self.getVersionedAssetJSON(uid, --version, assetVersionInfo).then(resolve).catch(reject);
-                })
-                    .catch(reject);
-            })
-                .catch((error) => {
-                log(self.config, error, 'error');
-                if (error.status === 408) {
-                    console.log('retrying', uid);
-                    // retrying when timeout
-                    self.assetDownloadRetry[uid + version]
-                        ? ++self.assetDownloadRetry[uid + version]
-                        : (self.assetDownloadRetry[uid + version] = 1);
-                    return self.getVersionedAssetJSON(uid, version, assetVersionInfo).then(resolve).catch(reject);
-                }
-                reject(error);
-            });
-        });
-    }
-    downloadAsset(asset) {
-        const self = this;
-        return new Promise(async (resolve, reject) => {
-            if (!validateUids(asset.uid) && !validateFileName(asset.filename)) {
-                reject(`UIDs not valid`);
-            }
-            const assetFolderPath = path.resolve(sanitizePath(self.assetsFolderPath), sanitizePath(asset.uid));
-            const assetFilePath = path.resolve(sanitizePath(assetFolderPath), sanitizePath(asset.filename));
-            if (fs.existsSync(assetFilePath)) {
-                log(self.config, 'Skipping download of { title: ' + asset.filename + ', uid: ' + asset.uid + ' }, as they already exist', 'success');
-                return resolve();
-            }
-            self.assetStream = {
-                url: self.config.securedAssets ? `${asset.url}?authtoken=${configHandler.get('authtoken')}` : asset.url,
-            };
-            fileHelper.makeDirectory(assetFolderPath);
-            const assetFileStream = fs.createWriteStream(assetFilePath);
-            self.assetStream.url = encodeURI(self.assetStream.url);
-            self.httpClient
-                .options({ responseType: 'stream' })
-                .get(self.assetStream.url)
-                .then(({ data: assetStreamRequest }) => {
-                if (self.assetConfig.enableDownloadStatus) {
-                    const str = progress({
-                        time: 5000,
-                        length: assetStreamRequest.headers['content-length'],
-                    });
-                    str.on('progress', (progressData) => {
-                        console.log(`${asset.filename}: ${Math.round(progressData.percentage)}%`);
-                    });
-                    assetStreamRequest.pipe(str).pipe(assetFileStream);
-                }
-                assetStreamRequest.pipe(assetFileStream);
-            })
-                .catch((error) => {
-                log(self.config, error, 'error');
-                reject(error);
-            });
-            assetFileStream
-                .on('close', function () {
-                log(self.config, 'Downloaded ' + asset.filename + ': ' + asset.uid + ' successfully!', 'success');
-                return resolve();
-            })
-                .on('error', (error) => {
-                log(self.config, `Download ${asset.filename}: ${asset.uid} failed!`, 'error');
-                log(self.config, error, 'error');
-                reject(error);
-            });
-        });
-    }
-    getFolders() {
-        const self = this;
-        return new Promise((resolve, reject) => {
-            return self
-                .getAssetCount(true)
-                .then((count) => {
-                if (count === 0) {
-                    log(self.config, 'No folders were found in the stack', 'success');
-                    return resolve();
-                }
-                return self
-                    .getFolderDetails(0, count)
-                    .then(function () {
-                    log(self.config, chalk.green('Exported asset-folders successfully!'), 'success');
-                    return resolve();
-                })
-                    .catch(function (error) {
-                    log(self.config, error, 'error');
-                    reject(error);
-                });
-            })
-                .catch(function (error) {
-                log(self.config, error, 'error');
-                reject(error);
-            });
-        });
-    }
-    getFolderDetails(skip, tCount) {
-        const self = this;
-        return new Promise((resolve, reject) => {
-            if (typeof skip !== 'number') {
-                skip = 0;
-            }
-            if (skip > tCount) {
-                fileHelper.writeFileSync(self.folderJSONPath, self.folderContents);
-                return resolve();
-            }
-            const queryRequestObj = {
-                skip: skip,
-                include_folders: true,
-                query: { is_dir: true },
-            };
-            self.stackAPIClient
-                .asset()
-                .query(queryRequestObj)
-                .find()
-                .then((folderDetailsResponse) => {
-                for (let i in folderDetailsResponse.items) {
-                    self.folderContents.push(folderDetailsResponse.items[i]);
-                }
-                skip += 100;
-                return self.getFolderDetails(skip, tCount).then(resolve).catch(reject);
-            })
-                .catch((error) => {
-                log(self.config, error, 'error');
-            });
-        });
-    }
-};

package/lib/export/modules-js/content-types.d.ts

@@ -1,21 +0,0 @@
-export = ContentTypesExport;
-declare class ContentTypesExport {
-    constructor(exportConfig: any, stackAPIClient: any);
-    stackAPIClient: any;
-    exportConfig: any;
-    contentTypesConfig: any;
-    qs: {
-        include_count: boolean;
-        asc: string;
-        limit: any;
-        include_global_field_schema: boolean;
-    };
-    contentTypesPath: string;
-    contentTypes: any[];
-    fetchConcurrency: any;
-    writeConcurrency: any;
-    start(): Promise<void>;
-    getContentTypes(skip?: number): any;
-    sanitizeAttribs(contentTypes: any): any[];
-    writeContentTypes(contentTypes: any): Promise<any>;
-}

package/lib/export/modules-js/content-types.js

@@ -1,76 +0,0 @@
-const path = require('path');
-const chalk = require('chalk');
-const { fileHelper, executeTask, formatError, log } = require('../../utils');
-const { sanitizePath } = require('@contentstack/cli-utilities');
-class ContentTypesExport {
-    constructor(exportConfig, stackAPIClient) {
-        this.stackAPIClient = stackAPIClient;
-        this.exportConfig = exportConfig;
-        this.contentTypesConfig = exportConfig.modules.content_types;
-        this.qs = {
-            include_count: true,
-            asc: 'updated_at',
-            limit: this.contentTypesConfig.limit,
-            include_global_field_schema: true,
-        };
-        // If content type id is provided then use it as part of query
-        if (Array.isArray(this.exportConfig.contentTypes) && this.exportConfig.contentTypes.length > 0) {
-            this.qs.uid = { $in: this.exportConfig.contentTypes };
-        }
-        this.contentTypesPath = path.resolve(sanitizePath(exportConfig.data), sanitizePath(exportConfig.branchName) || '', sanitizePath(this.contentTypesConfig.dirName));
-        this.contentTypes = [];
-        this.fetchConcurrency = this.contentTypesConfig.fetchConcurrency || this.exportConfig.fetchConcurrency;
-        this.writeConcurrency = this.contentTypesConfig.writeConcurrency || this.exportConfig.writeConcurrency;
-    }
-    async start() {
-        try {
-            log(this.exportConfig, 'Starting content type export', 'success');
-            await fileHelper.makeDirectory(this.contentTypesPath);
-            await this.getContentTypes();
-            await this.writeContentTypes(this.contentTypes);
-            log(this.exportConfig, chalk.green('Content type(s) exported successfully'), 'success');
-        }
-        catch (error) {
-            log(this.exportConfig, `Failed to export content types ${formatError(error)}`, 'error');
-            throw new Error('Failed to export content types');
-        }
-    }
-    async getContentTypes(skip = 0) {
-        if (skip) {
-            this.qs.skip = skip;
-        }
-        const contentTypeSearchResponse = await this.stackAPIClient.contentType().query(this.qs).find();
-        if (Array.isArray(contentTypeSearchResponse.items) && contentTypeSearchResponse.items.length > 0) {
-            let updatedContentTypes = this.sanitizeAttribs(contentTypeSearchResponse.items);
-            this.contentTypes.push(...updatedContentTypes);
-            skip += this.contentTypesConfig.limit;
-            if (skip > contentTypeSearchResponse.count) {
-                return;
-            }
-            return await this.getContentTypes(skip);
-        }
-        else {
-            log(this.exportConfig, 'No content types returned for the given query', 'info');
-        }
-    }
-    sanitizeAttribs(contentTypes) {
-        let updatedContentTypes = [];
-        contentTypes.forEach((contentType) => {
-            for (let key in contentType) {
-                if (this.contentTypesConfig.validKeys.indexOf(key) === -1) {
-                    delete contentType[key];
-                }
-            }
-            updatedContentTypes.push(contentType);
-        });
-        return updatedContentTypes;
-    }
-    async writeContentTypes(contentTypes) {
-        function write(contentType) {
-            return fileHelper.writeFile(path.join(sanitizePath(this.contentTypesPath), `${sanitizePath(contentType.uid === 'schema' ? 'schema|1' : contentType.uid)}.json`), contentType);
-        }
-        await executeTask(contentTypes, write.bind(this), { concurrency: this.writeConcurrency });
-        return fileHelper.writeFile(path.join(this.contentTypesPath, 'schema.json'), contentTypes);
-    }
-}
-module.exports = ContentTypesExport;