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

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

@@ -7,4 +7,5 @@ export default class ExportQueryCommand extends Command {
     static usage: string;
     static flags: FlagInput;
     run(): Promise<void>;
+    initializeMessageHandler(): void;
 }

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

@@ -8,6 +8,7 @@ class ExportQueryCommand extends cli_command_1.Command {
     async run() {
         try {
             const { flags } = await this.parse(ExportQueryCommand);
+            this.initializeMessageHandler();
             // Setup export configuration
             const exportQueryConfig = await (0, utils_1.setupQueryExportConfig)(flags);
             exportQueryConfig.host = this.cmaHost;
@@ -41,6 +42,9 @@ class ExportQueryCommand extends cli_command_1.Command {
             (0, cli_utilities_1.handleAndLogError)(error);
         }
     }
+    initializeMessageHandler() {
+        cli_utilities_1.messageHandler.init(this.context);
+    }
 }
 exports.default = ExportQueryCommand;
 ExportQueryCommand.description = 'Export content from a stack using query-based filtering';

package/lib/config/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const config = {
-    contentVersion: 2,
+    contentVersion: 1,
     host: 'https://api.contentstack.io/v3',
     // Query-based export module configuration
     modules: {

package/lib/config/index.ts

@@ -1,7 +1,7 @@
 import { DefaultConfig } from '../types';
 
 const config: DefaultConfig = {
-  contentVersion: 2,
+  contentVersion: 1,
   host: 'https://api.contentstack.io/v3',
 
   // Query-based export module configuration

package/lib/core/module-exporter.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleExporter = void 0;
 const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const cli_cm_export_1 = tslib_1.__importDefault(require("@contentstack/cli-cm-export"));
+const read_content_type_schemas_1 = require("../utils/read-content-type-schemas");
 class ModuleExporter {
     constructor(exportQueryConfig) {
         this.exportedModules = [];
@@ -22,6 +24,13 @@ class ModuleExporter {
             // Create export command instance
             await cli_cm_export_1.default.run(cmd);
             cli_utilities_1.log.debug(`Export command completed for module: ${moduleName}`, moduleLogContext);
+            if (moduleName === 'content-types') {
+                const baseDir = options.directory || this.exportQueryConfig.exportDir;
+                const branch = options.branch || this.exportQueryConfig.branchName || '';
+                const ctDir = path.join((0, cli_utilities_1.sanitizePath)(baseDir), (0, cli_utilities_1.sanitizePath)(branch), 'content_types');
+                (0, read_content_type_schemas_1.rebuildContentTypesSchemaJson)(ctDir);
+                cli_utilities_1.log.debug('Rebuilt content_types/schema.json from all per-UID JSON files', moduleLogContext);
+            }
             // Read the exported data
             // const data = await this.readExportedData(moduleName, options);
             if (!this.exportedModules.includes(moduleName)) {
@@ -48,10 +57,13 @@ class ModuleExporter {
         cmd.push('-d', directory);
         // Module
         cmd.push('--module', moduleName);
-        // Alias (management token)
+        // Alias or management token (mutually exclusive for the export CLI)
         if (options.alias) {
             cmd.push('-a', options.alias);
         }
+        else if (this.exportQueryConfig.managementToken) {
+            cmd.push('-a', this.exportQueryConfig.managementToken);
+        }
         // Branch
         if (options.branch || this.exportQueryConfig.branchName) {
             cmd.push('--branch', options.branch || this.exportQueryConfig.branchName);

package/lib/core/query-executor.d.ts

@@ -9,8 +9,19 @@ export declare class QueryExporter {
     execute(): Promise<void>;
     private exportGeneralModules;
     private exportQueriedModule;
-    private exportReferencedContentTypes;
-    private exportDependentModules;
+    /**
+     * Iteratively expand the set of exported content types, global fields, extensions,
+     * taxonomies, and marketplace apps until no new items are discovered (fixpoint).
+     *
+     * Each iteration scans the combined set of CT and GF documents that currently exist on
+     * disk.  Any newly discovered referenced content types or global fields are exported and
+     * the loop restarts so that their schemas can be scanned in turn.  Leaf dependencies
+     * (extensions, taxonomies, marketplace apps) are collected and exported in the same pass
+     * without triggering an extra iteration, since they do not themselves produce new schemas.
+     *
+     * Personalize is exported exactly once, after the closure stabilises.
+     */
+    private expandSchemaClosure;
     private exportContentModules;
     private exportEntries;
     private exportReferencedAssets;

package/lib/core/query-executor.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryExporter = void 0;
 const tslib_1 = require("tslib");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
+const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
 const query_parser_1 = require("../utils/query-parser");
 const module_exporter_1 = require("./module-exporter");
@@ -10,6 +11,7 @@ const utils_1 = require("../utils");
 const utils_2 = require("../utils");
 const utils_3 = require("../utils");
 const utils_4 = require("../utils");
+const read_content_type_schemas_1 = require("../utils/read-content-type-schemas");
 class QueryExporter {
     constructor(managementAPIClient, exportQueryConfig) {
         this.exportQueryConfig = exportQueryConfig;
@@ -31,19 +33,10 @@ class QueryExporter {
         await this.exportGeneralModules();
         // Step 4: Export queried modules
         await this.exportQueriedModule(parsedQuery);
-        // Step 1: Read initial content types and mark them as exported
-        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) {
-            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 5+6: resolve the full transitive closure of referenced content types,
+        // global fields, extensions, taxonomies, and marketplace apps.
+        cli_utilities_1.log.debug('Starting schema closure expansion', this.exportQueryConfig.context);
+        await this.expandSchemaClosure();
         // Step 7: export content modules entries, assets
         cli_utilities_1.log.debug('Starting content modules export', this.exportQueryConfig.context);
         await this.exportContentModules();
@@ -71,131 +64,112 @@ class QueryExporter {
         }
         cli_utilities_1.log.debug('Queried module export completed', this.exportQueryConfig.context);
     }
-    async exportReferencedContentTypes() {
-        cli_utilities_1.log.info('Starting export of referenced content types...', this.exportQueryConfig.context);
+    /**
+     * Iteratively expand the set of exported content types, global fields, extensions,
+     * taxonomies, and marketplace apps until no new items are discovered (fixpoint).
+     *
+     * Each iteration scans the combined set of CT and GF documents that currently exist on
+     * disk.  Any newly discovered referenced content types or global fields are exported and
+     * the loop restarts so that their schemas can be scanned in turn.  Leaf dependencies
+     * (extensions, taxonomies, marketplace apps) are collected and exported in the same pass
+     * without triggering an extra iteration, since they do not themselves produce new schemas.
+     *
+     * Personalize is exported exactly once, after the closure stabilises.
+     */
+    async expandSchemaClosure() {
+        cli_utilities_1.log.info('Starting export of referenced content types and dependent modules...', this.exportQueryConfig.context);
         try {
+            const ctPath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'content_types');
+            const gfPath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'global_fields');
             const referencedHandler = new utils_1.ReferencedContentTypesHandler(this.exportQueryConfig);
-            const exportedContentTypeUIDs = new Set();
-            // Step 1: Read initial content types and mark them as exported
-            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) {
-                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];
-            cli_utilities_1.log.info(`Starting with ${currentBatch.length} initial content types`, this.exportQueryConfig.context);
-            // track reference depth
+            const dependenciesHandler = new utils_3.ContentTypeDependenciesHandler(this.stackAPIClient, this.exportQueryConfig);
+            const exportedCTUIDs = new Set();
+            const exportedGFUIDs = new Set();
+            const exportedExtUIDs = new Set();
+            const exportedTaxUIDs = new Set();
+            const exportedMarketplaceUIDs = new Set();
             let iterationCount = 0;
-            // Step 3: Process batches until no new references are found
-            while (currentBatch.length > 0 && iterationCount < this.exportQueryConfig.maxCTReferenceDepth) {
+            while (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) {
-                    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
-                    const query = {
-                        modules: {
-                            'content-types': {
-                                uid: {
-                                    $in: newReferencedUIDs,
-                                },
-                            },
-                        },
-                    };
-                    await this.moduleExporter.exportModule('content-types', { query });
-                    const newContentTypes = utils_2.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath));
-                    currentBatch = [...newContentTypes];
-                    // Push new content types to main array
-                    contentTypes.push(...newContentTypes);
-                    cli_utilities_1.log.info(`Fetched ${currentBatch.length} new content types for next iteration`, this.exportQueryConfig.context);
+                cli_utilities_1.log.debug(`Schema closure iteration ${iterationCount}`, this.exportQueryConfig.context);
+                const allCTs = (0, read_content_type_schemas_1.readContentTypesFromExportDir)(ctPath);
+                const allGFs = (0, read_content_type_schemas_1.readGlobalFieldSchemasFromDir)(gfPath);
+                // Record everything currently on disk so we never re-export it.
+                allCTs.forEach((ct) => exportedCTUIDs.add(ct.uid));
+                allGFs.forEach((gf) => exportedGFUIDs.add(gf.uid));
+                const allSchemas = [...allCTs, ...allGFs];
+                if (allSchemas.length === 0) {
+                    cli_utilities_1.log.info('No schemas found on disk, stopping closure', this.exportQueryConfig.context);
+                    break;
+                }
+                let foundNewCTs = false;
+                let foundNewGFs = false;
+                // Step A: find and export referenced content types from the combined schema set.
+                if (!this.exportQueryConfig.skipReferences) {
+                    const referencedUIDs = await referencedHandler.extractReferencedContentTypes(allSchemas);
+                    const newCTUIDs = referencedUIDs.filter((uid) => !exportedCTUIDs.has(uid));
+                    if (newCTUIDs.length > 0) {
+                        cli_utilities_1.log.info(`Found ${newCTUIDs.length} new referenced content type(s) to fetch`, this.exportQueryConfig.context);
+                        await this.moduleExporter.exportModule('content-types', {
+                            query: { modules: { 'content-types': { uid: { $in: newCTUIDs } } } },
+                        });
+                        // Track immediately so the dedup filter works even if the disk reader
+                        // hasn't picked up the newly written files yet.
+                        newCTUIDs.forEach((uid) => exportedCTUIDs.add(uid));
+                        foundNewCTs = true;
+                    }
                 }
-                else {
-                    cli_utilities_1.log.info('No new referenced content types found, stopping recursion', this.exportQueryConfig.context);
+                // Step B: find and export dependent modules from the combined schema set.
+                if (!this.exportQueryConfig.skipDependencies) {
+                    const deps = await dependenciesHandler.extractDependencies(allSchemas);
+                    const newGFUIDs = [...deps.globalFields].filter((uid) => !exportedGFUIDs.has(uid));
+                    if (newGFUIDs.length > 0) {
+                        cli_utilities_1.log.info(`Found ${newGFUIDs.length} new global field(s)`, this.exportQueryConfig.context);
+                        await this.moduleExporter.exportModule('global-fields', {
+                            query: { modules: { 'global-fields': { uid: { $in: newGFUIDs } } } },
+                        });
+                        // Track immediately for the same reason as CTs above.
+                        newGFUIDs.forEach((uid) => exportedGFUIDs.add(uid));
+                        foundNewGFs = true;
+                    }
+                    // Extensions, taxonomies, and marketplace apps are leaf nodes: they do not
+                    // produce new schemas, so exporting them never requires an extra iteration.
+                    const newExtUIDs = [...deps.extensions].filter((uid) => !exportedExtUIDs.has(uid));
+                    if (newExtUIDs.length > 0) {
+                        cli_utilities_1.log.info(`Found ${newExtUIDs.length} new extension(s)`, this.exportQueryConfig.context);
+                        await this.moduleExporter.exportModule('extensions', {
+                            query: { modules: { extensions: { uid: { $in: newExtUIDs } } } },
+                        });
+                        newExtUIDs.forEach((uid) => exportedExtUIDs.add(uid));
+                    }
+                    const newMarketplaceUIDs = [...deps.marketplaceApps].filter((uid) => !exportedMarketplaceUIDs.has(uid));
+                    if (newMarketplaceUIDs.length > 0) {
+                        cli_utilities_1.log.info(`Found ${newMarketplaceUIDs.length} new marketplace app(s)`, this.exportQueryConfig.context);
+                        await this.moduleExporter.exportModule('marketplace-apps', {
+                            query: { modules: { 'marketplace-apps': { installation_uid: { $in: newMarketplaceUIDs } } } },
+                        });
+                        newMarketplaceUIDs.forEach((uid) => exportedMarketplaceUIDs.add(uid));
+                    }
+                    const newTaxUIDs = [...deps.taxonomies].filter((uid) => !exportedTaxUIDs.has(uid));
+                    if (newTaxUIDs.length > 0) {
+                        cli_utilities_1.log.info(`Found ${newTaxUIDs.length} new taxonom(ies)`, this.exportQueryConfig.context);
+                        await this.moduleExporter.exportModule('taxonomies', {
+                            query: { modules: { taxonomies: { uid: { $in: newTaxUIDs } } } },
+                        });
+                        newTaxUIDs.forEach((uid) => exportedTaxUIDs.add(uid));
+                    }
+                }
+                if (!foundNewCTs && !foundNewGFs) {
+                    cli_utilities_1.log.info('Schema closure complete, no new content types or global fields found', this.exportQueryConfig.context);
                     break;
                 }
             }
-            utils_2.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(contentTypesFilePath), contentTypes);
-            cli_utilities_1.log.success('Referenced content types export completed successfully', this.exportQueryConfig.context);
-        }
-        catch (error) {
-            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error exporting referenced content types');
-            throw error;
-        }
-    }
-    async exportDependentModules() {
-        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);
-                cli_utilities_1.log.info(`Exporting ${globalFieldUIDs.length} global fields...`, this.exportQueryConfig.context);
-                const query = {
-                    modules: {
-                        'global-fields': {
-                            uid: { $in: globalFieldUIDs },
-                        },
-                    },
-                };
-                await this.moduleExporter.exportModule('global-fields', { query });
-            }
-            // Export Extensions
-            if (dependencies.extensions.size > 0) {
-                const extensionUIDs = Array.from(dependencies.extensions);
-                cli_utilities_1.log.info(`Exporting ${extensionUIDs.length} extensions...`, this.exportQueryConfig.context);
-                const query = {
-                    modules: {
-                        extensions: {
-                            uid: { $in: extensionUIDs },
-                        },
-                    },
-                };
-                await this.moduleExporter.exportModule('extensions', { query });
-            }
-            // export marketplace apps
-            if (dependencies.marketplaceApps.size > 0) {
-                const marketplaceAppInstallationUIDs = Array.from(dependencies.marketplaceApps);
-                cli_utilities_1.log.info(`Exporting ${marketplaceAppInstallationUIDs.length} marketplace apps...`, this.exportQueryConfig.context);
-                const query = {
-                    modules: {
-                        'marketplace-apps': {
-                            installation_uid: { $in: marketplaceAppInstallationUIDs },
-                        },
-                    },
-                };
-                await this.moduleExporter.exportModule('marketplace-apps', { query });
-            }
-            // Export Taxonomies
-            if (dependencies.taxonomies.size > 0) {
-                const taxonomyUIDs = Array.from(dependencies.taxonomies);
-                cli_utilities_1.log.info(`Exporting ${taxonomyUIDs.length} taxonomies...`, this.exportQueryConfig.context);
-                const query = {
-                    modules: {
-                        taxonomies: {
-                            uid: { $in: taxonomyUIDs },
-                        },
-                    },
-                };
-                await this.moduleExporter.exportModule('taxonomies', { query });
-            }
-            // export personalize
+            // Personalize is a single global module exported once after the closure stabilises.
             await this.moduleExporter.exportModule('personalize');
-            cli_utilities_1.log.success('Dependent modules export completed successfully', this.exportQueryConfig.context);
+            cli_utilities_1.log.success('Referenced content types and dependent modules exported successfully', this.exportQueryConfig.context);
         }
         catch (error) {
-            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error exporting dependent modules');
+            (0, cli_utilities_1.handleAndLogError)(error, this.exportQueryConfig.context, 'Error during schema closure expansion');
             throw error;
         }
     }
@@ -244,18 +218,9 @@ class QueryExporter {
             const assetUIDs = assetHandler.extractReferencedAssets();
             if (assetUIDs.length > 0) {
                 cli_utilities_1.log.info(`Found ${assetUIDs.length} referenced assets to export`, this.exportQueryConfig.context);
+                fs.mkdirSync(assetsDir, { recursive: true });
                 // 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 });
-                }
                 // 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);

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

@@ -36,16 +36,22 @@ class ReferencedContentTypesHandler {
     getReferencedContentTypes(schema) {
         const referencedTypes = new Set();
         const traverseSchema = (schemaArray) => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             for (const field of schemaArray) {
                 if (field.data_type === 'group' || field.data_type === 'global_field') {
-                    // Recursively traverse group and global field schemas
-                    traverseSchema(field.schema);
+                    // Recursively traverse group and global field schemas.
+                    // field.schema may be absent when a global_field is represented only by
+                    // its reference_to UID (stub form in a content type's inline schema).
+                    if (Array.isArray(field.schema) && field.schema.length > 0) {
+                        traverseSchema(field.schema);
+                    }
                 }
                 else if (field.data_type === 'blocks') {
                     // Traverse each block's schema
                     for (const blockKey in field.blocks) {
-                        traverseSchema(field.blocks[blockKey].schema);
+                        if ((_a = field.blocks[blockKey]) === null || _a === void 0 ? void 0 : _a.schema) {
+                            traverseSchema(field.blocks[blockKey].schema);
+                        }
                     }
                 }
                 else if (field.data_type === 'reference' && field.reference_to) {
@@ -60,8 +66,8 @@ class ReferencedContentTypesHandler {
                 else if (
                 // Handle JSON RTE with embedded entries
                 field.data_type === 'json' &&
-                    ((_a = field.field_metadata) === null || _a === void 0 ? void 0 : _a.rich_text_type) &&
-                    ((_b = field.field_metadata) === null || _b === void 0 ? void 0 : _b.embed_entry) &&
+                    ((_b = field.field_metadata) === null || _b === void 0 ? void 0 : _b.rich_text_type) &&
+                    ((_c = field.field_metadata) === null || _c === void 0 ? void 0 : _c.embed_entry) &&
                     field.reference_to) {
                     field.reference_to.forEach((ref) => {
                         if (ref !== 'sys_assets') {
@@ -72,8 +78,8 @@ class ReferencedContentTypesHandler {
                 else if (
                 // Handle Text RTE with embedded entries
                 field.data_type === 'text' &&
-                    ((_c = field.field_metadata) === null || _c === void 0 ? void 0 : _c.rich_text_type) &&
-                    ((_d = field.field_metadata) === null || _d === void 0 ? void 0 : _d.embed_entry) &&
+                    ((_d = field.field_metadata) === null || _d === void 0 ? void 0 : _d.rich_text_type) &&
+                    ((_e = field.field_metadata) === null || _e === void 0 ? void 0 : _e.embed_entry) &&
                     field.reference_to) {
                     field.reference_to.forEach((ref) => {
                         if (ref !== 'sys_assets') {

package/lib/utils/dependency-resolver.d.ts

@@ -3,7 +3,16 @@ export declare class ContentTypeDependenciesHandler {
     private exportQueryConfig;
     private stackAPIClient;
     constructor(stackAPIClient: any, exportQueryConfig: QueryExportConfig);
-    extractDependencies(): Promise<{
+    /**
+     * Extract all dependencies (global fields, extensions, taxonomies, marketplace apps) from the
+     * provided schema documents.  When `schemas` is omitted the method falls back to reading content
+     * type schemas from disk — kept for backward compatibility with callers that do not supply
+     * already-loaded documents.
+     *
+     * Pass the combined set of content-type AND global-field documents so that transitive
+     * dependencies inside global fields are discovered in the same pass.
+     */
+    extractDependencies(schemas?: any[]): Promise<{
         globalFields: Set<string>;
         extensions: Set<string>;
         taxonomies: Set<string>;

package/lib/utils/dependency-resolver.js

@@ -3,18 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentTypeDependenciesHandler = void 0;
 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 read_content_type_schemas_1 = require("./read-content-type-schemas");
 class ContentTypeDependenciesHandler {
     constructor(stackAPIClient, exportQueryConfig) {
         this.exportQueryConfig = exportQueryConfig;
         this.stackAPIClient = stackAPIClient;
     }
-    async extractDependencies() {
-        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) {
-            cli_utilities_1.log.info('No content types found, skipping dependency extraction', this.exportQueryConfig.context);
+    /**
+     * Extract all dependencies (global fields, extensions, taxonomies, marketplace apps) from the
+     * provided schema documents.  When `schemas` is omitted the method falls back to reading content
+     * type schemas from disk — kept for backward compatibility with callers that do not supply
+     * already-loaded documents.
+     *
+     * Pass the combined set of content-type AND global-field documents so that transitive
+     * dependencies inside global fields are discovered in the same pass.
+     */
+    async extractDependencies(schemas) {
+        let allSchemas;
+        if (schemas !== undefined) {
+            allSchemas = schemas;
+        }
+        else {
+            const contentTypesFilePath = path.join((0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(this.exportQueryConfig.branchName || ''), 'content_types');
+            allSchemas = (0, read_content_type_schemas_1.readContentTypesFromExportDir)(contentTypesFilePath);
+        }
+        if (allSchemas.length === 0) {
+            cli_utilities_1.log.info('No schemas found, skipping dependency extraction', this.exportQueryConfig.context);
             return {
                 globalFields: new Set(),
                 extensions: new Set(),
@@ -22,16 +37,16 @@ class ContentTypeDependenciesHandler {
                 marketplaceApps: new Set(),
             };
         }
-        cli_utilities_1.log.info(`Extracting dependencies from ${allContentTypes.length} content types`, this.exportQueryConfig.context);
+        cli_utilities_1.log.info(`Extracting dependencies from ${allSchemas.length} schema(s)`, this.exportQueryConfig.context);
         const dependencies = {
             globalFields: new Set(),
             extensions: new Set(),
             taxonomies: new Set(),
             marketplaceApps: new Set(),
         };
-        for (const contentType of allContentTypes) {
-            if (contentType.schema) {
-                this.traverseSchemaForDependencies(contentType.schema, dependencies);
+        for (const doc of allSchemas) {
+            if (doc.schema) {
+                this.traverseSchemaForDependencies(doc.schema, dependencies);
             }
         }
         // Separate extensions from marketplace apps using the extracted extension UIDs
@@ -109,7 +124,7 @@ class ContentTypeDependenciesHandler {
                 });
             }
             // Recursive traversal for nested structures
-            if (field.data_type === 'group' && field.schema) {
+            if ((field.data_type === 'group' || field.data_type === 'global_field') && field.schema) {
                 this.traverseSchemaForDependencies(field.schema, dependencies);
             }
             if (field.data_type === 'blocks' && field.blocks) {

package/lib/utils/query-parser.js

@@ -35,6 +35,7 @@ class QueryParser {
         }
         catch (error) {
             (0, cli_utilities_1.handleAndLogError)(error, this.config.context, 'Invalid JSON query');
+            throw new cli_utilities_1.CLIError('Invalid JSON query');
         }
     }
     validate(query) {

package/lib/utils/read-content-type-schemas.d.ts

@@ -0,0 +1,16 @@
+/**
+ * CLI v1 aggregate content types under `content_types/schema.json`.
+ */
+export declare function readContentTypesFromExportDir(dir: string): any[];
+/**
+ * Global fields: prefer `global_fields/globalfields.json` (cm-export v1), then per-file / per-subfolder layouts.
+ */
+export declare function readGlobalFieldSchemasFromDir(dir: string): any[];
+/**
+ * Rebuild `content_types/schema.json` from every per–content-type `*.json` in the folder
+ * (excluding `schema.json` itself). Each `cm:stacks:export --module content-types` run
+ * overwrites `schema.json` with that run’s batch only; query-export runs that module
+ * multiple times, so without this merge the aggregate omits earlier types and the
+ * entries module (which only reads `schema.json`) skips their entries.
+ */
+export declare function rebuildContentTypesSchemaJson(ctDir: string): void;

package/lib/utils/read-content-type-schemas.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebuildContentTypesSchemaJson = exports.readGlobalFieldSchemasFromDir = exports.readContentTypesFromExportDir = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const file_helper_1 = require("./file-helper");
+function normalizeToArray(raw) {
+    if (raw == null)
+        return [];
+    if (Array.isArray(raw))
+        return raw;
+    if (typeof raw === 'object')
+        return Object.values(raw);
+    return [];
+}
+/**
+ * CLI v1 aggregate content types under `content_types/schema.json`.
+ */
+function readContentTypesFromExportDir(dir) {
+    const schemaPath = path.join((0, cli_utilities_1.sanitizePath)(dir), 'schema.json');
+    try {
+        const raw = file_helper_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(schemaPath));
+        return normalizeToArray(raw);
+    }
+    catch (_a) {
+        return [];
+    }
+}
+exports.readContentTypesFromExportDir = readContentTypesFromExportDir;
+function readGlobalFieldSchemasFromSubdirs(base) {
+    if (!fs.existsSync(base))
+        return [];
+    const out = [];
+    for (const name of fs.readdirSync(base)) {
+        if (name === 'globalfields.json' || name === 'schema.json')
+            continue;
+        const full = path.join(base, name);
+        let st;
+        try {
+            st = fs.statSync(full);
+        }
+        catch (_a) {
+            continue;
+        }
+        if (!st.isDirectory()) {
+            if (name.endsWith('.json')) {
+                try {
+                    const doc = file_helper_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(full));
+                    if (doc && typeof doc === 'object')
+                        out.push(doc);
+                }
+                catch (_b) {
+                    /* skip invalid */
+                }
+            }
+            continue;
+        }
+        const uid = name;
+        const candidates = [path.join(full, `${uid}.json`), path.join(full, 'index.json')];
+        let loaded = false;
+        for (const p of candidates) {
+            if (fs.existsSync(p)) {
+                try {
+                    const doc = file_helper_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(p));
+                    if (doc && typeof doc === 'object') {
+                        out.push(doc);
+                        loaded = true;
+                        break;
+                    }
+                }
+                catch (_c) {
+                    /* try next */
+                }
+            }
+        }
+        if (loaded)
+            continue;
+        try {
+            for (const f of fs.readdirSync(full)) {
+                if (!f.endsWith('.json'))
+                    continue;
+                const doc = file_helper_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(path.join(full, f)));
+                if (doc && typeof doc === 'object') {
+                    out.push(doc);
+                    break;
+                }
+            }
+        }
+        catch (_d) {
+            /* skip */
+        }
+    }
+    return out;
+}
+/**
+ * Global fields: prefer `global_fields/globalfields.json` (cm-export v1), then per-file / per-subfolder layouts.
+ */
+function readGlobalFieldSchemasFromDir(dir) {
+    const base = (0, cli_utilities_1.sanitizePath)(dir);
+    const aggPath = path.join(base, 'globalfields.json');
+    if (fs.existsSync(aggPath)) {
+        try {
+            const raw = file_helper_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(aggPath));
+            const list = normalizeToArray(raw);
+            if (list.length > 0)
+                return list;
+        }
+        catch (_a) {
+            /* fall through to subdir scan */
+        }
+    }
+    return readGlobalFieldSchemasFromSubdirs(base);
+}
+exports.readGlobalFieldSchemasFromDir = readGlobalFieldSchemasFromDir;
+/**
+ * Rebuild `content_types/schema.json` from every per–content-type `*.json` in the folder
+ * (excluding `schema.json` itself). Each `cm:stacks:export --module content-types` run
+ * overwrites `schema.json` with that run’s batch only; query-export runs that module
+ * multiple times, so without this merge the aggregate omits earlier types and the
+ * entries module (which only reads `schema.json`) skips their entries.
+ */
+function rebuildContentTypesSchemaJson(ctDir) {
+    const dir = (0, cli_utilities_1.sanitizePath)(ctDir);
+    if (!fs.existsSync(dir))
+        return;
+    const byUid = new Map();
+    for (const name of fs.readdirSync(dir)) {
+        if (!name.endsWith('.json') || name === 'schema.json')
+            continue;
+        const fp = path.join(dir, name);
+        let st;
+        try {
+            st = fs.statSync(fp);
+        }
+        catch (_a) {
+            continue;
+        }
+        if (!st.isFile())
+            continue;
+        try {
+            const doc = file_helper_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(fp));
+            if (doc && typeof doc === 'object' && !Array.isArray(doc) && typeof doc.uid === 'string') {
+                byUid.set(doc.uid, doc);
+            }
+        }
+        catch (_b) {
+            /* skip invalid JSON */
+        }
+    }
+    const merged = Array.from(byUid.values());
+    if (merged.length === 0)
+        return;
+    const schemaPath = path.join(dir, 'schema.json');
+    file_helper_1.fsUtil.writeFile((0, cli_utilities_1.sanitizePath)(schemaPath), merged);
+}
+exports.rebuildContentTypesSchemaJson = rebuildContentTypesSchemaJson;

package/messages/index.json

@@ -1 +1,75 @@
-{}
+{
+  "ASSET_EXPORT_COMPLETE": "Asset export process completed successfully",
+  "ASSET_FOLDERS_EXPORT_COMPLETE": "Asset folder structure exported successfully",
+  "ASSET_METADATA_EXPORT_COMPLETE": "Asset metadata exported successfully",
+  "ASSET_VERSIONED_METADATA_EXPORT_COMPLETE": "Versioned asset metadata exported successfully",
+  "ASSET_DOWNLOAD_COMPLETE": "Asset download completed successfully",
+  "ASSET_DOWNLOAD_SUCCESS": "Asset '%s' (UID: %s) downloaded successfully",
+  "ASSET_DOWNLOAD_FAILED": "Failed to download asset '%s' (UID: %s)",
+  "ASSET_WRITE_FAILED": "Failed to write asset file '%s' (UID: %s)",
+  "ASSET_QUERY_FAILED": "Failed to query asset data from the API",
+  "ASSET_VERSIONED_QUERY_FAILED": "Failed to query versioned asset data from the API",
+  "ASSET_COUNT_QUERY_FAILED": "Failed to retrieve total asset count",
+
+  "CONTENT_TYPE_EXPORT_COMPLETE": "Content types exported successfully",
+  "CONTENT_TYPE_NO_TYPES": "No content types found",
+  "CONTENT_TYPE_EXPORT_FAILED": "Failed to export content types",
+  "CONTENT_TYPE_NO_TYPES_RETURNED": "API returned no content types for the given query",
+
+  "ENVIRONMENT_EXPORT_COMPLETE": "Successfully exported %s environment(s)",
+  "ENVIRONMENT_EXPORT_SUCCESS": "Environment '%s' exported successfully",
+  "ENVIRONMENT_NOT_FOUND": "No environments found in the current stack",
+
+  "EXTENSION_EXPORT_COMPLETE": "Successfully exported %s extension(s)",
+  "EXTENSION_EXPORT_SUCCESS": "Extension '%s' exported successfully",
+  "EXTENSION_NOT_FOUND": "No extensions found in the current stack",
+
+  "GLOBAL_FIELDS_EXPORT_COMPLETE": "Successfully exported %s global field(s)",
+
+  "LABELS_EXPORT_COMPLETE": "Successfully exported %s label(s)",
+  "LABEL_EXPORT_SUCCESS": "Label '%s' exported successfully",
+  "LABELS_NOT_FOUND": "No labels found in the current stack",
+
+  "LOCALES_EXPORT_COMPLETE": "Successfully exported %s locale(s) including %s master locale(s)",
+
+  "TAXONOMY_EXPORT_COMPLETE": "Successfully exported %s taxonomy entries",
+  "TAXONOMY_EXPORT_SUCCESS": "Taxonomy '%s' exported successfully",
+  "TAXONOMY_NOT_FOUND": "No taxonomies found in the current stack",
+
+  "WEBHOOK_EXPORT_COMPLETE": "Successfully exported %s webhook(s)",
+  "WEBHOOK_EXPORT_SUCCESS": "Webhook '%s' exported successfully",
+  "WEBHOOK_NOT_FOUND": "No webhooks found in the current stack",
+
+  "WORKFLOW_EXPORT_COMPLETE": "Successfully exported %s workflow(s)",
+  "WORKFLOW_EXPORT_SUCCESS": "Workflow '%s' exported successfully",
+  "WORKFLOW_NOT_FOUND": "No workflows found in the current stack",
+
+  "PERSONALIZE_URL_NOT_SET": "Cannot export Personalize project: URL not configured",
+  "PERSONALIZE_SKIPPING_WITH_MANAGEMENT_TOKEN": "Skipping Personalize project export: Management token not supported",
+  "PERSONALIZE_MODULE_NOT_IMPLEMENTED": "Module '%s' implementation not found",
+  "PERSONALIZE_NOT_ENABLED": "Personalize feature is not enabled for this organization",
+
+  "MARKETPLACE_APPS_EXPORT_COMPLETE": "Successfully exported %s marketplace app(s)",
+  "MARKETPLACE_APP_CONFIG_EXPORT": "Exporting configuration for app '%s'",
+  "MARKETPLACE_APP_CONFIG_SUCCESS": "Successfully exported configuration for app '%s'",
+  "MARKETPLACE_APP_EXPORT_SUCCESS": "Successfully exported app '%s'",
+  "MARKETPLACE_APPS_NOT_FOUND": "No marketplace apps found in the current stack",
+  "MARKETPLACE_APP_CONFIG_EXPORT_FAILED": "Failed to export configuration for app '%s'",
+  "MARKETPLACE_APP_MANIFEST_EXPORT_FAILED": "Failed to export manifest for app '%s'",
+
+  "COMPOSABLE_STUDIO_EXPORT_START": "Starting Studio project export...",
+  "COMPOSABLE_STUDIO_NOT_FOUND": "No Studio project found for this stack",
+  "COMPOSABLE_STUDIO_EXPORT_COMPLETE": "Successfully exported Studio project '%s'",
+  "COMPOSABLE_STUDIO_EXPORT_FAILED": "Failed to export Studio project: %s",
+  "COMPOSABLE_STUDIO_AUTH_REQUIRED": "To export Studio projects, you must be logged in",
+
+  "ENTRIES_EXPORT_COMPLETE": "Successfully exported entries (Content Type: %s, Locale: %s)",
+  "ENTRIES_EXPORT_SUCCESS": "All entries exported successfully",
+  "ENTRIES_VERSIONED_EXPORT_SUCCESS": "Successfully exported versioned entry (Content Type: %s, UID: %s, Locale: %s)",
+  "ENTRIES_EXPORT_VERSIONS_FAILED": "Failed to export versions for content type '%s' (UID: %s)",
+
+  "BRANCH_EXPORT_FAILED": "Failed to export contents from branch (UID: %s)",
+
+  "ROLES_NO_CUSTOM_ROLES": "No custom roles found in the current stack",
+  "ROLES_EXPORTING_ROLE": "Exporting role '%s'"
+}

package/oclif.manifest.json

@@ -115,5 +115,5 @@
       ]
     }
   },
-  "version": "1.0.0-beta.9"
+  "version": "1.0.0"
 }

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@contentstack/cli-cm-export-query",
   "description": "Contentstack CLI plugin to export content from stack",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
-    "@contentstack/cli-cm-export": "~1.23.2",
-    "@contentstack/cli-command": "~1.7.2",
-    "@contentstack/cli-utilities": "~1.17.4",
-    "@oclif/core": "^4.3.0",
+    "@contentstack/cli-variants": "~1.4.3",
+    "@contentstack/cli-cm-export": "~1.24.3",
+    "@contentstack/cli-command": "~1.8.2",
+    "@contentstack/cli-utilities": "~1.18.3",
+    "@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.23",
+    "lodash": "^4.18.1",
     "merge": "^2.1.1",
     "mkdirp": "^1.0.4",
     "progress-stream": "^2.0.0",
@@ -21,22 +21,25 @@
     "tslib": "^2.8.1",
     "winston": "^3.19.0"
   },
+  "overrides": {
+    "brace-expansion": "^5.0.5"
+  },
   "devDependencies": {
     "@contentstack/cli-dev-dependencies": "~1.3.1",
-    "@oclif/plugin-help": "^6.2.37",
-    "@oclif/test": "^4.1.16",
+    "@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.37",
+    "@types/node": "^20.19.39",
     "@types/progress-stream": "^2.0.5",
     "@types/sinon": "^17.0.4",
     "chai": "^4.5.0",
     "dotenv": "^16.6.1",
     "dotenv-expand": "^9.0.0",
     "eslint": "^8.57.1",
-    "eslint-config-oclif": "^6.0.148",
+    "eslint-config-oclif": "^6.0.157",
     "husky": "^9.1.7",
     "mocha": "10.8.2",
     "nyc": "^15.1.0",
@@ -46,19 +49,23 @@
     "typescript": "^4.9.5"
   },
   "scripts": {
-    "build": "npm run clean && npm install && npm run compile && cp -r src/config lib/",
-    "clean": "rm -rf ./lib ./node_modules tsconfig.build.tsbuildinfo",
+    "build": "pnpm compile && pnpm copy-config && oclif manifest && oclif readme",
+    "clean": "rm -rf ./lib ./node_modules tsconfig.tsbuildinfo",
     "compile": "tsc -b tsconfig.json",
     "postpack": "rm -f oclif.manifest.json",
-    "prepack": "npm run compile && oclif manifest && oclif readme && cp -r src/config lib/",
+    "copy-config": "cp -r src/config lib/",
+    "prepack": "pnpm compile && pnpm copy-config && oclif manifest && oclif readme",
     "version": "oclif readme && git add README.md",
     "test:report": "tsc -p test && nyc --reporter=lcov --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
     "pretest": "tsc -p test",
     "test": "nyc --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
+    "posttest": "npm run lint",
     "lint": "eslint src/**/*.ts",
     "format": "eslint src/**/*.ts --fix",
+    "test:integration": "INTEGRATION_TEST=true mocha --config ./test/.mocharc.js --forbid-only \"test/run.test.js\"",
+    "test:integration:report": "INTEGRATION_TEST=true nyc --extension .js mocha --forbid-only \"test/run.test.js\"",
     "test:unit": "mocha --forbid-only \"test/unit/**/*.test.ts\"",
-    "prepare": "npx husky && chmod +x .husky/pre-commit"
+    "test:unit:report": "nyc --reporter=text --extension .ts mocha --forbid-only \"test/unit/**/*.test.ts\""
   },
   "engines": {
     "node": ">=14.0.0"