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

package/lib/utils/dependency-resolver.js

@@ -0,0 +1,126 @@
+"use strict";
+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 logger_1 = require("./logger");
+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) {
+            (0, logger_1.log)(this.exportQueryConfig, 'No content types found, skipping dependency extraction', 'info');
+            return {
+                globalFields: new Set(),
+                extensions: new Set(),
+                taxonomies: new Set(),
+                marketplaceApps: new Set(),
+            };
+        }
+        (0, logger_1.log)(this.exportQueryConfig, `Extracting dependencies from ${allContentTypes.length} content types`, 'info');
+        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);
+            }
+        }
+        // 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');
+            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');
+            }
+            catch (error) {
+                (0, logger_1.log)(this.exportQueryConfig, `Error separating extensions and marketplace apps: ${error.message}`, 'error');
+                // 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');
+        }
+        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');
+        try {
+            // Query parameters to include marketplace extensions
+            const queryParams = {
+                include_count: true,
+                include_marketplace_extensions: true,
+                query: {
+                    uid: { $in: extensionUIDs },
+                },
+            };
+            // 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');
+                return { extensions: extensionUIDs, marketplaceApps: [] };
+            }
+            const marketplaceApps = [];
+            const regularExtensions = [];
+            response.items.forEach((item) => {
+                if (item.app_uid && item.app_installation_uid) {
+                    marketplaceApps.push(item.app_installation_uid);
+                }
+                else {
+                    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');
+            return { extensions: regularExtensions, marketplaceApps };
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error fetching extensions and marketplace apps: ${error.message}`, 'error');
+            return { extensions: extensionUIDs, marketplaceApps: [] };
+        }
+    }
+    traverseSchemaForDependencies(schema, dependencies) {
+        for (const field of schema) {
+            // Global fields
+            if (field.data_type === 'global_field' && field.reference_to) {
+                dependencies.globalFields.add(field.reference_to);
+            }
+            // Extensions
+            if (field.extension_uid) {
+                dependencies.extensions.add(field.extension_uid);
+            }
+            // Taxonomies - UPDATED LOGIC
+            if (field.data_type === 'taxonomy' && field.taxonomies && Array.isArray(field.taxonomies)) {
+                field.taxonomies.forEach((tax) => {
+                    if (tax.taxonomy_uid) {
+                        dependencies.taxonomies.add(tax.taxonomy_uid);
+                    }
+                });
+            }
+            // Recursive traversal for nested structures
+            if (field.data_type === 'group' && field.schema) {
+                this.traverseSchemaForDependencies(field.schema, dependencies);
+            }
+            if (field.data_type === 'blocks' && field.blocks) {
+                for (const blockKey in field.blocks) {
+                    if (field.blocks[blockKey].schema) {
+                        this.traverseSchemaForDependencies(field.blocks[blockKey].schema, dependencies);
+                    }
+                }
+            }
+        }
+    }
+}
+exports.ContentTypeDependenciesHandler = ContentTypeDependenciesHandler;

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

@@ -0,0 +1,2 @@
+import { FsUtility } from '@contentstack/cli-utilities';
+export declare const fsUtil: FsUtility;

package/lib/utils/file-helper.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsUtil = void 0;
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+exports.fsUtil = new cli_utilities_1.FsUtility();

package/lib/utils/index.d.ts

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

package/lib/utils/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+Object.defineProperty(exports, "fsUtil", { enumerable: true, get: function () { return file_helper_1.fsUtil; } });
+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; } });
+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);

package/lib/utils/logger.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2024 Contentstack LLC
+ * MIT Licensed
+ */
+import { QueryExportConfig } from '../types';
+export declare const log: (config: QueryExportConfig, message: any, type: string) => Promise<void>;
+export declare const unlinkFileLogger: () => void;

package/lib/utils/logger.js

@@ -0,0 +1,158 @@
+"use strict";
+/*!
+ * Contentstack Export
+ * Copyright (c) 2024 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const slice = Array.prototype.slice;
+const ansiRegexPattern = [
+    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+    '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))',
+].join('|');
+function returnString(args) {
+    let returnStr = '';
+    if (args && args.length) {
+        returnStr = args
+            .map(function (item) {
+            if (item && typeof item === 'object') {
+                try {
+                    const redactedObject = (0, cli_utilities_1.redactObject)(item);
+                    if (redactedObject && typeof redactedObject === 'object') {
+                        return JSON.stringify(redactedObject);
+                    }
+                }
+                catch (error) { }
+                return item;
+            }
+            return item;
+        })
+            .join('  ')
+            .trim();
+    }
+    returnStr = returnStr.replace(new RegExp(ansiRegexPattern, 'g'), '').trim();
+    return returnStr;
+}
+const myCustomLevels = {
+    levels: {
+        warn: 1,
+        info: 2,
+        debug: 3,
+    },
+    colors: {
+        //colors aren't being used anywhere as of now, we're using chalk to add colors while logging
+        info: 'blue',
+        debug: 'green',
+        warn: 'yellow',
+        error: 'red',
+    },
+};
+let logger;
+let errorLogger;
+let successTransport;
+let errorTransport;
+function init(_logPath) {
+    if (!logger || !errorLogger) {
+        const logsDir = path.resolve((0, cli_utilities_1.sanitizePath)(_logPath), 'logs', 'export');
+        // Create dir if doesn't already exist
+        mkdirp_1.default.sync(logsDir);
+        successTransport = {
+            filename: path.join((0, cli_utilities_1.sanitizePath)(logsDir), 'success.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'info',
+        };
+        errorTransport = {
+            filename: path.join((0, cli_utilities_1.sanitizePath)(logsDir), 'error.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'error',
+        };
+        logger = winston.createLogger({
+            transports: [
+                new winston.transports.File(successTransport),
+                new winston.transports.Console({ format: winston.format.simple() }),
+            ],
+            levels: myCustomLevels.levels,
+        });
+        errorLogger = winston.createLogger({
+            transports: [
+                new winston.transports.File(errorTransport),
+                new winston.transports.Console({
+                    level: 'error',
+                    format: winston.format.combine(winston.format.colorize({ all: true, colors: { error: 'red' } }), winston.format.simple()),
+                }),
+            ],
+            levels: { error: 0 },
+        });
+    }
+    return {
+        log: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('info', logString);
+            }
+        },
+        warn: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('warn', logString);
+            }
+        },
+        error: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                errorLogger.log('error', logString);
+            }
+        },
+        debug: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('debug', logString);
+            }
+        },
+    };
+}
+const log = async (config, message, type) => {
+    const logsPath = (0, cli_utilities_1.sanitizePath)(config.logsPath || config.dataPath);
+    // ignoring the type argument, as we are not using it to create a logfile anymore
+    if (type !== 'error') {
+        // removed type argument from init method
+        init(logsPath).log(message);
+    }
+    else {
+        init(logsPath).error(message);
+    }
+};
+exports.log = log;
+const unlinkFileLogger = () => {
+    if (logger) {
+        const transports = logger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                logger.remove(transport);
+            }
+        });
+    }
+    if (errorLogger) {
+        const transports = errorLogger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                errorLogger.remove(transport);
+            }
+        });
+    }
+};
+exports.unlinkFileLogger = unlinkFileLogger;

package/lib/utils/query-parser.d.ts

@@ -0,0 +1,9 @@
+import { QueryExportConfig } from '../types';
+export declare class QueryParser {
+    private config;
+    constructor(config: QueryExportConfig);
+    parse(queryInput: string): Promise<any>;
+    private parseFromFile;
+    private parseFromString;
+    private validate;
+}

package/lib/utils/query-parser.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryParser = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+class QueryParser {
+    constructor(config) {
+        this.config = config;
+    }
+    async parse(queryInput) {
+        let query;
+        // Check if it's a file path
+        if (queryInput.endsWith('.json') && fs.existsSync(queryInput)) {
+            query = this.parseFromFile(queryInput);
+        }
+        else {
+            query = this.parseFromString(queryInput);
+        }
+        this.validate(query);
+        return query;
+    }
+    parseFromFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new cli_utilities_1.CLIError(`Failed to parse query file: ${error.message}`);
+        }
+    }
+    parseFromString(queryString) {
+        try {
+            return JSON.parse(queryString);
+        }
+        catch (error) {
+            throw new cli_utilities_1.CLIError(`Invalid JSON query: ${error.message}`);
+        }
+    }
+    validate(query) {
+        if (!query || typeof query !== 'object') {
+            throw new cli_utilities_1.CLIError('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');
+        }
+        const modules = Object.keys(query.modules);
+        if (modules.length === 0) {
+            throw new cli_utilities_1.CLIError('Query must contain at least one module');
+        }
+        // Validate supported modules
+        const queryableModules = this.config.modules.queryable;
+        for (const module of modules) {
+            if (!queryableModules.includes(module)) {
+                throw new cli_utilities_1.CLIError(`Module "${module}" is not queryable. Supported modules: ${queryableModules.join(', ')}`);
+            }
+        }
+    }
+}
+exports.QueryParser = QueryParser;

package/lib/utils/referenced-asset-handler.d.ts

@@ -0,0 +1,22 @@
+import { QueryExportConfig } from '../types';
+export declare class AssetReferenceHandler {
+    private exportQueryConfig;
+    private entriesDir;
+    constructor(exportQueryConfig: QueryExportConfig);
+    /**
+     * Extract all asset UIDs by processing entries file by file (memory efficient)
+     */
+    extractReferencedAssets(): string[];
+    /**
+     * Process a single file and extract asset UIDs from all its entries
+     */
+    private processSingleFile;
+    /**
+     * Extract asset UIDs from stringified content using multiple patterns
+     */
+    private extractAssetUIDsFromString;
+    /**
+     * Recursively find all JSON files in the entries directory
+     */
+    private findAllJsonFiles;
+}

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetReferenceHandler = void 0;
+const tslib_1 = require("tslib");
+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;
+        this.entriesDir = path.join((0, cli_utilities_1.sanitizePath)(exportQueryConfig.exportDir), (0, cli_utilities_1.sanitizePath)(exportQueryConfig.branchName || ''), 'entries');
+    }
+    /**
+     * 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');
+        try {
+            if (!fs.existsSync(this.entriesDir)) {
+                (0, logger_1.log)(this.exportQueryConfig, 'Entries directory does not exist', 'warn');
+                return [];
+            }
+            // Global set to maintain unique asset UIDs across all files
+            const globalAssetUIDs = new Set();
+            // Get all JSON files
+            const jsonFiles = this.findAllJsonFiles(this.entriesDir);
+            // Process files one by one
+            let totalEntriesProcessed = 0;
+            for (const jsonFile of jsonFiles) {
+                const entriesInFile = this.processSingleFile(jsonFile, globalAssetUIDs);
+                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');
+            return result;
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error extracting assets: ${error.message}`, 'error');
+            return [];
+        }
+    }
+    /**
+     * Process a single file and extract asset UIDs from all its entries
+     */
+    processSingleFile(filePath, globalAssetUIDs) {
+        // Skip index.json files
+        if (path.basename(filePath) === 'index.json') {
+            return 0;
+        }
+        try {
+            const fileContent = index_1.fsUtil.readFile((0, cli_utilities_1.sanitizePath)(filePath));
+            if (!fileContent || typeof fileContent !== 'object') {
+                return 0;
+            }
+            // Stringify the ENTIRE file content at once
+            const fileString = JSON.stringify(fileContent);
+            // Extract all asset UIDs from the entire file
+            const assetUIDs = this.extractAssetUIDsFromString(fileString);
+            // Add to global set
+            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');
+            return entriesCount;
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error processing file ${filePath}: ${error.message}`, 'warn');
+            return 0;
+        }
+    }
+    /**
+     * Extract asset UIDs from stringified content using multiple patterns
+     */
+    extractAssetUIDsFromString(content) {
+        const assetUIDs = new Set();
+        // Pattern 1: HTML img tags with asset_uid
+        const htmlAssetRegex = /<img asset_uid=\\"([^"]+)\\"/g;
+        let match;
+        while ((match = htmlAssetRegex.exec(content)) !== null) {
+            if (match[1]) {
+                assetUIDs.add(match[1]);
+            }
+        }
+        // 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');
+        while ((match = urlRegex.exec(content)) !== null) {
+            const assetUID = match[6]; // The asset UID is in the 6th capture group
+            if (assetUID) {
+                assetUIDs.add(assetUID);
+            }
+        }
+        return Array.from(assetUIDs);
+    }
+    /**
+     * Recursively find all JSON files in the entries directory
+     */
+    findAllJsonFiles(dir) {
+        const jsonFiles = [];
+        try {
+            const items = fs.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path.join(dir, item);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    jsonFiles.push(...this.findAllJsonFiles(fullPath));
+                }
+                else if (stat.isFile() && item.endsWith('.json')) {
+                    jsonFiles.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            (0, logger_1.log)(this.exportQueryConfig, `Error reading directory ${dir}: ${error.message}`, 'warn');
+        }
+        return jsonFiles;
+    }
+}
+exports.AssetReferenceHandler = AssetReferenceHandler;

package/messages/index.json

@@ -0,0 +1 @@
+{}

package/oclif.manifest.json

@@ -0,0 +1,108 @@
+{
+  "commands": {
+    "cm:stacks:export-query": {
+      "aliases": [
+        "cm:export-query"
+      ],
+      "args": {},
+      "description": "Export content from a stack using query-based filtering",
+      "examples": [
+        "csdx cm:stacks:export-query --query '{\"modules\":{\"content-types\":{\"title\":{\"$in\":[\"Blog\",\"Author\"]}}}}'",
+        "csdx cm:stacks:export-query --query ./ct-query.json --skip-references",
+        "csdx cm:stacks:export-query --alias <alias> --query '{\"modules\":{\"entries\":{\"content_type_uid\":\"blog\"}}}'",
+        "csdx cm:stacks:export-query --query '{\"modules\":{\"assets\":{\"title\":{\"$regex\":\"image\"}}}}'"
+      ],
+      "flags": {
+        "config": {
+          "char": "c",
+          "description": "Path to the configuration file",
+          "name": "config",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "stack-api-key": {
+          "char": "k",
+          "description": "Stack API key",
+          "name": "stack-api-key",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "data-dir": {
+          "char": "d",
+          "description": "Path to store exported content",
+          "name": "data-dir",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "alias": {
+          "char": "a",
+          "description": "Management token alias",
+          "name": "alias",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "branch": {
+          "description": "Branch name to export from",
+          "name": "branch",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "query": {
+          "description": "Query as JSON string or file path",
+          "name": "query",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "skip-references": {
+          "description": "Skip referenced content types",
+          "name": "skip-references",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "skip-dependencies": {
+          "description": "Skip dependent modules (global-fields, extensions, taxonomies)",
+          "name": "skip-dependencies",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "secured-assets": {
+          "description": "Export secured assets",
+          "name": "secured-assets",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "yes": {
+          "char": "y",
+          "description": "Skip confirmation prompts",
+          "name": "yes",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "cm:stacks:export-query",
+      "pluginAlias": "@contentstack/cli-cm-export-query",
+      "pluginName": "@contentstack/cli-cm-export-query",
+      "pluginType": "core",
+      "strict": true,
+      "usage": "cm:stacks:export-query --query <value> [options]",
+      "isESM": false,
+      "relativePath": [
+        "lib",
+        "commands",
+        "cm",
+        "stacks",
+        "export-query.js"
+      ]
+    }
+  },
+  "version": "1.0.0-beta.1"
+}