@contentstack/cli-cm-export 1.6.1 → 1.8.0

package/README.md

@@ -48,7 +48,7 @@ $ npm install -g @contentstack/cli-cm-export
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-export/1.6.1 linux-x64 node-v18.16.1
+@contentstack/cli-cm-export/1.8.0 linux-x64 node-v18.17.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND

package/lib/config/index.js

@@ -60,7 +60,7 @@ const config = {
         labels: {
             dirName: 'labels',
             fileName: 'labels.json',
-            invalidKeys: ['stackHeaders', 'uid', 'urlPath', 'created_at', 'updated_at', 'created_by', 'updated_by'],
+            invalidKeys: ['stackHeaders', 'urlPath', 'created_at', 'updated_at', 'created_by', 'updated_by'],
         },
         webhooks: {
             dirName: 'webhooks',
@@ -137,6 +137,7 @@ const config = {
             // total no of entries fetched in each content type in a single call
             limit: 100,
             dependencies: ['locales', 'content-types'],
+            exportVersions: false,
         },
         extensions: {
             dirName: 'extensions',
@@ -368,7 +369,20 @@ const config = {
         'xh',
         'zu',
     ],
-    updatedModules: ['assets', 'locales'],
+    updatedModules: [
+        'assets',
+        'locales',
+        'extensions',
+        'marketplace-apps',
+        'labels',
+        'webhooks',
+        'custom-roles',
+        'global-fields',
+        'content-types',
+        'entries',
+        'workflows',
+        'stack',
+    ],
     apis: {
         userSession: '/user-session/',
         globalfields: '/global_fields/',

package/lib/export/modules/base-class.d.ts

@@ -18,11 +18,12 @@ export type EnvType = {
 export type CustomPromiseHandlerInput = {
     index: number;
     batchIndex: number;
+    element?: Record<string, any>;
     apiParams?: ApiOptions;
     isLastRequest: boolean;
 };
 export type CustomPromiseHandler = (input: CustomPromiseHandlerInput) => Promise<any>;
-export type ApiModuleType = 'stack' | 'asset' | 'assets' | 'entry' | 'entries' | 'content-type' | 'content-types' | 'stacks' | 'download-asset';
+export type ApiModuleType = 'stack' | 'asset' | 'assets' | 'entry' | 'entries' | 'content-type' | 'content-types' | 'stacks' | 'versioned-entries' | 'download-asset';
 export default abstract class BaseClass {
     readonly client: any;
     exportConfig: ExportConfig;

package/lib/export/modules/base-class.js

@@ -45,6 +45,7 @@ class BaseClass {
                     if (promisifyHandler instanceof Function) {
                         promise = promisifyHandler({
                             apiParams,
+                            element,
                             isLastRequest,
                             index: Number(index),
                             batchIndex: Number(batchIndex),

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

@@ -0,0 +1,15 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class ContentTypesExport extends BaseClass {
+    private stackAPIClient;
+    exportConfig: ExportConfig;
+    private qs;
+    private contentTypesConfig;
+    private contentTypesDirPath;
+    private contentTypes;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getContentTypes(skip?: number): Promise<any>;
+    sanitizeAttribs(contentTypes: Record<string, unknown>[]): Record<string, unknown>[];
+    writeContentTypes(contentTypes: Record<string, unknown>[]): Promise<void>;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ContentTypesExport extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.stackAPIClient = stackAPIClient;
+        this.contentTypesConfig = exportConfig.modules['content-types'];
+        this.qs = {
+            include_count: true,
+            asc: 'updated_at',
+            limit: this.contentTypesConfig.limit,
+            include_global_field_schema: true,
+        };
+        this.contentTypesDirPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.contentTypesConfig.dirName);
+        this.contentTypes = [];
+    }
+    async start() {
+        try {
+            (0, utils_1.log)(this.exportConfig, 'Starting content type export', 'success');
+            await utils_1.fsUtil.makeDirectory(this.contentTypesDirPath);
+            await this.getContentTypes();
+            await this.writeContentTypes(this.contentTypes);
+            (0, utils_1.log)(this.exportConfig, 'Content type(s) exported successfully', 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.exportConfig, `Failed to export content types ${(0, utils_1.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 || 100;
+            if (skip >= contentTypeSearchResponse.count) {
+                return;
+            }
+            return await this.getContentTypes(skip);
+        }
+        else {
+            (0, utils_1.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 utils_1.fsUtil.writeFile(path.join(this.contentTypesDirPath, `${contentType.uid === 'schema' ? 'schema|1' : contentType.uid}.json`), contentType);
+        }
+        await (0, utils_1.executeTask)(contentTypes, write.bind(this), { concurrency: this.exportConfig.writeConcurrency });
+        return utils_1.fsUtil.writeFile(path.join(this.contentTypesDirPath, 'schema.json'), contentTypes);
+    }
+}
+exports.default = ContentTypesExport;

package/lib/export/modules/custom-roles.d.ts

@@ -0,0 +1,16 @@
+import BaseClass from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ExportCustomRoles extends BaseClass {
+    private customRoles;
+    private existingRoles;
+    private customRolesConfig;
+    private sourceLocalesMap;
+    private localesMap;
+    rolesFolderPath: string;
+    customRolesLocalesFilepath: string;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getCustomRoles(): Promise<void>;
+    getLocales(): Promise<void>;
+    getCustomRolesLocales(): Promise<void>;
+}

package/lib/export/modules/custom-roles.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const keys_1 = tslib_1.__importDefault(require("lodash/keys"));
+const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const forEach_1 = tslib_1.__importDefault(require("lodash/forEach"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportCustomRoles extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.customRoles = {};
+        this.customRolesConfig = config_1.default.modules.customRoles;
+        this.existingRoles = { Admin: 1, Developer: 1, 'Content Manager': 1 };
+        this.localesMap = {};
+        this.sourceLocalesMap = {};
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting custom roles export', 'info');
+        this.rolesFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.customRolesConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.rolesFolderPath);
+        this.customRolesLocalesFilepath = (0, node_path_1.resolve)(this.rolesFolderPath, this.customRolesConfig.customRolesLocalesFileName);
+        await this.getCustomRoles();
+        await this.getLocales();
+        await this.getCustomRolesLocales();
+    }
+    async getCustomRoles() {
+        const roles = await this.stack
+            .role()
+            .fetchAll({ include_rules: true, include_permissions: true })
+            .then((data) => data)
+            .catch((err) => (0, utils_1.log)(this.exportConfig, `Failed to fetch roles. ${(0, utils_1.formatError)(err)}`, 'error'));
+        const customRoles = roles.items.filter((role) => !this.existingRoles[role.name]);
+        if (!customRoles.length) {
+            (0, utils_1.log)(this.exportConfig, 'No custom roles were found in the Stack', 'info');
+            return;
+        }
+        customRoles.forEach((role) => {
+            (0, utils_1.log)(this.exportConfig, `'${role === null || role === void 0 ? void 0 : role.name}' role was exported successfully`, 'info');
+            this.customRoles[role.uid] = role;
+        });
+        utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.rolesFolderPath, this.customRolesConfig.fileName), this.customRoles);
+    }
+    async getLocales() {
+        const locales = await this.stack
+            .locale()
+            .query({})
+            .find()
+            .then((data) => data)
+            .catch((err) => (0, utils_1.log)(this.exportConfig, `Failed to fetch locales. ${(0, utils_1.formatError)(err)}`, 'error'));
+        for (const locale of locales.items) {
+            this.sourceLocalesMap[locale.uid] = locale;
+        }
+    }
+    async getCustomRolesLocales() {
+        var _a, _b;
+        for (const role of (0, values_1.default)(this.customRoles)) {
+            const customRole = role;
+            const rulesLocales = (0, find_1.default)(customRole.rules, (rule) => rule.module === 'locale');
+            if ((_a = rulesLocales === null || rulesLocales === void 0 ? void 0 : rulesLocales.locales) === null || _a === void 0 ? void 0 : _a.length) {
+                (0, forEach_1.default)(rulesLocales.locales, (locale) => {
+                    this.localesMap[locale] = 1;
+                });
+            }
+        }
+        if ((_b = (0, keys_1.default)(this.localesMap)) === null || _b === void 0 ? void 0 : _b.length) {
+            for (const locale in this.localesMap) {
+                if (this.sourceLocalesMap[locale] !== undefined) {
+                    const sourceLocale = this.sourceLocalesMap[locale];
+                    sourceLocale === null || sourceLocale === void 0 ? true : delete sourceLocale.stackHeaders;
+                }
+                this.localesMap[locale] = this.sourceLocalesMap[locale];
+            }
+            utils_1.fsUtil.writeFile(this.customRolesLocalesFilepath, this.localesMap);
+        }
+    }
+}
+exports.default = ExportCustomRoles;

package/lib/export/modules/entries.d.ts

@@ -0,0 +1,26 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+import BaseClass, { ApiOptions } from './base-class';
+export default class EntriesExport extends BaseClass {
+    private stackAPIClient;
+    exportConfig: ExportConfig;
+    private entriesConfig;
+    private entriesDirPath;
+    private localesFilePath;
+    private schemaFilePath;
+    private entriesFileHelper;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    createRequestObjects(locales: Array<Record<string, unknown>>, contentTypes: Array<Record<string, unknown>>): Array<Record<string, any>>;
+    getEntries(options: Record<string, any>): Promise<any>;
+    fetchEntriesVersions(entries: any, options: {
+        locale: string;
+        contentType: string;
+        versionedEntryPath: string;
+    }): Promise<void>;
+    entryVersionHandler({ apiParams, element: entry, }: {
+        apiParams: ApiOptions;
+        element: Record<string, string>;
+        isLastRequest: boolean;
+    }): Promise<unknown>;
+    getEntryByVersion(options: any, entry: Record<string, any>, entries?: Array<Record<string, any>>): Promise<any[]>;
+}

package/lib/export/modules/entries.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class EntriesExport extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.stackAPIClient = stackAPIClient;
+        this.exportConfig = exportConfig;
+        this.entriesConfig = exportConfig.modules.entries;
+        this.entriesDirPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.entriesConfig.dirName);
+        this.localesFilePath = path.resolve(exportConfig.data, exportConfig.branchName || '', exportConfig.modules.locales.dirName, exportConfig.modules.locales.fileName);
+        this.schemaFilePath = path.resolve(exportConfig.data, exportConfig.branchName || '', exportConfig.modules.content_types.dirName, 'schema.json');
+    }
+    async start() {
+        var _a;
+        try {
+            (0, utils_1.log)(this.exportConfig, 'Starting entries export', 'info');
+            const locales = utils_1.fsUtil.readFile(this.localesFilePath);
+            const contentTypes = utils_1.fsUtil.readFile(this.schemaFilePath);
+            if (contentTypes.length === 0) {
+                (0, utils_1.log)(this.exportConfig, 'No content types found to export entries', 'info');
+                return;
+            }
+            const entryRequestOptions = this.createRequestObjects(locales, contentTypes);
+            for (let entryRequestOption of entryRequestOptions) {
+                (0, utils_1.log)(this.exportConfig, `Starting export of entries of content type - ${entryRequestOption.contentType} locale - ${entryRequestOption.locale}`, 'info');
+                await this.getEntries(entryRequestOption);
+                (_a = this.entriesFileHelper) === null || _a === void 0 ? void 0 : _a.completeFile(true);
+                (0, utils_1.log)(this.exportConfig, `Exported entries of type '${entryRequestOption.contentType}' locale '${entryRequestOption.locale}'`, 'success');
+            }
+            (0, utils_1.log)(this.exportConfig, 'Entries exported successfully', 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.exportConfig, `Failed to export entries ${(0, utils_1.formatError)(error)}`, 'error');
+            throw new Error('Failed to export entries');
+        }
+    }
+    createRequestObjects(locales, contentTypes) {
+        let requestObjects = [];
+        contentTypes.forEach((contentType) => {
+            if (Object.keys(locales).length !== 0) {
+                for (let locale in locales) {
+                    requestObjects.push({
+                        contentType: contentType.uid,
+                        locale: locales[locale].code,
+                    });
+                }
+            }
+            requestObjects.push({
+                contentType: contentType.uid,
+                locale: this.exportConfig.master_locale.code,
+            });
+        });
+        return requestObjects;
+    }
+    async getEntries(options) {
+        options.skip = options.skip || 0;
+        let requestObject = {
+            locale: options.locale,
+            skip: options.skip,
+            limit: this.entriesConfig.limit,
+            include_count: true,
+            include_publish_details: true,
+            query: {
+                locale: options.locale,
+            },
+        };
+        const entriesSearchResponse = await this.stackAPIClient
+            .contentType(options.contentType)
+            .entry()
+            .query(requestObject)
+            .find();
+        if (Array.isArray(entriesSearchResponse.items) && entriesSearchResponse.items.length > 0) {
+            if (options.skip === 0) {
+                const entryBasePath = path.join(this.entriesDirPath, options.contentType, options.locale);
+                await utils_1.fsUtil.makeDirectory(entryBasePath);
+                this.entriesFileHelper = new cli_utilities_1.FsUtility({
+                    moduleName: 'entries',
+                    indexFileName: 'index.json',
+                    basePath: entryBasePath,
+                    chunkFileSize: this.entriesConfig.chunkFileSize,
+                    keepMetadata: false,
+                    omitKeys: this.entriesConfig.invalidKeys,
+                });
+            }
+            this.entriesFileHelper.writeIntoFile(entriesSearchResponse.items, { mapKeyVal: true });
+            if (this.entriesConfig.exportVersions) {
+                let versionedEntryPath = path.join(this.entriesDirPath, options.contentType, options.locale, 'versions');
+                utils_1.fsUtil.makeDirectory(versionedEntryPath);
+                await this.fetchEntriesVersions(entriesSearchResponse.items, {
+                    locale: options.locale,
+                    contentType: options.contentType,
+                    versionedEntryPath,
+                });
+            }
+            options.skip += this.entriesConfig.limit || 100;
+            if (options.skip >= entriesSearchResponse.count) {
+                return Promise.resolve(true);
+            }
+            return await this.getEntries(options);
+        }
+    }
+    async fetchEntriesVersions(entries, options) {
+        const onSuccess = ({ response, apiData: entry }) => {
+            utils_1.fsUtil.writeFile(path.join(options.versionedEntryPath, `${entry.uid}.json`), response);
+            (0, utils_1.log)(this.exportConfig, `Exported versioned entries of type '${options.contentType}' locale '${options.locale}'`, 'success');
+        };
+        const onReject = ({ error, apiData: { uid } = undefined }) => {
+            (0, utils_1.log)(this.exportConfig, `failed to export versions of entry ${uid}`, 'error');
+            (0, utils_1.log)(this.exportConfig, (0, utils_1.formatError)(error), 'error');
+        };
+        return await this.makeConcurrentCall({
+            apiBatches: [entries],
+            module: 'versioned-entries',
+            totalCount: entries.length,
+            concurrencyLimit: this.entriesConfig.batchLimit,
+            apiParams: {
+                module: 'versioned-entries',
+                queryParam: options,
+                resolve: onSuccess,
+                reject: onReject,
+            },
+        }, this.entryVersionHandler.bind(this));
+    }
+    async entryVersionHandler({ apiParams, element: entry, }) {
+        return new Promise(async (resolve, reject) => {
+            return await this.getEntryByVersion(apiParams.queryParam, entry)
+                .then((response) => {
+                apiParams.resolve({
+                    response,
+                    apiData: entry,
+                });
+                resolve(true);
+            })
+                .catch((error) => {
+                apiParams.reject({
+                    error,
+                    apiData: entry,
+                });
+                reject(true);
+            });
+        });
+    }
+    async getEntryByVersion(options, entry, entries = []) {
+        const queryRequestObject = {
+            locale: options.locale,
+            except: {
+                BASE: this.entriesConfig.invalidKeys,
+            },
+            version: entry._version,
+        };
+        const entryResponse = await this.stackAPIClient
+            .contentType(options.contentType)
+            .entry(entry.uid)
+            .fetch(queryRequestObject);
+        entries.push(entryResponse);
+        if (--entry._version > 0) {
+            return await this.getEntryByVersion(options, entry, entries);
+        }
+        return entries;
+    }
+}
+exports.default = EntriesExport;

package/lib/export/modules/environments.d.ts

@@ -0,0 +1,12 @@
+import BaseClass from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ExportEnvironments extends BaseClass {
+    private environments;
+    private environmentConfig;
+    environmentsFolderPath: string;
+    private qs;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getEnvironments(skip?: number): Promise<void>;
+    sanitizeAttribs(environments: Record<string, string>[]): void;
+}

package/lib/export/modules/environments.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportEnvironments extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.environments = {};
+        this.environmentConfig = config_1.default.modules.environments;
+        this.qs = { include_count: true };
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting environment export', 'info');
+        this.environmentsFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.environmentConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.environmentsFolderPath);
+        await this.getEnvironments();
+        if (this.environments === undefined || (0, isEmpty_1.default)(this.environments)) {
+            (0, utils_1.log)(this.exportConfig, 'No environments found', 'info');
+        }
+        else {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.environmentsFolderPath, this.environmentConfig.fileName), this.environments);
+            (0, utils_1.log)(this.exportConfig, 'All the environments have been exported successfully!', 'success');
+        }
+    }
+    async getEnvironments(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        await this.stack
+            .environment()
+            .query(this.qs)
+            .find()
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                this.sanitizeAttribs(items);
+                skip += this.environmentConfig.limit || 100;
+                if (skip >= count) {
+                    return;
+                }
+                return await this.getEnvironments(skip);
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export environments. ${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    sanitizeAttribs(environments) {
+        var _a;
+        for (let index = 0; index < (environments === null || environments === void 0 ? void 0 : environments.length); index++) {
+            const extUid = environments[index].uid;
+            const envName = (_a = environments[index]) === null || _a === void 0 ? void 0 : _a.name;
+            this.environments[extUid] = (0, omit_1.default)(environments[index], ['ACL']);
+            (0, utils_1.log)(this.exportConfig, `'${envName}' environment was exported successfully`, 'success');
+        }
+    }
+}
+exports.default = ExportEnvironments;

package/lib/export/modules/extensions.d.ts

@@ -0,0 +1,12 @@
+import BaseClass from './base-class';
+import { ExtensionsConfig, ModuleClassParams } from '../../types';
+export default class ExportExtensions extends BaseClass {
+    private extensionsFolderPath;
+    private extensions;
+    extensionConfig: ExtensionsConfig;
+    private qs;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getExtensions(skip?: number): Promise<void>;
+    sanitizeAttribs(extensions: Record<string, string>[]): void;
+}

package/lib/export/modules/extensions.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportExtensions extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.extensions = {};
+        this.extensionConfig = config_1.default.modules.extensions;
+        this.qs = { include_count: true };
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting extension export', 'info');
+        this.extensionsFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.extensionConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.extensionsFolderPath);
+        await this.getExtensions();
+        if (this.extensions === undefined || (0, isEmpty_1.default)(this.extensions)) {
+            (0, utils_1.log)(this.exportConfig, 'No extensions found', 'info');
+        }
+        else {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.extensionsFolderPath, this.extensionConfig.fileName), this.extensions);
+            (0, utils_1.log)(this.exportConfig, 'All the extensions have been exported successfully!', 'success');
+        }
+    }
+    async getExtensions(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        await this.stack
+            .extension()
+            .query(this.qs)
+            .find()
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                this.sanitizeAttribs(items);
+                skip += this.extensionConfig.limit || 100;
+                if (skip >= count) {
+                    return;
+                }
+                return await this.getExtensions(skip);
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export extensions. ${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    sanitizeAttribs(extensions) {
+        var _a;
+        for (let index = 0; index < (extensions === null || extensions === void 0 ? void 0 : extensions.length); index++) {
+            const extUid = extensions[index].uid;
+            const extTitle = (_a = extensions[index]) === null || _a === void 0 ? void 0 : _a.title;
+            this.extensions[extUid] = (0, omit_1.default)(extensions[index], ['SYS_ACL']);
+            (0, utils_1.log)(this.exportConfig, `'${extTitle}' extension was exported successfully`, 'success');
+        }
+    }
+}
+exports.default = ExportExtensions;

package/lib/export/modules/global-fields.d.ts

@@ -0,0 +1,14 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class GlobalFieldsExport extends BaseClass {
+    private stackAPIClient;
+    exportConfig: ExportConfig;
+    private qs;
+    private globalFieldsConfig;
+    private globalFieldsDirPath;
+    private globalFields;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getGlobalFields(skip?: number): Promise<any>;
+    sanitizeAttribs(globalFields: Record<string, string>[]): void;
+}