@contentstack/cli-cm-export-query 1.0.0-beta.1 → 1.0.0-beta.11

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Contentstack
+Copyright (c) 2026 Contentstack
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/commands/cm/stacks/export-query.d.ts

@@ -6,6 +6,5 @@ export default class ExportQueryCommand extends Command {
     static examples: string[];
     static usage: string;
     static flags: FlagInput;
-    static aliases: string[];
     run(): Promise<void>;
 }

package/lib/commands/cm/stacks/export-query.js

@@ -16,16 +16,29 @@ class ExportQueryCommand extends cli_command_1.Command {
                 exportQueryConfig.developerHubBaseUrl = this.developerHubUrl;
             }
             this.exportDir = (0, cli_utilities_1.sanitizePath)(exportQueryConfig.exportDir);
-            // Initialize and run query export
+            // Create base context without module name - module field is set dynamically during each module export
+            exportQueryConfig.context = (0, utils_1.createLogContext)(exportQueryConfig);
+            cli_utilities_1.log.debug('Export configuration setup completed', exportQueryConfig.context);
+            // Initialize management API client
             const managementAPIClient = await (0, cli_utilities_1.managementSDKClient)(exportQueryConfig);
+            // Setup and validate branch configuration
+            const stackAPIClient = managementAPIClient.stack({
+                api_key: exportQueryConfig.stackApiKey,
+                management_token: exportQueryConfig.managementToken,
+            });
+            // Setup branches (validate branch or set default to 'main')
+            await (0, utils_1.setupBranches)(exportQueryConfig, stackAPIClient);
+            cli_utilities_1.log.debug('Branch configuration setup completed', exportQueryConfig.context);
+            // Initialize and run query export
+            cli_utilities_1.log.debug('Starting query exporter', exportQueryConfig.context);
             const queryExporter = new query_executor_1.QueryExporter(managementAPIClient, exportQueryConfig);
             await queryExporter.execute();
-            (0, utils_1.log)(exportQueryConfig, 'Query-based export completed successfully!', 'success');
-            (0, utils_1.log)(exportQueryConfig, `Export files saved to: ${this.exportDir}`, 'info');
+            cli_utilities_1.log.debug('Query exporter completed successfully', exportQueryConfig.context);
+            cli_utilities_1.log.success('Query-based export completed successfully!', exportQueryConfig.context);
+            cli_utilities_1.log.info(`Export files saved to: ${this.exportDir}`, exportQueryConfig.context);
         }
         catch (error) {
-            (0, utils_1.log)({ exportDir: this.exportDir }, `Export failed: ${(0, cli_utilities_1.formatError)(error)}`, 'error');
-            throw error;
+            (0, cli_utilities_1.handleAndLogError)(error);
         }
     }
 }
@@ -57,6 +70,11 @@ ExportQueryCommand.flags = {
     }),
     branch: cli_utilities_1.flags.string({
         description: 'Branch name to export from',
+        exclusive: ['branch-alias'],
+    }),
+    'branch-alias': cli_utilities_1.flags.string({
+        description: 'Alias of Branch to export from',
+        exclusive: ['branch'],
     }),
     query: cli_utilities_1.flags.string({
         required: true,
@@ -76,4 +94,3 @@ ExportQueryCommand.flags = {
         description: 'Skip confirmation prompts',
     }),
 };
-ExportQueryCommand.aliases = ['cm:export-query'];

package/lib/core/module-exporter.js

@@ -4,7 +4,6 @@ exports.ModuleExporter = void 0;
 const tslib_1 = require("tslib");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const cli_cm_export_1 = tslib_1.__importDefault(require("@contentstack/cli-cm-export"));
