@contentstack/cli-cm-export 1.5.8 → 1.6.1

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

@@ -0,0 +1,54 @@
+import { ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class ExportAssets extends BaseClass {
+    private assetsRootPath;
+    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[];
+    };
+    private assetsFolder;
+    versionedAssets: Record<string, unknown>[];
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    get commonQueryParam(): Record<string, unknown>;
+    start(): Promise<void>;
+    /**
+     * @method getAssetsFolders
+     * @param {number} totalCount number
+     * @returns Promise<any|void>
+     */
+    getAssetsFolders(totalCount: number | void): Promise<Promise<void> | void>;
+    /**
+     * @method getAssets
+     * @param totalCount number
+     * @returns Promise<void>
+     */
+    getAssets(totalCount: number | void): Promise<any | void>;
+    /**
+     * @method getVersionedAssets
+     * @returns Promise<any|void>
+     */
+    getVersionedAssets(): Promise<any | void>;
+    /**
+     * @method getAssetsCount
+     * @param isDir boolean
+     * @returns Promise<number|undefined>
+     */
+    getAssetsCount(isDir?: boolean): Promise<number | void>;
+    /**
+     * @method downloadAssets
+     * @returns Promise<any|void>
+     */
+    downloadAssets(): Promise<any | void>;
+}