-const logger_1 = require("../utils/logger");
 class ModuleExporter {
     constructor(exportQueryConfig) {
         this.exportedModules = [];
@@ -12,25 +11,28 @@ class ModuleExporter {
     }
     async exportModule(moduleName, options = {}) {
         try {
-            (0, logger_1.log)(this.exportQueryConfig, `Exporting module: ${moduleName}`, 'info');
+            const moduleLogContext = Object.assign(Object.assign({}, this.exportQueryConfig.context), { module: moduleName });
+            cli_utilities_1.log.info(`Exporting module: ${moduleName}`, moduleLogContext);
+            cli_utilities_1.log.debug(`Building export command for module: ${moduleName}`, moduleLogContext);
             // Build command arguments
             const cmd = this.buildExportCommand(moduleName, options);
-            (0, logger_1.log)(this.exportQueryConfig, `Running export command: ${cmd.join(' ')}`, 'debug');
             // Configurable delay
             const delay = this.exportQueryConfig.exportDelayMs || 2000;
             await new Promise((resolve) => setTimeout(resolve, delay));
             // Create export command instance
             await cli_cm_export_1.default.run(cmd);
+            cli_utilities_1.log.debug(`Export command completed for module: ${moduleName}`, moduleLogContext);
             // Read the exported data
             // const data = await this.readExportedData(moduleName, options);
             if (!this.exportedModules.includes(moduleName)) {
                 this.exportedModules.push(moduleName);
             }
             // success message
-            (0, logger_1.log)(this.exportQueryConfig, `Successfully exported ${moduleName}`, 'success');
+            cli_utilities_1.log.success(`Successfully exported ${moduleName}`, moduleLogContext);
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Failed to export ${moduleName}: ${(0, cli_utilities_1.formatError)(error)}`, 'error');
+            const moduleLogContext = Object.assign(Object.assign({}, this.exportQueryConfig.context), { module: moduleName });
+            (0, cli_utilities_1.handleAndLogError)(error, moduleLogContext, `Failed to export ${moduleName}`);
             throw error;
         }
     }

package/lib/core/query-executor.js

@@ -6,7 +6,6 @@ const cli_utilities_1 = require("@contentstack/cli-utilities");
 const path = tslib_1.__importStar(require("path"));
 const query_parser_1 = require("../utils/query-parser");
 const module_exporter_1 = require("./module-exporter");
-const logger_1 = require("../utils/logger");
 const utils_1 = require("../utils");
 const utils_2 = require("../utils");
 const utils_3 = require("../utils");
@@ -23,10 +22,11 @@ class QueryExporter {
         this.moduleExporter = new module_exporter_1.ModuleExporter(exportQueryConfig);
     }
     async execute() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Starting query-based export...', 'info');
+        cli_utilities_1.log.info('Starting query-based export...', this.exportQueryConfig.context);
         // Step 1: Parse and validate query
+        cli_utilities_1.log.debug('Parsing and validating query', this.exportQueryConfig.context);
         const parsedQuery = await this.queryParser.parse(this.exportQueryConfig.query);
-        (0, logger_1.log)(this.exportQueryConfig, 'Query parsed and validated successfully', 'success');
+        cli_utilities_1.log.success('Query parsed and validated successfully', this.exportQueryConfig.context);
         // Step 2: Always export general modules
         await this.exportGeneralModules();
         // Step 4: Export queried modules
@@ -35,39 +35,44 @@ class QueryExporter {
         const contentTypesFilePath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'content_types', 'schema.json');
         const contentTypes = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath)) || [];
         if (contentTypes.length === 0) {
-            (0, logger_1.log)(this.exportQueryConfig, 'No content types found, skipping export', 'info');
+            cli_utilities_1.log.info('No content types found, skipping export', this.exportQueryConfig.context);
             process.exit(0);
         }
         // Step 5: export other content types which are referenced in previous step
+        cli_utilities_1.log.debug('Starting referenced content types export', this.exportQueryConfig.context);
         await this.exportReferencedContentTypes();
         // Step 6: export dependent modules global fields, extensions, taxonomies
+        cli_utilities_1.log.debug('Starting dependent modules export', this.exportQueryConfig.context);
         await this.exportDependentModules();
         // Step 7: export content modules entries, assets
+        cli_utilities_1.log.debug('Starting content modules export', this.exportQueryConfig.context);
         await this.exportContentModules();
         // Step 9: export all other modules
-        (0, logger_1.log)(this.exportQueryConfig, 'Query-based export completed successfully!', 'success');
+        cli_utilities_1.log.success('Query-based export completed successfully!', this.exportQueryConfig.context);
     }
     // export general modules
     async exportGeneralModules() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Exporting general modules...', 'info');
+        cli_utilities_1.log.info('Exporting general modules...', this.exportQueryConfig.context);
         for (const module of this.exportQueryConfig.modules.general) {
             await this.moduleExporter.exportModule(module);
         }
     }
     async exportQueriedModule(parsedQuery) {
+        cli_utilities_1.log.debug('Starting queried module export', this.exportQueryConfig.context);
         for (const [moduleName] of Object.entries(parsedQuery.modules)) {
             const module = moduleName;
             if (!this.exportQueryConfig.modules.queryable.includes(module)) {
-                (0, logger_1.log)(this.exportQueryConfig, `Module "${module}" is not queryable`, 'error');
+                cli_utilities_1.log.error(`Module "${module}" is not queryable`, this.exportQueryConfig.context);
                 continue;
             }
-            (0, logger_1.log)(this.exportQueryConfig, `Exporting ${moduleName} with query...`, 'info');
+            cli_utilities_1.log.info(`Exporting ${moduleName} with query...`, this.exportQueryConfig.context);
             // Export the queried module
             await this.moduleExporter.exportModule(module, { query: parsedQuery });
         }
+        cli_utilities_1.log.debug('Queried module export completed', this.exportQueryConfig.context);
     }
     async exportReferencedContentTypes() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of referenced content types...', 'info');
+        cli_utilities_1.log.info('Starting export of referenced content types...', this.exportQueryConfig.context);
         try {
             const referencedHandler = new utils_1.ReferencedContentTypesHandler(this.exportQueryConfig);
             const exportedContentTypeUIDs = new Set();
@@ -75,24 +80,25 @@ class QueryExporter {
             const contentTypesFilePath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'content_types', 'schema.json');
             const contentTypes = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath)) || [];
             if (contentTypes.length === 0) {
-                (0, logger_1.log)(this.exportQueryConfig, 'No content types found, skipping referenced content types export', 'info');
+                cli_utilities_1.log.info('No content types found, skipping referenced content types export', this.exportQueryConfig.context);
                 return;
             }
             // Step 2: Start with initial batch (all currently exported content types)
             let currentBatch = [...contentTypes];
-            (0, logger_1.log)(this.exportQueryConfig, `Starting with ${currentBatch.length} initial content types`, 'info');
+            cli_utilities_1.log.info(`Starting with ${currentBatch.length} initial content types`, this.exportQueryConfig.context);
             // track reference depth
             let iterationCount = 0;
             // Step 3: Process batches until no new references are found
             while (currentBatch.length > 0 && iterationCount < this.exportQueryConfig.maxCTReferenceDepth) {
                 iterationCount++;
+                cli_utilities_1.log.debug(`Processing referenced content types iteration ${iterationCount}`, this.exportQueryConfig.context);
                 currentBatch.forEach((ct) => exportedContentTypeUIDs.add(ct.uid));
                 // Extract referenced content types from current batch
                 const referencedUIDs = await referencedHandler.extractReferencedContentTypes(currentBatch);
                 // Filter out already exported content types
                 const newReferencedUIDs = referencedUIDs.filter((uid) => !exportedContentTypeUIDs.has(uid));
                 if (newReferencedUIDs.length > 0) {
-                    (0, logger_1.log)(this.exportQueryConfig, `Found ${newReferencedUIDs.length} new referenced content types to fetch`, 'info');
+                    cli_utilities_1.log.info(`Found ${newReferencedUIDs.length} new referenced content types to fetch`, this.exportQueryConfig.context);
                     // // Add to exported set to avoid duplicates in future iterations
                     // newReferencedUIDs.forEach((uid) => exportedContentTypeUIDs.add(uid));
                     // Step 4: Fetch new content types using moduleExporter
@@ -110,31 +116,32 @@ class QueryExporter {
                     currentBatch = [...newContentTypes];
                     // Push new content types to main array
                     contentTypes.push(...newContentTypes);
-                    (0, logger_1.log)(this.exportQueryConfig, `Fetched ${currentBatch.length} new content types for next iteration`, 'info');
+                    cli_utilities_1.log.info(`Fetched ${currentBatch.length} new content types for next iteration`, this.exportQueryConfig.context);
                 }
                 else {
-                    (0, logger_1.log)(this.exportQueryConfig, 'No new referenced content types found, stopping recursion', 'info');
+                    cli_utilities_1.log.info('No new referenced content types found, stopping recursion', this.exportQueryConfig.context);
                     break;
                 }
             }
             utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath), contentTypes);
-            (0, logger_1.log)(this.exportQueryConfig, 'Referenced content types export completed successfully', 'success');
+            cli_utilities_1.log.success('Referenced content types export completed successfully', this.exportQueryConfig.context);
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error exporting referenced content types: ${error.message}`, 'error');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error exporting referenced content types');
             throw error;
         }
     }
     async exportDependentModules() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of dependent modules...', 'info');
+        cli_utilities_1.log.info('Starting export of dependent modules...', this.exportQueryConfig.context);
         try {
             const dependenciesHandler = new utils_3.ContentTypeDependenciesHandler(this.stackAPIClient, this.exportQueryConfig);
             // Extract dependencies from all exported content types
             const dependencies = await dependenciesHandler.extractDependencies();
+            cli_utilities_1.log.debug('Dependencies extracted successfully', this.exportQueryConfig.context);
             // Export Global Fields
             if (dependencies.globalFields.size > 0) {
                 const globalFieldUIDs = Array.from(dependencies.globalFields);
-                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${globalFieldUIDs.length} global fields...`, 'info');
+                cli_utilities_1.log.info(`Exporting ${globalFieldUIDs.length} global fields...`, this.exportQueryConfig.context);
                 const query = {
                     modules: {
                         'global-fields': {
@@ -147,7 +154,7 @@ class QueryExporter {
             // Export Extensions
             if (dependencies.extensions.size > 0) {
                 const extensionUIDs = Array.from(dependencies.extensions);
-                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${extensionUIDs.length} extensions...`, 'info');
+                cli_utilities_1.log.info(`Exporting ${extensionUIDs.length} extensions...`, this.exportQueryConfig.context);
                 const query = {
                     modules: {
                         extensions: {
@@ -160,7 +167,7 @@ class QueryExporter {
             // export marketplace apps
             if (dependencies.marketplaceApps.size > 0) {
                 const marketplaceAppInstallationUIDs = Array.from(dependencies.marketplaceApps);
-                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${marketplaceAppInstallationUIDs.length} marketplace apps...`, 'info');
+                cli_utilities_1.log.info(`Exporting ${marketplaceAppInstallationUIDs.length} marketplace apps...`, this.exportQueryConfig.context);
                 const query = {
                     modules: {
                         'marketplace-apps': {
@@ -173,7 +180,7 @@ class QueryExporter {
             // Export Taxonomies
             if (dependencies.taxonomies.size > 0) {
                 const taxonomyUIDs = Array.from(dependencies.taxonomies);
-                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${taxonomyUIDs.length} taxonomies...`, 'info');
+                cli_utilities_1.log.info(`Exporting ${taxonomyUIDs.length} taxonomies...`, this.exportQueryConfig.context);
                 const query = {
                     modules: {
                         taxonomies: {
@@ -185,15 +192,15 @@ class QueryExporter {
             }
             // export personalize
             await this.moduleExporter.exportModule('personalize');
-            (0, logger_1.log)(this.exportQueryConfig, 'Dependent modules export completed successfully', 'success');
+            cli_utilities_1.log.success('Dependent modules export completed successfully', this.exportQueryConfig.context);
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error exporting dependent modules: ${error.message}`, 'error');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error exporting dependent modules');
             throw error;
         }
     }
     async exportContentModules() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of content modules...', 'info');
+        cli_utilities_1.log.info('Starting export of content modules...', this.exportQueryConfig.context);
         try {
             // Step 1: Export entries for all exported content types
             await this.exportEntries();
@@ -202,50 +209,129 @@ class QueryExporter {
             const delay = this.exportQueryConfig.exportDelayMs || 5000;
             await new Promise((resolve) => setTimeout(resolve, delay));
             await this.exportReferencedAssets();
-            (0, logger_1.log)(this.exportQueryConfig, 'Content modules export completed successfully', 'success');
+            cli_utilities_1.log.success('Content modules export completed successfully', this.exportQueryConfig.context);
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error exporting content modules: ${error.message}`, 'error');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error exporting content modules');
             throw error;
         }
     }
     async exportEntries() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Exporting entries...', 'info');
+        cli_utilities_1.log.info('Exporting entries...', this.exportQueryConfig.context);
         try {
             // Export entries - module exporter will automatically read exported content types
             // and export entries for all of them
             await this.moduleExporter.exportModule('entries');
-            (0, logger_1.log)(this.exportQueryConfig, 'Entries export completed successfully', 'success');
+            cli_utilities_1.log.success('Entries export completed successfully', this.exportQueryConfig.context);
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error exporting entries: ${error.message}`, 'error');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error exporting entries');
             throw error;
         }
     }
     async exportReferencedAssets() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Starting export of referenced assets...', 'info');
+        cli_utilities_1.log.info('Starting export of referenced assets...', this.exportQueryConfig.context);
         try {
+            const assetsDir = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'assets');
+            const metadataFilePath = path.join(assetsDir, 'metadata.json');
+            const assetFilePath = path.join(assetsDir, 'assets.json');
+            // Define temp file paths
+            const tempMetadataFilePath = path.join(assetsDir, 'metadata_temp.json');
+            const tempAssetFilePath = path.join(assetsDir, 'assets_temp.json');
             const assetHandler = new utils_4.AssetReferenceHandler(this.exportQueryConfig);
             // Extract referenced asset UIDs from all entries
+            cli_utilities_1.log.debug('Extracting referenced assets from entries', this.exportQueryConfig.context);
             const assetUIDs = assetHandler.extractReferencedAssets();
             if (assetUIDs.length > 0) {
-                (0, logger_1.log)(this.exportQueryConfig, `Exporting ${assetUIDs.length} referenced assets...`, 'info');
-                const query = {
-                    modules: {
-                        assets: {
-                            uid: { $in: assetUIDs },
+                cli_utilities_1.log.info(`Found ${assetUIDs.length} referenced assets to export`, this.exportQueryConfig.context);
+                // Define batch size - can be configurable through exportQueryConfig
+                const batchSize = this.exportQueryConfig.assetBatchSize || 100;
+                if (assetUIDs.length <= batchSize) {
+                    const query = {
+                        modules: {
+                            assets: {
+                                uid: { $in: assetUIDs },
+                            },
                         },
-                    },
-                };
-                await this.moduleExporter.exportModule('assets', { query });
-                (0, logger_1.log)(this.exportQueryConfig, 'Referenced assets exported successfully', 'success');
+                    };
+                    await this.moduleExporter.exportModule('assets', { query });
+                }
+                // if asset size is bigger than batch size, then we need to export in batches
+                // Calculate number of batches
+                const totalBatches = Math.ceil(assetUIDs.length / batchSize);
+                cli_utilities_1.log.info(`Processing assets in ${totalBatches} batches of ${batchSize}`, this.exportQueryConfig.context);
+                // Process assets in batches
+                for (let i = 0; i < totalBatches; i++) {
+                    const start = i * batchSize;
+                    const end = Math.min(start + batchSize, assetUIDs.length);
+                    const batchAssetUIDs = assetUIDs.slice(start, end);
+                    cli_utilities_1.log.info(`Exporting batch ${i + 1}/${totalBatches} (${batchAssetUIDs.length} assets)...`, this.exportQueryConfig.context);
+                    const query = {
+                        modules: {
+                            assets: {
+                                uid: { $in: batchAssetUIDs },
+                            },
+                        },
+                    };
+                    await this.moduleExporter.exportModule('assets', { query });
+                    // Read the current batch's metadata.json and assets.json files
+                    const currentMetadata = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(metadataFilePath));
+                    const currentAssets = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(assetFilePath));
+                    // Check if this is the first batch
+                    if (i === 0) {
+                        // For first batch, initialize temp files with current content
+                        utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(tempMetadataFilePath), currentMetadata);
+                        utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(tempAssetFilePath), currentAssets);
+                        cli_utilities_1.log.info(`Initialized temporary files with first batch data`, this.exportQueryConfig.context);
+                    }
+                    else {
+                        // For subsequent batches, append to temp files with incremented keys
+                        // Handle metadata (which contains arrays of asset info)
+                        const tempMetadata = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(tempMetadataFilePath)) || {};
+                        // Merge metadata by combining arrays
+                        if (currentMetadata) {
+                            Object.keys(currentMetadata).forEach((key) => {
+                                if (!tempMetadata[key]) {
+                                    tempMetadata[key] = currentMetadata[key];
+                                }
+                            });
+                        }
+                        // Write updated metadata back to temp file
+                        utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(tempMetadataFilePath), tempMetadata);
+                        // Handle assets (which is an object with numeric keys)
+                        const tempAssets = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(tempAssetFilePath)) || {};
+                        let nextIndex = Object.keys(tempAssets).length + 1;
+                        // Add current assets with incremented keys
+                        Object.values(currentAssets).forEach((value) => {
+                            tempAssets[nextIndex.toString()] = value;
+                            nextIndex++;
+                        });
+                        utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(tempAssetFilePath), tempAssets);
+                        cli_utilities_1.log.info(`Updated temporary files with batch ${i + 1} data`, this.exportQueryConfig.context);
+                    }
+                    // Optional: Add delay between batches to avoid rate limiting
+                    if (i < totalBatches - 1 && this.exportQueryConfig.batchDelayMs) {
+                        await new Promise((resolve) => setTimeout(resolve, this.exportQueryConfig.batchDelayMs));
+                    }
+                }
+                // After all batches are processed, copy temp files back to original files
+                const finalMetadata = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(tempMetadataFilePath));
+                const finalAssets = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(tempAssetFilePath));
+                utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(metadataFilePath), finalMetadata);
+                utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(assetFilePath), finalAssets);
+                cli_utilities_1.log.info(`Final data written back to original files`, this.exportQueryConfig.context);
+                // Clean up temp files
+                utils_2.fsUtil.removeFile((0, cli_utilities_1.sanitizePath)(tempMetadataFilePath));
+                utils_2.fsUtil.removeFile((0, cli_utilities_1.sanitizePath)(tempAssetFilePath));
+                cli_utilities_1.log.info(`Temporary files cleaned up`, this.exportQueryConfig.context);
+                cli_utilities_1.log.success('Referenced assets exported successfully', this.exportQueryConfig.context);
             }
             else {
-                (0, logger_1.log)(this.exportQueryConfig, 'No referenced assets found in entries', 'info');
+                cli_utilities_1.log.info('No referenced assets found in entries', this.exportQueryConfig.context);
             }
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error exporting referenced assets: ${error.message}`, 'error');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error exporting referenced assets');
             throw error;
         }
     }

package/lib/types/index.d.ts

@@ -129,6 +129,19 @@ export interface DefaultConfig {
     externalConfigPath?: string;
     maxCTReferenceDepth: number;
 }
+/**
+ * Log context interface for centralized logging
+ */
+export interface LogContext {
+    command: string;
+    module: string;
+    email: string;
+    sessionId: string;
+    apiKey: string;
+    orgId: string;
+    authenticationMethod: string;
+    [key: string]: unknown;
+}
 export interface QueryExportConfig extends DefaultConfig {
     query: string;
     skipReferences: boolean;
@@ -136,10 +149,15 @@ export interface QueryExportConfig extends DefaultConfig {
     stackApiKey: string;
     managementToken?: string;
     branchName: string;
+    branchAlias?: string;
     securedAssets: boolean;
     logsPath: string;
     dataPath: string;
     exportDelayMs?: number;
+    batchDelayMs?: number;
+    assetBatchSize?: number;
+    assetBatchDelayMs?: number;
+    context?: LogContext;
 }
 export interface QueryMetadata {
     query: any;

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

@@ -0,0 +1,10 @@
+import { QueryExportConfig } from '../types';
+/**
+ * Validates and sets up branch configuration for the stack
+ *
+ * @param config The export configuration
+ * @param stackAPIClient The stack API client
+ * @returns Promise that resolves when branch setup is complete
+ */
+export declare const setupBranches: (config: QueryExportConfig, stackAPIClient: any) => Promise<void>;
+export default setupBranches;

package/lib/utils/branch-helper.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupBranches = void 0;
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+/**
+ * Validates and sets up branch configuration for the stack
+ *
+ * @param config The export configuration
+ * @param stackAPIClient The stack API client
+ * @returns Promise that resolves when branch setup is complete
+ */
+const setupBranches = async (config, stackAPIClient) => {
+    if (typeof config !== 'object') {
+        throw new Error('The branch configuration is invalid.');
+    }
+    const context = config.context;
+    try {
+        if (config.branchAlias) {
+            config.branchName = await (0, cli_utilities_1.getBranchFromAlias)(stackAPIClient, config.branchAlias);
+            return;
+        }
+        if (config.branchName) {
+            // Check if the specified branch exists
+            cli_utilities_1.log.info(`Validating branch: ${config.branchName}`, context);
+            const result = await stackAPIClient
+                .branch(config.branchName)
+                .fetch()
+                .catch((err) => {
+                (0, cli_utilities_1.handleAndLogError)(err, context, 'Error fetching branch');
+                return null;
+            });
+            if (result && typeof result === 'object') {
+                cli_utilities_1.log.success(`Branch '${config.branchName}' found`, context);
+            }
+            else {
+                throw new Error(`No branch found named ${config.branchName}.`);
+            }
+        }
+        else {
+            // If no branch name provided, check if the stack has branches
+            cli_utilities_1.log.info('No branch specified, checking if stack has branches', context);
+            const result = await stackAPIClient
+                .branch()
+                .query()
+                .find()
+                .catch(() => {
+                cli_utilities_1.log.info('Stack does not have branches', context);
+                return null;
+            });
+            if (result && result.items && Array.isArray(result.items) && result.items.length > 0) {
+                // Set default branch to 'main' if it exists
+                config.branchName = 'main';
+            }
+            else {
+                // Stack doesn't have branches
+                cli_utilities_1.log.info('Stack does not have branches', context);
+                return;
+            }
+        }
+        config.branchEnabled = true;
+    }
+    catch (error) {
+        (0, cli_utilities_1.handleAndLogError)(error, context, 'Error setting up branches');
+        throw error;
+    }
+};
+exports.setupBranches = setupBranches;
+exports.default = exports.setupBranches;

package/lib/utils/config-handler.js

@@ -12,23 +12,30 @@ async function setupQueryExportConfig(flags) {
     const exportQueryConfig = Object.assign(Object.assign({}, config_1.default), { exportDir, stackApiKey: flags['stack-api-key'] || '', managementToken: flags.alias ? (_a = cli_utilities_1.configHandler.get(`tokens.${flags.alias}`)) === null || _a === void 0 ? void 0 : _a.token : undefined, query: flags.query, skipReferences: flags['skip-references'] || false, skipDependencies: flags['skip-dependencies'] || false, branchName: flags.branch, securedAssets: flags['secured-assets'] || false, isQueryBasedExport: true, logsPath: exportDir, dataPath: exportDir, 
         // Todo: accept the path of the config file from the user
         externalConfigPath: path.join(__dirname, '../config/export-config.json') });
+    if (flags['branch-alias']) {
+        exportQueryConfig.branchAlias = flags['branch-alias'];
+    }
+    // override the external config path if the user provides a config file
+    if (flags.config) {
+        exportQueryConfig.externalConfigPath = (0, cli_utilities_1.sanitizePath)(flags['config']);
+    }
     // Handle authentication
     if (flags.alias) {
         const { token, apiKey } = cli_utilities_1.configHandler.get(`tokens.${flags.alias}`) || {};
-        config_1.default.managementToken = token;
-        config_1.default.stackApiKey = apiKey;
-        if (!config_1.default.managementToken) {
-            throw new Error(`No management token found on given alias ${flags.alias}`);
+        exportQueryConfig.managementToken = token;
+        exportQueryConfig.stackApiKey = apiKey;
+        if (!exportQueryConfig.managementToken) {
+            throw new Error(`No management token found for alias ${flags.alias}.`);
         }
     }
-    if (!config_1.default.managementToken) {
+    if (!exportQueryConfig.managementToken) {
         if (!(0, cli_utilities_1.isAuthenticated)()) {
-            throw new Error('Please login or provide an alias for the management token');
+            throw new Error('Log in or provide an alias for the management token.');
         }
         else {
-            config_1.default.stackApiKey = flags['stack-api-key'] || (await (0, common_helper_1.askAPIKey)());
-            if (typeof config_1.default.stackApiKey !== 'string') {
-                throw new Error('Invalid API key received');
+            exportQueryConfig.stackApiKey = flags['stack-api-key'] || (await (0, common_helper_1.askAPIKey)());
+            if (typeof exportQueryConfig.stackApiKey !== 'string') {
+                throw new Error('The API key is invalid.');
             }
         }
     }

package/lib/utils/content-type-helper.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReferencedContentTypesHandler = void 0;
-const logger_1 = require("./logger");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
 class ReferencedContentTypesHandler {
     constructor(exportQueryConfig) {
         this.exportQueryConfig = exportQueryConfig;
@@ -12,7 +12,7 @@ class ReferencedContentTypesHandler {
      */
     async extractReferencedContentTypes(contentTypeBatch) {
         const allReferencedTypes = new Set();
-        (0, logger_1.log)(this.exportQueryConfig, `Extracting references from ${contentTypeBatch.length} content types`, 'info');
+        cli_utilities_1.log.info(`Extracting references from ${contentTypeBatch.length} content types`, this.exportQueryConfig.context);
         for (const contentType of contentTypeBatch) {
             if (contentType.schema) {
                 const referencedTypes = this.getReferencedContentTypes(contentType.schema);
@@ -20,7 +20,7 @@ class ReferencedContentTypesHandler {
             }
         }
         const result = Array.from(allReferencedTypes);
-        (0, logger_1.log)(this.exportQueryConfig, `Found ${result.length} referenced content types`, 'info');
+        cli_utilities_1.log.info(`Found ${result.length} referenced content types`, this.exportQueryConfig.context);
         return result;
     }
     /**

package/lib/utils/dependency-resolver.js

@@ -5,7 +5,6 @@ const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("path"));
 const index_1 = require("./index");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
-const logger_1 = require("./logger");
 class ContentTypeDependenciesHandler {
     constructor(stackAPIClient, exportQueryConfig) {
         this.exportQueryConfig = exportQueryConfig;
@@ -15,7 +14,7 @@ class ContentTypeDependenciesHandler {
         const contentTypesFilePath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'content_types', 'schema.json');
         const allContentTypes = index_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath)) || [];
         if (allContentTypes.length === 0) {
-            (0, logger_1.log)(this.exportQueryConfig, 'No content types found, skipping dependency extraction', 'info');
+            cli_utilities_1.log.info('No content types found, skipping dependency extraction', this.exportQueryConfig.context);
             return {
                 globalFields: new Set(),
                 extensions: new Set(),
@@ -23,7 +22,7 @@ class ContentTypeDependenciesHandler {
                 marketplaceApps: new Set(),
             };
         }
-        (0, logger_1.log)(this.exportQueryConfig, `Extracting dependencies from ${allContentTypes.length} content types`, 'info');
+        cli_utilities_1.log.info(`Extracting dependencies from ${allContentTypes.length} content types`, this.exportQueryConfig.context);
         const dependencies = {
             globalFields: new Set(),
             extensions: new Set(),
@@ -38,26 +37,26 @@ class ContentTypeDependenciesHandler {
         // Separate extensions from marketplace apps using the extracted extension UIDs
         if (dependencies.extensions.size > 0) {
             const extensionUIDs = Array.from(dependencies.extensions);
-            (0, logger_1.log)(this.exportQueryConfig, `Processing ${extensionUIDs.length} extensions to identify marketplace apps...`, 'info');
+            cli_utilities_1.log.info(`Processing ${extensionUIDs.length} extensions to identify marketplace apps...`, this.exportQueryConfig.context);
             try {
                 const { extensions, marketplaceApps } = await this.fetchExtensionsAndMarketplaceApps(extensionUIDs);
                 dependencies.extensions = new Set(extensions);
                 dependencies.marketplaceApps = new Set(marketplaceApps);
-                (0, logger_1.log)(this.exportQueryConfig, `Dependencies separated - Global Fields: ${dependencies.globalFields.size}, Extensions: ${dependencies.extensions.size}, Taxonomies: ${dependencies.taxonomies.size}, Marketplace Apps: ${dependencies.marketplaceApps.size}`, 'info');
+                cli_utilities_1.log.info(`Dependencies separated - Global Fields: ${dependencies.globalFields.size}, Extensions: ${dependencies.extensions.size}, Taxonomies: ${dependencies.taxonomies.size}, Marketplace Apps: ${dependencies.marketplaceApps.size}`, this.exportQueryConfig.context);
             }
             catch (error) {
-                (0, logger_1.log)(this.exportQueryConfig, `Error separating extensions and marketplace apps: ${error.message}`, 'error');
+                (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Failed to separate extensions and Marketplace apps');
                 // Keep original extensions if separation fails
             }
         }
         else {
-            (0, logger_1.log)(this.exportQueryConfig, `Found dependencies - Global Fields: ${dependencies.globalFields.size}, Extensions: ${dependencies.extensions.size}, Taxonomies: ${dependencies.taxonomies.size}, Marketplace Apps: ${dependencies.marketplaceApps.size}`, 'info');
+            cli_utilities_1.log.info(`Found dependencies - Global Fields: ${dependencies.globalFields.size}, Extensions: ${dependencies.extensions.size}, Taxonomies: ${dependencies.taxonomies.size}, Marketplace Apps: ${dependencies.marketplaceApps.size}`, this.exportQueryConfig.context);
         }
         return dependencies;
     }
     // Update the fetchExtensionsAndMarketplaceApps method to only fetch specific extension UIDs
     async fetchExtensionsAndMarketplaceApps(extensionUIDs) {
-        (0, logger_1.log)(this.exportQueryConfig, `Fetching details for ${extensionUIDs.length} extensions to identify marketplace apps...`, 'info');
+        cli_utilities_1.log.info(`Fetching details for ${extensionUIDs.length} extensions to identify marketplace apps...`, this.exportQueryConfig.context);
         try {
             // Query parameters to include marketplace extensions
             const queryParams = {
@@ -70,7 +69,7 @@ class ContentTypeDependenciesHandler {
             // Fetch all extensions including marketplace apps
             const response = await this.stackAPIClient.extension().query(queryParams).find();
             if (!response || !response.items) {
-                (0, logger_1.log)(this.exportQueryConfig, `No extensions found`, 'warn');
+                cli_utilities_1.log.warn(`No extensions found`, this.exportQueryConfig.context);
                 return { extensions: extensionUIDs, marketplaceApps: [] };
             }
             const marketplaceApps = [];
@@ -83,11 +82,11 @@ class ContentTypeDependenciesHandler {
                     regularExtensions.push(item.uid);
                 }
             });
-            (0, logger_1.log)(this.exportQueryConfig, `Identified ${marketplaceApps.length} marketplace apps and ${regularExtensions.length} regular extensions from ${extensionUIDs.length} total extensions`, 'info');
+            cli_utilities_1.log.info(`Identified ${marketplaceApps.length} marketplace apps and ${regularExtensions.length} regular extensions from ${extensionUIDs.length} total extensions`, this.exportQueryConfig.context);
             return { extensions: regularExtensions, marketplaceApps };
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error fetching extensions and marketplace apps: ${error.message}`, 'error');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Failed to fetch extensions and Marketplace apps');
             return { extensions: extensionUIDs, marketplaceApps: [] };
         }
     }

package/lib/utils/index.d.ts

@@ -1,8 +1,10 @@
 export * as fileHelper from './file-helper';
 export { fsUtil } from './file-helper';
-export { log, unlinkFileLogger } from './logger';
+export { log, unlinkFileLogger, createLogContext } from './logger';
+export { LogContext } from '../types';
 export * from './common-helper';
 export * from './config-handler';
 export * from './content-type-helper';
 export * from './dependency-resolver';
 export * from './referenced-asset-handler';
+export { setupBranches } from './branch-helper';

package/lib/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unlinkFileLogger = exports.log = exports.fsUtil = exports.fileHelper = void 0;
+exports.setupBranches = exports.createLogContext = exports.unlinkFileLogger = exports.log = exports.fsUtil = exports.fileHelper = void 0;
 const tslib_1 = require("tslib");
 exports.fileHelper = tslib_1.__importStar(require("./file-helper"));
 var file_helper_1 = require("./file-helper");
@@ -8,8 +8,11 @@ Object.defineProperty(exports, "fsUtil", { enumerable: true, get: function () {
 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; } });
+Object.defineProperty(exports, "createLogContext", { enumerable: true, get: function () { return logger_1.createLogContext; } });
 tslib_1.__exportStar(require("./common-helper"), exports);
 tslib_1.__exportStar(require("./config-handler"), exports);
 tslib_1.__exportStar(require("./content-type-helper"), exports);
 tslib_1.__exportStar(require("./dependency-resolver"), exports);
 tslib_1.__exportStar(require("./referenced-asset-handler"), exports);
+var branch_helper_1 = require("./branch-helper");
+Object.defineProperty(exports, "setupBranches", { enumerable: true, get: function () { return branch_helper_1.setupBranches; } });

package/lib/utils/logger.d.ts

@@ -3,6 +3,10 @@
  * Copyright (c) 2024 Contentstack LLC
  * MIT Licensed
  */
-import { QueryExportConfig } from '../types';
+import { QueryExportConfig, LogContext } from '../types';
 export declare const log: (config: QueryExportConfig, message: any, type: string) => Promise<void>;
 export declare const unlinkFileLogger: () => void;
+/**
+ * Creates a context object for logging from QueryExportConfig
+ */
+export declare function createLogContext(config: QueryExportConfig, moduleName?: string): LogContext;

package/lib/utils/logger.js

@@ -5,7 +5,7 @@
  * MIT Licensed
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unlinkFileLogger = exports.log = void 0;
+exports.createLogContext = exports.unlinkFileLogger = exports.log = void 0;
 const tslib_1 = require("tslib");
 const winston = tslib_1.__importStar(require("winston"));
 const path = tslib_1.__importStar(require("path"));
@@ -156,3 +156,18 @@ const unlinkFileLogger = () => {
     }
 };
 exports.unlinkFileLogger = unlinkFileLogger;
+/**
+ * Creates a context object for logging from QueryExportConfig
+ */
+function createLogContext(config, moduleName) {
+    return {
+        command: 'cm:stacks:export-query',
+        module: moduleName || '',
+        email: cli_utilities_1.configHandler.get('email') || '',
+        sessionId: cli_utilities_1.configHandler.get('sessionId') || '',
+        apiKey: config.stackApiKey || '',
+        orgId: cli_utilities_1.configHandler.get('oauthOrgUid') || '',
+        authenticationMethod: config.managementToken ? 'Management Token' : 'Basic Auth',
+    };
+}
+exports.createLogContext = createLogContext;

package/lib/utils/query-parser.js

@@ -26,7 +26,7 @@ class QueryParser {
             return JSON.parse(content);
         }
         catch (error) {
-            throw new cli_utilities_1.CLIError(`Failed to parse query file: ${error.message}`);
+            (0, cli_utilities_1.handleAndLogError)(error, this.config.context, 'Failed to parse the query file');
         }
     }
     parseFromString(queryString) {
@@ -34,19 +34,19 @@ class QueryParser {
             return JSON.parse(queryString);
         }
         catch (error) {
-            throw new cli_utilities_1.CLIError(`Invalid JSON query: ${error.message}`);
+            (0, cli_utilities_1.handleAndLogError)(error, this.config.context, 'Invalid JSON query');
         }
     }
     validate(query) {
         if (!query || typeof query !== 'object') {
-            throw new cli_utilities_1.CLIError('Query must be a valid JSON object');
+            throw new cli_utilities_1.CLIError('The query must be a valid JSON object.');
         }
         if (!query.modules || typeof query.modules !== 'object') {
-            throw new cli_utilities_1.CLIError('Query must contain a "modules" object');
+            throw new cli_utilities_1.CLIError('The query must contain a "modules" object.');
         }
         const modules = Object.keys(query.modules);
         if (modules.length === 0) {
-            throw new cli_utilities_1.CLIError('Query must contain at least one module');
+            throw new cli_utilities_1.CLIError('The query must contain at least one module.');
         }
         // Validate supported modules
         const queryableModules = this.config.modules.queryable;

package/lib/utils/referenced-asset-handler.js

@@ -6,7 +6,6 @@ const path = tslib_1.__importStar(require("path"));
 const fs = tslib_1.__importStar(require("fs"));
 const index_1 = require("./index");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
-const logger_1 = require("./logger");
 class AssetReferenceHandler {
     constructor(exportQueryConfig) {
         this.exportQueryConfig = exportQueryConfig;
@@ -16,10 +15,10 @@ class AssetReferenceHandler {
      * Extract all asset UIDs by processing entries file by file (memory efficient)
      */
     extractReferencedAssets() {
-        (0, logger_1.log)(this.exportQueryConfig, 'Extracting referenced assets from entries...', 'info');
+        cli_utilities_1.log.info('Extracting referenced assets from entries...', this.exportQueryConfig.context);
         try {
             if (!fs.existsSync(this.entriesDir)) {
-                (0, logger_1.log)(this.exportQueryConfig, 'Entries directory does not exist', 'warn');
+                cli_utilities_1.log.warn('Entries directory does not exist', this.exportQueryConfig.context);
                 return [];
             }
             // Global set to maintain unique asset UIDs across all files
@@ -33,11 +32,11 @@ class AssetReferenceHandler {
                 totalEntriesProcessed += entriesInFile;
             }
             const result = Array.from(globalAssetUIDs);
-            (0, logger_1.log)(this.exportQueryConfig, `Found ${result.length} unique asset UIDs from ${totalEntriesProcessed} entries across ${jsonFiles.length} files`, 'info');
+            cli_utilities_1.log.info(`Found ${result.length} unique asset UIDs from ${totalEntriesProcessed} entries across ${jsonFiles.length} files`, this.exportQueryConfig.context);
             return result;
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error extracting assets: ${error.message}`, 'error');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Failed to extract assets');
             return [];
         }
     }
@@ -62,11 +61,11 @@ class AssetReferenceHandler {
             assetUIDs.forEach((uid) => globalAssetUIDs.add(uid));
             // Count entries for logging
             const entriesCount = Object.keys(fileContent).length;
-            (0, logger_1.log)(this.exportQueryConfig, `Processed ${entriesCount} entries from ${path.basename(filePath)}`, 'debug');
+            cli_utilities_1.log.debug(`Processed ${entriesCount} entries from ${path.basename(filePath)}`, this.exportQueryConfig.context);
             return entriesCount;
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error processing file ${filePath}: ${error.message}`, 'warn');
+            cli_utilities_1.log.warn(`Failed to process file ${filePath}: ${(0, cli_utilities_1.formatError)(error)}`, this.exportQueryConfig.context);
             return 0;
         }
     }
@@ -83,10 +82,21 @@ class AssetReferenceHandler {
                 assetUIDs.add(match[1]);
             }
         }
+        let assetUrlRegex = '';
+        let assetUIDMatchIndex;
+        if (process.env.ENVIRONMENT === 'NON_PROD') {
+            assetUrlRegex = '(https://.*?/v3/assets/(.*?)/(.*?)/(.*?)/(.*?)(?="))';
+            assetUIDMatchIndex = 3;
+        }
+        else {
+            assetUrlRegex =
+                '(https://(assets|(eu-|azure-na-|azure-eu-|gcp-na-|gcp-eu-)?images).contentstack.(io|com)/v3/assets/(.*?)/(.*?)/(.*?)/(.*?)(?="))';
+            assetUIDMatchIndex = 6;
+        }
         // Pattern 2: Contentstack asset URLs
-        const urlRegex = new RegExp('(https://(assets|(eu-|azure-na-|azure-eu-|gcp-na-|gcp-eu-)?images).contentstack.(io|com)/v3/assets/(.*?)/(.*?)/(.*?)/(.*?)(?="))', 'g');
+        const urlRegex = new RegExp(assetUrlRegex, 'g');
         while ((match = urlRegex.exec(content)) !== null) {
-            const assetUID = match[6]; // The asset UID is in the 6th capture group
+            const assetUID = match[assetUIDMatchIndex]; // The asset UID is in the 6th capture group
             if (assetUID) {
                 assetUIDs.add(assetUID);
             }
@@ -112,7 +122,7 @@ class AssetReferenceHandler {
             }
         }
         catch (error) {
-            (0, logger_1.log)(this.exportQueryConfig, `Error reading directory ${dir}: ${error.message}`, 'warn');
+            cli_utilities_1.log.warn(`Failed to read directory ${dir}: ${(0, cli_utilities_1.formatError)(error)}`, this.exportQueryConfig.context);
         }
         return jsonFiles;
     }

package/oclif.manifest.json

@@ -1,9 +1,7 @@
 {
   "commands": {
     "cm:stacks:export-query": {
-      "aliases": [
-        "cm:export-query"
-      ],
+      "aliases": [],
       "args": {},
       "description": "Export content from a stack using query-based filtering",
       "examples": [
@@ -47,11 +45,24 @@
         },
         "branch": {
           "description": "Branch name to export from",
+          "exclusive": [
+            "branch-alias"
+          ],
           "name": "branch",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
+        "branch-alias": {
+          "description": "Alias of Branch to export from",
+          "exclusive": [
+            "branch"
+          ],
+          "name": "branch-alias",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "query": {
           "description": "Query as JSON string or file path",
           "name": "query",
@@ -104,5 +115,5 @@
       ]
     }
   },
-  "version": "1.0.0-beta.1"
+  "version": "1.0.0-beta.11"
 }

package/package.json

@@ -1,51 +1,54 @@
 {
   "name": "@contentstack/cli-cm-export-query",
   "description": "Contentstack CLI plugin to export content from stack",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.11",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
-    "@contentstack/cli-cm-export": "~1.18.0",
-    "@contentstack/cli-command": "~1.6.0",
-    "@contentstack/cli-utilities": "~1.13.0",
-    "@oclif/core": "^4.3.0",
+    "@contentstack/cli-cm-export": "~1.24.1",
+    "@contentstack/cli-command": "~1.8.0",
+    "@contentstack/cli-utilities": "~1.18.1",
+    "@oclif/core": "^4.10.5",
     "async": "^3.2.6",
     "big-json": "^3.2.0",
     "bluebird": "^3.7.2",
-    "chalk": "^4.1.2",
-    "lodash": "^4.17.21",
+    "lodash": "^4.18.1",
     "merge": "^2.1.1",
     "mkdirp": "^1.0.4",
     "progress-stream": "^2.0.0",
     "promise-limit": "^2.7.0",
-    "winston": "^3.17.0"
+    "tslib": "^2.8.1",
+    "winston": "^3.19.0"
+  },
+  "overrides": {
+    "brace-expansion": "^5.0.5"
   },
   "devDependencies": {
-    "@contentstack/cli-dev-dependencies": "~1.3.0",
-    "@oclif/plugin-help": "^6.2.28",
-    "@oclif/test": "^4.1.13",
+    "@contentstack/cli-dev-dependencies": "~1.3.1",
+    "@oclif/plugin-help": "^6.2.44",
+    "@oclif/test": "^4.1.18",
     "@types/big-json": "^3.2.5",
     "@types/chai": "^4.3.20",
     "@types/mkdirp": "^1.0.2",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^20.19.8",
+    "@types/node": "^20.19.39",
     "@types/progress-stream": "^2.0.5",
     "@types/sinon": "^17.0.4",
     "chai": "^4.5.0",
-    "dotenv": "^16.5.0",
+    "dotenv": "^16.6.1",
     "dotenv-expand": "^9.0.0",
     "eslint": "^8.57.1",
-    "eslint-config-oclif": "^6.0.62",
+    "eslint-config-oclif": "^6.0.157",
     "husky": "^9.1.7",
     "mocha": "10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
-    "sinon": "^17.0.1",
+    "sinon": "^17.0.2",
     "ts-node": "^10.9.2",
     "typescript": "^4.9.5"
   },
   "scripts": {
-    "build": "npm run clean && npm run compile && cp -r src/config lib/",
+    "build": "npm run clean && npm install && npm run compile && cp -r src/config lib/",
     "clean": "rm -rf ./lib ./node_modules tsconfig.build.tsbuildinfo",
     "compile": "tsc -b tsconfig.json",
     "postpack": "rm -f oclif.manifest.json",