package/lib/export/modules/assets.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const chunk_1 = tslib_1.__importDefault(require("lodash/chunk"));
+const first_1 = tslib_1.__importDefault(require("lodash/first"));
+const merge_1 = tslib_1.__importDefault(require("lodash/merge"));
+const filter_1 = tslib_1.__importDefault(require("lodash/filter"));
+const uniqBy_1 = tslib_1.__importDefault(require("lodash/uniqBy"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const entries_1 = tslib_1.__importDefault(require("lodash/entries"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const includes_1 = tslib_1.__importDefault(require("lodash/includes"));
+const progress_stream_1 = tslib_1.__importDefault(require("progress-stream"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ExportAssets extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.assetConfig = config_1.default.modules.assets;
+        this.assetsFolder = [];
+        this.versionedAssets = [];
+    }
+    get commonQueryParam() {
+        return {
+            skip: 0,
+            asc: 'created_at',
+            include_count: false,
+        };
+    }
+    async start() {
+        this.assetsRootPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.assetConfig.dirName);
+        // NOTE step 1: Get assets and it's folder count in parallel
+        const [assetsCount, assetsFolderCount] = await Promise.all([this.getAssetsCount(), this.getAssetsCount(true)]);
+        // NOTE step 2: Get assets and it's folder data in parallel
+        await Promise.all([this.getAssetsFolders(assetsFolderCount), this.getAssets(assetsCount)]);
+        // NOTE step 3: Get versioned assets
+        if (!(0, isEmpty_1.default)(this.versionedAssets) && this.assetConfig.includeVersionedAssets) {
+            await this.getVersionedAssets();
+        }
+        // NOTE step 4: Download all assets
+        await this.downloadAssets();
+        (0, utils_1.log)(this.exportConfig, 'Assets exported successfully.!', 'info');
+    }
+    /**
+     * @method getAssetsFolders
+     * @param {number} totalCount number
+     * @returns Promise<any|void>
+     */
+    getAssetsFolders(totalCount) {
+        if (!totalCount)
+            return Promise.resolve();
+        const queryParam = Object.assign(Object.assign({}, this.commonQueryParam), { query: { is_dir: true } });
+        const onSuccess = ({ response: { items } }) => {
+            if (!(0, isEmpty_1.default)(items))
+                this.assetsFolder.push(...items);
+        };
+        const onReject = ({ error }) => {
+            (0, utils_1.log)(this.exportConfig, 'Export asset folder query failed', 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        };
+        return this.makeConcurrentCall({
+            totalCount,
+            apiParams: {
+                queryParam,
+                module: 'assets',
+                reject: onReject,
+                resolve: onSuccess,
+            },
+            module: 'assets folders',
+            concurrencyLimit: this.assetConfig.fetchConcurrency,
+        }).then(() => {
+            if (!(0, isEmpty_1.default)(this.assetsFolder)) {
+                new cli_utilities_1.FsUtility({ basePath: this.assetsRootPath }).writeFile((0, node_path_1.resolve)(this.assetsRootPath, 'folders.json'), this.assetsFolder);
+            }
+            (0, utils_1.log)(this.exportConfig, 'Assets folder Exported successfully.!', 'info');
+        });
+    }
+    /**
+     * @method getAssets
+     * @param totalCount number
+     * @returns Promise<void>
+     */
+    getAssets(totalCount) {
+        if (!totalCount)
+            return Promise.resolve();
+        let fs;
+        let metaHandler;
+        const queryParam = Object.assign(Object.assign({}, this.commonQueryParam), { include_publish_details: true, except: { BASE: this.assetConfig.invalidKeys } });
+        if (this.assetConfig.includeVersionedAssets) {
+            const customHandler = (array) => {
+                const versionAssets = (0, filter_1.default)(array, ({ _version }) => _version > 1);
+                if (!(0, isEmpty_1.default)(versionAssets)) {
+                    this.versionedAssets.push(...(0, map_1.default)(versionAssets, ({ uid, _version }) => ({
+                        [uid]: _version,
+                    })));
+                }
+            };
+            metaHandler = customHandler;
+        }
+        const onReject = ({ error }) => {
+            (0, utils_1.log)(this.exportConfig, 'Export asset query failed', 'error');
+            (0, utils_1.log)(this.exportConfig, error.message, 'error');
+        };
+        const onSuccess = ({ response: { items } }) => {
+            if (!fs && !(0, isEmpty_1.default)(items)) {
+                fs = new cli_utilities_1.FsUtility({
+                    metaHandler,
+                    moduleName: 'assets',
+                    indexFileName: 'assets.json',
+                    basePath: this.assetsRootPath,
+                    chunkFileSize: this.assetConfig.chunkFileSize,
+                    metaPickKeys: (0, merge_1.default)(['uid', 'url', 'filename'], this.assetConfig.assetsMetaKeys),
+                });
+            }
+            if (!(0, isEmpty_1.default)(items))
+                fs === null || fs === void 0 ? void 0 : fs.writeIntoFile(items, { mapKeyVal: true });
+        };
+        return this.makeConcurrentCall({
+            module: 'assets',
+            totalCount,
+            apiParams: {
+                queryParam,
+                module: 'assets',
+                reject: onReject,
+                resolve: onSuccess,
+            },
+            concurrencyLimit: this.assetConfig.fetchConcurrency,
+        }).then(() => {
+            fs === null || fs === void 0 ? void 0 : fs.completeFile(true);
+            (0, utils_1.log)(this.exportConfig, 'Assets metadata exported successfully.!', 'info');
+        });
+    }
+    /**
+     * @method getVersionedAssets
+     * @returns Promise<any|void>
+     */
+    getVersionedAssets() {
+        let fs;
+        const queryParam = Object.assign(Object.assign({}, this.commonQueryParam), { include_publish_details: true, except: { BASE: this.assetConfig.invalidKeys } });
+        const versionedAssets = (0, map_1.default)(this.versionedAssets, (element) => {
+            const batch = [];
+            const [uid, version] = (0, first_1.default)((0, entries_1.default)(element));
+            for (let index = 1; index < version; index++) {
+                batch.push({ [uid]: index });
+            }
+            return batch;
+        }).flat();
+        const apiBatches = (0, chunk_1.default)(versionedAssets, this.assetConfig.fetchConcurrency);
+        const promisifyHandler = (input) => {
+            const { index, batchIndex, apiParams, isLastRequest } = input;
+            const batch = apiBatches[batchIndex][index];
+            const [uid, version] = (0, first_1.default)((0, entries_1.default)(batch));
+            if (apiParams === null || apiParams === void 0 ? void 0 : apiParams.queryParam) {
+                apiParams.uid = uid;
+                apiParams.queryParam.version = version;
+                return this.makeAPICall(apiParams, isLastRequest);
+            }
+            return Promise.resolve();
+        };
+        const onSuccess = ({ response }) => {
+            if (!fs && !(0, isEmpty_1.default)(response)) {
+                fs = new cli_utilities_1.FsUtility({
+                    moduleName: 'assets',
+                    indexFileName: 'versioned-assets.json',
+                    chunkFileSize: this.assetConfig.chunkFileSize,
+                    basePath: (0, node_path_1.resolve)(this.assetsRootPath, 'versions'),
+                    metaPickKeys: (0, merge_1.default)(['uid', 'url', 'filename', '_version'], this.assetConfig.assetsMetaKeys),
+                });
+            }
+            if (!(0, isEmpty_1.default)(response))
+                fs === null || fs === void 0 ? void 0 : fs.writeIntoFile([response], {
+                    mapKeyVal: true,
+                    keyName: ['uid', '_version'],
+                });
+        };
+        const onReject = ({ error }) => {
+            (0, utils_1.log)(this.exportConfig, 'Export versioned asset query failed', 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        };
+        return this.makeConcurrentCall({
+            apiBatches,
+            apiParams: {
+                queryParam,
+                module: 'asset',
+                reject: onReject,
+                resolve: onSuccess,
+            },
+            module: 'versioned assets',
+            totalCount: versionedAssets.length,
+            concurrencyLimit: this.assetConfig.fetchConcurrency,
+        }, promisifyHandler).then(() => {
+            fs === null || fs === void 0 ? void 0 : fs.completeFile(true);
+            (0, utils_1.log)(this.exportConfig, 'Assets folder Exported successfully.!', 'info');
+        });
+    }
+    /**
+     * @method getAssetsCount
+     * @param isDir boolean
+     * @returns Promise<number|undefined>
+     */
+    getAssetsCount(isDir = false) {
+        const queryParam = Object.assign(Object.assign({ limit: 1 }, this.commonQueryParam), { skip: 10 ** 100 });
+        if (isDir)
+            queryParam.query = { is_dir: true };
+        return this.stack
+            .asset()
+            .query(queryParam)
+            .count()
+            .then(({ assets }) => assets)
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, 'Get count query failed', 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    /**
+     * @method downloadAssets
+     * @returns Promise<any|void>
+     */
+    async downloadAssets() {
+        const fs = new cli_utilities_1.FsUtility({
+            fileExt: 'json',
+            createDirIfNotExist: false,
+            basePath: this.assetsRootPath,
+        });
+        const assetsMetaData = fs.getPlainMeta();
+        let listOfAssets = (0, values_1.default)(assetsMetaData).flat();
+        if (this.assetConfig.includeVersionedAssets) {
+            const versionedAssetsMetaData = fs.getPlainMeta((0, node_path_1.resolve)(this.assetsRootPath, 'versions', 'metadata.json'));
+            listOfAssets.push(...(0, values_1.default)(versionedAssetsMetaData).flat());
+        }
+        listOfAssets = (0, uniqBy_1.default)(listOfAssets, 'url');
+        const apiBatches = (0, chunk_1.default)(listOfAssets, this.assetConfig.downloadLimit);
+        const downloadedAssetsDirs = await (0, cli_utilities_1.getDirectories)((0, node_path_1.resolve)(this.assetsRootPath, 'files'));
+        const onSuccess = ({ response: { data }, additionalInfo }) => {
+            const { asset } = additionalInfo;
+            const assetFolderPath = (0, node_path_1.resolve)(this.assetsRootPath, 'files', asset.uid);
+            const assetFilePath = (0, node_path_1.resolve)(assetFolderPath, asset.filename);
+            if (!(0, includes_1.default)(downloadedAssetsDirs, asset.uid)) {
+                fs.createFolderIfNotExist(assetFolderPath);
+            }
+            const assetWriterStream = (0, node_fs_1.createWriteStream)(assetFilePath);
+            assetWriterStream.on('error', (error) => {
+                (0, utils_1.log)(this.exportConfig, `Downloaded failed ${asset.filename}: ${asset.uid}!`, 'error');
+                (0, utils_1.log)(this.exportConfig, error, 'error');
+            });
+            /**
+             * NOTE if pipe not working as expected add the following code below to fix the issue
+             * https://oramind.com/using-streams-efficiently-in-nodejs/
+             * import * as stream from "stream";
+             * import { promisify } from "util";
+             * const finished = promisify(stream.finished);
+             * await finished(assetWriterStream);
+             */
+            if (this.assetConfig.enableDownloadStatus) {
+                const str = (0, progress_stream_1.default)({
+                    time: 5000,
+                    length: data.headers['content-length'],
+                });
+                str.on('progress', function (progressData) {
+                    console.log(`${asset.filename}: ${Math.round(progressData.percentage)}%`);
+                });
+                data.pipe(str).pipe(assetWriterStream);
+            }
+            else {
+                data.pipe(assetWriterStream);
+            }
+            (0, utils_1.log)(this.exportConfig, `Downloaded ${asset.filename}: ${asset.uid} successfully!`, 'success');
+        };
+        const onReject = ({ error, additionalInfo }) => {
+            const { asset } = additionalInfo;
+            (0, utils_1.log)(this.exportConfig, `Downloaded failed ${asset.filename}: ${asset.uid}!`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        };
+        const promisifyHandler = (input) => {
+            const { index, batchIndex } = input;
+            const asset = apiBatches[batchIndex][index];
+            const url = this.assetConfig.securedAssets
+                ? `${asset.url}?authtoken=${cli_utilities_1.configHandler.get('authtoken')}`
+                : asset.url;
+            return this.makeAPICall({
+                reject: onReject,
+                resolve: onSuccess,
+                url: encodeURI(url),
+                module: 'download-asset',
+                additionalInfo: { asset },
+            });
+        };
+        return this.makeConcurrentCall({
+            apiBatches,
+            module: 'assets download',
+            totalCount: listOfAssets.length,
+            concurrencyLimit: this.assetConfig.downloadLimit,
+        }, promisifyHandler).then(() => {
+            (0, utils_1.log)(this.exportConfig, 'Assets download completed successfully.!', 'info');
+        });
+    }
+}
+exports.default = ExportAssets;

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

@@ -0,0 +1,48 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+export type ApiOptions = {
+    uid?: string;
+    url?: string;
+    module: ApiModuleType;
+    queryParam?: Record<any, any>;
+    resolve: (value: any) => void;
+    reject: (error: any) => void;
+    additionalInfo?: Record<any, any>;
+};
+export type EnvType = {
+    module: string;
+    totalCount: number;
+    apiBatches?: number[];
+    concurrencyLimit: number;
+    apiParams?: ApiOptions;
+};
+export type CustomPromiseHandlerInput = {
+    index: number;
+    batchIndex: number;
+    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 default abstract class BaseClass {
+    readonly client: any;
+    exportConfig: ExportConfig;
+    constructor({ exportConfig, stackAPIClient }: Omit<ModuleClassParams, 'moduleName'>);
+    get stack(): any;
+    delay(ms: number): Promise<void>;
+    makeConcurrentCall(env: EnvType, promisifyHandler?: CustomPromiseHandler): Promise<void>;
+    /**
+     * @method logMsgAndWaitIfRequired
+     * @param module string
+     * @param start number
+     * @param batchNo number
+     * @returns Promise<void>
+     */
+    logMsgAndWaitIfRequired(module: string, start: number, batchNo: number): Promise<void>;
+    /**
+     * @method makeAPICall
+     * @param {Record<string, any>} options - Api related params
+     * @param {Record<string, any>} isLastRequest - Boolean
+     * @returns Promise<any>
+     */
+    makeAPICall({ module: moduleName, reject, resolve, url, uid, additionalInfo, queryParam }: ApiOptions, isLastRequest?: boolean): Promise<any>;
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const fill_1 = tslib_1.__importDefault(require("lodash/fill"));
+const last_1 = tslib_1.__importDefault(require("lodash/last"));
+const chunk_1 = tslib_1.__importDefault(require("lodash/chunk"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const entries_1 = tslib_1.__importDefault(require("lodash/entries"));
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+const utils_1 = require("../../utils");
+class BaseClass {
+    constructor({ exportConfig, stackAPIClient }) {
+        this.client = stackAPIClient;
+        this.exportConfig = exportConfig;
+    }
+    get stack() {
+        return this.client;
+    }
+    delay(ms) {
+        /* eslint-disable no-promise-executor-return */
+        return new Promise((resolve) => setTimeout(resolve, ms <= 0 ? 0 : ms));
+    }
+    makeConcurrentCall(env, promisifyHandler) {
+        const { module, apiBatches, totalCount, apiParams, concurrencyLimit } = env;
+        /* eslint-disable no-async-promise-executor */
+        return new Promise(async (resolve) => {
+            let batchNo = 0;
+            let isLastRequest = false;
+            const batch = (0, fill_1.default)(Array.from({ length: Number.parseInt(String(totalCount / 100), 10) }), 100);
+            if (totalCount % 100)
+                batch.push(100);
+            const batches = apiBatches ||
+                (0, chunk_1.default)((0, map_1.default)(batch, (skip, i) => skip * i), concurrencyLimit);
+            /* eslint-disable no-promise-executor-return */
+            if ((0, isEmpty_1.default)(batches))
+                return resolve();
+            for (const [batchIndex, batch] of (0, entries_1.default)(batches)) {
+                batchNo += 1;
+                const allPromise = [];
+                const start = Date.now();
+                for (const [index, element] of (0, entries_1.default)(batch)) {
+                    let promise;
+                    isLastRequest = (0, isEqual_1.default)((0, last_1.default)(batch), element) && (0, isEqual_1.default)((0, last_1.default)(batches), batch);
+                    if (promisifyHandler instanceof Function) {
+                        promise = promisifyHandler({
+                            apiParams,
+                            isLastRequest,
+                            index: Number(index),
+                            batchIndex: Number(batchIndex),
+                        });
+                    }
+                    else if (apiParams === null || apiParams === void 0 ? void 0 : apiParams.queryParam) {
+                        apiParams.queryParam.skip = element;
+                        promise = this.makeAPICall(apiParams, isLastRequest);
+                    }
+                    allPromise.push(promise);
+                }
+                /* eslint-disable no-await-in-loop */
+                await Promise.allSettled(allPromise);
+                /* eslint-disable no-await-in-loop */
+                await this.logMsgAndWaitIfRequired(module, start, batchNo);
+                if (isLastRequest)
+                    resolve();
+            }
+        });
+    }
+    /**
+     * @method logMsgAndWaitIfRequired
+     * @param module string
+     * @param start number
+     * @param batchNo number
+     * @returns Promise<void>
+     */
+    async logMsgAndWaitIfRequired(module, start, batchNo) {
+        const end = Date.now();
+        const exeTime = end - start;
+        (0, utils_1.log)(this.exportConfig, `Batch No. ${batchNo} of ${module} is complete.`, 'success');
+        if (this.exportConfig.modules.assets.displayExecutionTime) {
+            console.log(`Time taken to execute: ${exeTime} milliseconds; wait time: ${exeTime < 1000 ? 1000 - exeTime : 0} milliseconds`);
+        }
+        if (exeTime < 1000)
+            await this.delay(1000 - exeTime);
+    }
+    /**
+     * @method makeAPICall
+     * @param {Record<string, any>} options - Api related params
+     * @param {Record<string, any>} isLastRequest - Boolean
+     * @returns Promise<any>
+     */
+    makeAPICall({ module: moduleName, reject, resolve, url = '', uid = '', additionalInfo, queryParam = {} }, isLastRequest = false) {
+        switch (moduleName) {
+            case 'asset':
+                return this.stack
+                    .asset(uid)
+                    .fetch(queryParam)
+                    .then((response) => resolve({ response, isLastRequest, additionalInfo }))
+                    .catch((error) => reject({ error, isLastRequest, additionalInfo }));
+            case 'assets':
+                return this.stack
+                    .asset()
+                    .query(queryParam)
+                    .find()
+                    .then((response) => resolve({ response, isLastRequest, additionalInfo }))
+                    .catch((error) => reject({ error, isLastRequest, additionalInfo }));
+            case 'download-asset':
+                return this.stack
+                    .asset()
+                    .download({ url, responseType: 'stream' })
+                    .then((response) => resolve({ response, isLastRequest, additionalInfo }))
+                    .catch((error) => reject({ error, isLastRequest, additionalInfo }));
+            default:
+                return Promise.resolve();
+        }
+    }
+}
+exports.default = BaseClass;

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

@@ -0,0 +1,3 @@
+import { ModuleClassParams } from '../../types';
+export default function startModuleExport(modulePayload: ModuleClassParams): Promise<any>;
+export { default as ExportAssets } from './assets';

package/lib/export/modules/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportAssets = void 0;
+async function startModuleExport(modulePayload) {
+    const { default: ModuleRunner } = await (_a = `./${modulePayload.moduleName}`, Promise.resolve().then(() => __importStar(require(_a))));
+    const moduleRunner = new ModuleRunner(modulePayload);
+    return moduleRunner.start();
+}
+exports.default = startModuleExport;
+var assets_1 = require("./assets");
+Object.defineProperty(exports, "ExportAssets", { enumerable: true, get: function () { return __importDefault(assets_1).default; } });

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

@@ -0,0 +1,16 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class LocaleExport extends BaseClass {
+    private stackAPIClient;
+    exportConfig: ExportConfig;
+    private masterLocaleConfig;
+    private qs;
+    private localeConfig;
+    private localesPath;
+    private masterLocale;
+    private locales;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getLocales(skip?: number): Promise<any>;
+    sanitizeAttribs(locales: Record<string, string>[]): void;
+}

package/lib/export/modules/locales.js

@@ -0,0 +1,68 @@
+"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 LocaleExport extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.stackAPIClient = stackAPIClient;
+        this.localeConfig = exportConfig.modules.locales;
+        this.masterLocaleConfig = exportConfig.modules.masterLocale;
+        this.qs = {
+            include_count: true,
+            asc: 'updated_at',
+            only: {
+                BASE: this.localeConfig.requiredKeys,
+            },
+        };
+        this.localesPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.localeConfig.dirName);
+        this.locales = {};
+        this.masterLocale = {};
+    }
+    async start() {
+        try {
+            (0, utils_1.log)(this.exportConfig, 'Starting locale export', 'success');
+            await utils_1.fsUtil.makeDirectory(this.localesPath);
+            await this.getLocales();
+            utils_1.fsUtil.writeFile(path.join(this.localesPath, this.localeConfig.fileName), this.locales);
+            utils_1.fsUtil.writeFile(path.join(this.localesPath, this.masterLocaleConfig.fileName), this.masterLocale);
+            (0, utils_1.log)(this.exportConfig, 'Completed locale export', 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.exportConfig, `Failed to export locales. ${(0, utils_1.formatError)(error)}`, 'error');
+            throw new Error('Failed to export locales');
+        }
+    }
+    async getLocales(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        let localesFetchResponse = await this.stackAPIClient.locale().query(this.qs).find();
+        if (Array.isArray(localesFetchResponse.items) && localesFetchResponse.items.length > 0) {
+            this.sanitizeAttribs(localesFetchResponse.items);
+            skip += this.localeConfig.limit || 100;
+            if (skip > localesFetchResponse.count) {
+                return;
+            }
+            return await this.getLocales(skip);
+        }
+    }
+    sanitizeAttribs(locales) {
+        locales.forEach((locale) => {
+            for (let key in locale) {
+                if (this.localeConfig.requiredKeys.indexOf(key) === -1) {
+                    delete locale[key];
+                }
+            }
+            if (locale.code === this.exportConfig.master_locale.code) {
+                this.masterLocale[locale.uid] = locale;
+            }
+            else {
+                this.locales[locale.uid] = locale;
+            }
+        });
+    }
+}
+exports.default = LocaleExport;