@celonis/content-cli 1.10.0 → 1.12.0

package/commands/configuration-management/module.js

@@ -16,33 +16,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../../core/command/module-handler", "./config-command.service", "./variable-command.service", "./node.service", "./node-diff.service", "./node-dependency.service", "./package-version-command.service", "./package-validation.service"], factory);
+        define(["require", "exports", "../../core/command/module-handler", "./config-command.service", "./staging-package.service", "./metadata.service", "../t2tc/t2tc-command.service", "./variable-command.service", "./node.service", "./node-diff.service", "./node-dependency.service", "./package-version-command.service", "./package-validation.service", "./single-package-import.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     const module_handler_1 = require("../../core/command/module-handler");
     const config_command_service_1 = require("./config-command.service");
+    const staging_package_service_1 = require("./staging-package.service");
+    const metadata_service_1 = require("./metadata.service");
+    const t2tc_command_service_1 = require("../t2tc/t2tc-command.service");
     const variable_command_service_1 = require("./variable-command.service");
     const node_service_1 = require("./node.service");
     const node_diff_service_1 = require("./node-diff.service");
     const node_dependency_service_1 = require("./node-dependency.service");
     const package_version_command_service_1 = require("./package-version-command.service");
     const package_validation_service_1 = require("./package-validation.service");
+    const single_package_import_service_1 = require("./single-package-import.service");
     class Module extends module_handler_1.IModule {
         register(context, configurator) {
-            const configCommand = configurator.command("config");
+            const configCommand = configurator.command("config")
+                .description("Manage package configurations and their resources (package, nodes, versions, variables, metadata). Note: 'config list/export/import/diff' are deprecated — bulk Team-to-Team Copy operations have moved to the 't2tc package' group, and single-package operations live under 'config package'.");
             configCommand.command("list")
-                .description("Command to list packages")
+                .description("[Deprecated] Use 't2tc package list' instead. List packages in the target team.")
+                .deprecationNotice("'config list' is deprecated and will be removed in a future release. Use 't2tc package list' instead.")
                 .option("--json", "Return response as json type", "")
-                .option("--flavors <flavors...>", "Lists only active packages of the given flavors")
+                .option("--flavors <flavors...>", "Lists only packages of the given flavors")
                 .option("--withDependencies", "Include dependencies", "")
                 .option("--packageKeys <packageKeys...>", "Lists only active versions of given package keys")
                 .option("--keysByVersion <keysByVersion...>", "Lists packages by given key and version [packageKey.version]")
                 .option("--variableValue <variableValue>", "Variable value for filtering packages by.")
                 .option("--variableType <variableType>", "Variable type for filtering packages by.")
+                .option("--branches", "Include branches", false)
+                .option("--staging", "List staging packages instead", false)
                 .action(this.listPackages);
             configCommand.command("export")
-                .description("Command to export package configs")
+                .description("[Deprecated] Use 't2tc package export' instead. Export one or more packages into a Team-to-Team Copy archive.")
+                .deprecationNotice("'config export' is deprecated and will be removed in a future release. Use 't2tc package export' instead.")
                 .option("--packageKeys <packageKeys...>", "Keys of packages to export. Exports the latest deployed version only")
                 .option("--keysByVersion <keysByVersion...>", "Keys of packages to export by version")
                 .option("--withDependencies", "Include variables and dependencies", "")
@@ -54,12 +63,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .description("Commands related to package metadata");
             metadataCommand
                 .command("export")
-                .description("Command to show whether packages have unpublished changes")
+                .description("Show whether multiple packages have unpublished changes (bulk metadata export).")
                 .requiredOption("--packageKeys <packageKeys...>", "Keys of packages to find the metadata of")
                 .option("--json", "Return response as json type", "")
-                .action(this.batchExportPackagesMetadata);
+                .action(this.exportPackagesMetadata);
             configCommand.command("import")
-                .description("Command to import package configs")
+                .description("[Deprecated] Use 't2tc package import' (batch) or 'config package import' (single package) instead. Import packages from a Team-to-Team Copy archive.")
+                .deprecationNotice("'config import' is deprecated and will be removed in a future release. Use 't2tc package import' (batch archive) or 'config package import' (single package) instead.")
                 .option("--overwrite", "Flag to allow overwriting of packages")
                 .option("--validate", "Validate node configurations before import", false)
                 .option("--gitProfile <gitProfile>", "Git profile which you want to use for the Git operations")
@@ -67,16 +77,40 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("-f, --file <file>", "Exported packages file (relative path)")
                 .option("-d, --directory <directory>", "Exported packages directory (relative path)")
                 .action(this.batchImportPackages);
-            configCommand.command("validate")
+            const packageCommand = configCommand.command("package")
+                .description("Commands for working with a single package.");
+            packageCommand.command("import")
+                .description("Import a package from a zip file or directory. Uses the package format, which is not interchangeable with the 't2tc package export' / 't2tc package import' batch archive.")
+                .option("-f, --file <file>", "Package zip file (relative path)")
+                .option("-d, --directory <directory>", "Package directory (relative path)")
+                .option("--overwrite", "Flag to allow overwriting an existing package with the same key")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.importSinglePackage);
+            packageCommand.command("validate")
                 .description("Validate package node configurations")
                 .requiredOption("--packageKey <packageKey>", "Key of the package to validate")
-                .option("--layers <layers...>", "Validation layers to run", ["SCHEMA"])
+                .option("--layers <layers...>", "Validation layers to run. Allowed values: SCHEMA, BUSINESS, PACKAGE_SETTINGS (can be combined, e.g. --layers SCHEMA BUSINESS PACKAGE_SETTINGS). Defaults to SCHEMA.", ["SCHEMA"])
+                .option("--nodeKeys <nodeKeys...>", "Specific node keys to validate (default: all nodes)")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.validatePackage);
+            packageCommand.command("list")
+                .description("List packages in the target team. Lists staging packages by default.")
+                .option("--json", "Return response as json type", "")
+                .option("--flavors <flavors...>", "Lists only packages of the given flavors")
+                .action(this.listStagingPackages);
+            configCommand.command("validate")
+                .description("[Deprecated] Use 'config package validate' instead. Validate package node configurations.")
+                .deprecationNotice("'config validate' is deprecated and will be removed in a future release. Use 'config package validate' instead.")
+                .requiredOption("--packageKey <packageKey>", "Key of the package to validate")
+                .option("--layers <layers...>", "Validation layers to run. Allowed values: SCHEMA, BUSINESS, PACKAGE_SETTINGS (can be combined, e.g. --layers SCHEMA BUSINESS PACKAGE_SETTINGS). Defaults to SCHEMA.", ["SCHEMA"])
                 .option("--nodeKeys <nodeKeys...>", "Specific node keys to validate (default: all nodes)")
                 .option("--json", "Return the response as a JSON file")
                 .action(this.validatePackage);
             configCommand.command("diff")
-                .description("Command to diff configs of packages")
+                .description("[Deprecated] Use 't2tc package diff' instead. Diff a local Team-to-Team Copy archive against deployed or staging packages.")
+                .deprecationNotice("'config diff' is deprecated and will be removed in a future release. Use 't2tc package diff' instead.")
                 .option("--hasChanges", "Flag to return only the information if the package has changes without the actual changes")
+                .option("--baseVersion <version>", "Compare against a given version or STAGING")
                 .option("--json", "Return the response as a JSON file")
                 .requiredOption("-f, --file <file>", "Exported packages file (relative or absolute path)")
                 .action(this.diffPackages);
@@ -153,7 +187,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .requiredOption("--packageKey <packageKey>", "Identifier of the package")
                 .requiredOption("--nodeKey <nodeKey>", "Identifier of the node")
                 .requiredOption("--baseVersion <baseVersion>", "Base version of the node")
-                .requiredOption("--compareVersion <compareVersion>", "Compare version of the node")
+                .option("--compareVersion <compareVersion>", "Compare version of the node, mutually exclusive with --file (exactly one required)")
+                .option("-f, --file <file>", "Local node JSON file to diff against the base version, mutually exclusive with --compareVersion (exactly one required)")
                 .option("--json", "Return the response as a JSON file")
                 .action(this.diffNode);
             const nodeDependenciesCommand = nodesCommand.command("dependencies")
@@ -175,10 +210,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         listPackages(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
+                if (options.staging && (options.withDependencies || options.packageKeys || options.keysByVersion || options.variableValue || options.variableType)) {
+                    throw new Error("Staging parameter is not compatible with --withDependencies, --packageKeys, --keysByVersion, --variableValue, --variableType");
+                }
                 if (options.packageKeys && options.keysByVersion) {
                     throw new Error("Please provide either --packageKeys or --keysByVersion, but not both.");
                 }
-                yield new config_command_service_1.ConfigCommandService(context).listPackages(options.json, options.flavors, options.withDependencies, options.packageKeys, options.keysByVersion, options.variableValue, options.variableType);
+                yield new t2tc_command_service_1.T2tcCommandService(context).listPackages(options.json, options.flavors, options.withDependencies, options.packageKeys, options.keysByVersion, options.variableValue, options.variableType, options.branches, options.staging);
+            });
+        }
+        listStagingPackages(context, command, options) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new staging_package_service_1.StagingPackageService(context).listStagingPackages((_a = options.flavors) !== null && _a !== void 0 ? _a : [], false, options.json);
             });
         }
         batchExportPackages(context, command, options) {
@@ -191,12 +235,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     throw new Error("Please specify a branch using --gitBranch when using a Git profile.");
                 }
                 options.withDependencies = (_a = options.withDependencies) !== null && _a !== void 0 ? _a : false;
-                yield new config_command_service_1.ConfigCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies, options.gitBranch, options.unzip);
+                yield new t2tc_command_service_1.T2tcCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies, options.gitBranch, options.unzip);
             });
         }
-        batchExportPackagesMetadata(context, command, options) {
+        exportPackagesMetadata(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield new config_command_service_1.ConfigCommandService(context).batchExportPackagesMetadata(options.packageKeys, options.json);
+                yield new metadata_service_1.MetadataService(context).exportPackagesMetadata(options.packageKeys, options.json);
             });
         }
         getPackageVersion(context, command, options) {
@@ -222,12 +266,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 if (options.gitProfile && !options.gitBranch) {
                     throw new Error("Please specify a branch using --gitBranch when using a Git profile.");
                 }
-                yield new config_command_service_1.ConfigCommandService(context).batchImportPackages(options.file, options.directory, options.overwrite, options.gitBranch, options.validate);
+                yield new t2tc_command_service_1.T2tcCommandService(context).batchImportPackages(options.file, options.directory, options.overwrite, options.gitBranch, options.validate);
+            });
+        }
+        importSinglePackage(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new single_package_import_service_1.SinglePackageImportService(context).importPackage(options.file, options.directory, options.overwrite, options.json);
             });
         }
         diffPackages(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield new config_command_service_1.ConfigCommandService(context).diffPackages(options.file, options.hasChanges, options.json);
+                yield new t2tc_command_service_1.T2tcCommandService(context).diffPackages(options.file, options.hasChanges, options.baseVersion, options.json);
             });
         }
         validatePackage(context, command, options) {
@@ -281,7 +330,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         diffNode(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield new node_diff_service_1.NodeDiffService(context).diff(options.packageKey, options.nodeKey, options.baseVersion, options.compareVersion, options.json);
+                if ((options.file && options.compareVersion) || (!options.file && !options.compareVersion)) {
+                    throw new Error("Please provide either --compareVersion or --file, but not both.");
+                }
+                if (options.file) {
+                    yield new node_diff_service_1.NodeDiffService(context).diffWithFile(options.packageKey, options.nodeKey, options.baseVersion, options.file, options.json);
+                }
+                else {
+                    yield new node_diff_service_1.NodeDiffService(context).diff(options.packageKey, options.nodeKey, options.baseVersion, options.compareVersion, options.json);
+                }
             });
         }
         listNodeDependencies(context, command, options) {

package/commands/configuration-management/node-diff.service.js

@@ -13,12 +13,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "uuid", "../../core/utils/logger", "../../core/utils/file-service", "./api/node-diff-api"], factory);
+        define(["require", "exports", "node:fs", "uuid", "../../core/utils/logger", "../../core/utils/file-service", "./api/node-diff-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.NodeDiffService = void 0;
+    const fs = require("node:fs");
     const uuid_1 = require("uuid");
     const logger_1 = require("../../core/utils/logger");
     const file_service_1 = require("../../core/utils/file-service");
@@ -36,27 +37,49 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     compareVersion,
                 });
                 if (jsonResponse) {
-                    const filename = (0, uuid_1.v4)() + ".json";
-                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodeDiff, null, 2), filename);
-                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                    this.exportDiffAsJson(nodeDiff);
                 }
                 else {
-                    logger_1.logger.info(`Package Key: ${nodeDiff.packageKey}`);
-                    logger_1.logger.info(`Node Key: ${nodeDiff.nodeKey}`);
-                    logger_1.logger.info(`Name: ${nodeDiff.name}`);
-                    logger_1.logger.info(`Type: ${nodeDiff.type}`);
-                    logger_1.logger.info(`Is invalid configuration: ${nodeDiff.invalidContent}`);
-                    if (nodeDiff.parentNodeKey) {
-                        logger_1.logger.info(`Parent Node Key: ${nodeDiff.parentNodeKey}`);
-                    }
-                    logger_1.logger.info(`Change Date: ${new Date(nodeDiff.changeDate).toISOString()}`);
-                    logger_1.logger.info(`Updated By: ${nodeDiff.updatedBy}`);
-                    logger_1.logger.info(`Change Type: ${nodeDiff.changeType}`);
-                    logger_1.logger.info(`Changes: ${JSON.stringify(nodeDiff.changes)}`);
-                    logger_1.logger.info(`Metadata Changes: ${JSON.stringify(nodeDiff.metadataChanges)}`);
+                    this.logDiff(nodeDiff);
                 }
             });
         }
+        diffWithFile(packageKey, nodeKey, baseVersion, file, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const nodeDiff = yield this.nodeDiffApi.diffWithFile({
+                    packageKey,
+                    nodeKey,
+                    baseVersion,
+                    file: fs.createReadStream(file),
+                });
+                if (jsonResponse) {
+                    this.exportDiffAsJson(nodeDiff);
+                }
+                else {
+                    this.logDiff(nodeDiff);
+                }
+            });
+        }
+        exportDiffAsJson(nodeDiff) {
+            const filename = (0, uuid_1.v4)() + ".json";
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodeDiff, null, 2), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
+        logDiff(nodeDiff) {
+            logger_1.logger.info(`Package Key: ${nodeDiff.packageKey}`);
+            logger_1.logger.info(`Node Key: ${nodeDiff.nodeKey}`);
+            logger_1.logger.info(`Name: ${nodeDiff.name}`);
+            logger_1.logger.info(`Type: ${nodeDiff.type}`);
+            logger_1.logger.info(`Is invalid configuration: ${nodeDiff.invalidContent}`);
+            if (nodeDiff.parentNodeKey) {
+                logger_1.logger.info(`Parent Node Key: ${nodeDiff.parentNodeKey}`);
+            }
+            logger_1.logger.info(`Change Date: ${new Date(nodeDiff.changeDate).toISOString()}`);
+            logger_1.logger.info(`Updated By: ${nodeDiff.updatedBy}`);
+            logger_1.logger.info(`Change Type: ${nodeDiff.changeType}`);
+            logger_1.logger.info(`Changes: ${JSON.stringify(nodeDiff.changes)}`);
+            logger_1.logger.info(`Metadata Changes: ${JSON.stringify(nodeDiff.metadataChanges)}`);
+        }
     }
     exports.NodeDiffService = NodeDiffService;
 });

package/commands/configuration-management/single-package-import.service.js

@@ -0,0 +1,111 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "uuid", "form-data", "node:stream", "adm-zip", "node:fs", "../../core/utils/file-service", "../../core/utils/logger", "./api/single-package-import-api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SinglePackageImportService = void 0;
+    const uuid_1 = require("uuid");
+    const FormData = require("form-data");
+    const node_stream_1 = require("node:stream");
+    const AdmZip = require("adm-zip");
+    const fs = require("node:fs");
+    const file_service_1 = require("../../core/utils/file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const single_package_import_api_1 = require("./api/single-package-import-api");
+    class SinglePackageImportService {
+        constructor(context) {
+            this.singlePackageImportApi = new single_package_import_api_1.SinglePackageImportApi(context);
+        }
+        importPackage(file, directory, overwrite, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const resolvedSource = this.resolveSource(file, directory);
+                try {
+                    const packageZip = new AdmZip(resolvedSource.zipPath);
+                    const formData = this.buildBodyForImport(packageZip, resolvedSource.zipPath);
+                    const result = yield this.singlePackageImportApi.importPackage(formData, overwrite);
+                    this.outputResult(result, jsonResponse);
+                }
+                finally {
+                    if (resolvedSource.isTemporary) {
+                        fs.rmSync(resolvedSource.zipPath);
+                    }
+                }
+            });
+        }
+        resolveSource(file, directory) {
+            if (file && directory) {
+                throw new Error("You cannot use both --file and --directory options at the same time. Only one import source can be defined.");
+            }
+            if (!file && !directory) {
+                throw new Error("You must provide either a --file or a --directory option to import a package.");
+            }
+            if (file) {
+                if (file_service_1.fileService.isDirectory(file)) {
+                    throw new Error("The --file option accepts only zip files.");
+                }
+                return { zipPath: file, isTemporary: false };
+            }
+            if (!file_service_1.fileService.isDirectory(directory)) {
+                throw new Error("The --directory option accepts only directories.");
+            }
+            return { zipPath: file_service_1.fileService.zipDirectoryAsSinglePackage(directory), isTemporary: true };
+        }
+        buildBodyForImport(packageZip, sourcePath) {
+            this.assertUncompressedSizeWithinLimit(packageZip, sourcePath);
+            const formData = new FormData();
+            formData.append("packageFile", this.getReadableStream(packageZip), { filename: "package.zip" });
+            return formData;
+        }
+        assertUncompressedSizeWithinLimit(packageZip, sourcePath) {
+            const totalUncompressedBytes = packageZip.getEntries().reduce((sum, entry) => sum + entry.header.size, 0);
+            if (totalUncompressedBytes > SinglePackageImportService.MAX_UNCOMPRESSED_ZIP_SIZE) {
+                throw new Error(`Failed to handle zip file "${sourcePath}": uncompressed size ${(totalUncompressedBytes / (Math.pow(1024, 3))).toFixed(2)} GB exceeds the 4 GB limit.`);
+            }
+        }
+        getReadableStream(packageZip) {
+            return new node_stream_1.Readable({
+                read() {
+                    this.push(packageZip.toBuffer());
+                    this.push(null);
+                },
+            });
+        }
+        outputResult(result, jsonResponse) {
+            var _a;
+            if (jsonResponse) {
+                const filename = (0, uuid_1.v4)() + ".json";
+                file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(result, null, 2), filename);
+                logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                return;
+            }
+            const importedPackage = result.importedPackage;
+            const importedNodes = (_a = result.importedNodes) !== null && _a !== void 0 ? _a : [];
+            logger_1.logger.info(`Successfully imported package: ${importedPackage.key}`);
+            logger_1.logger.info(`Name: ${importedPackage.name}`);
+            if (importedPackage.flavor) {
+                logger_1.logger.info(`Flavor: ${importedPackage.flavor}`);
+            }
+            logger_1.logger.info(`Imported ${importedNodes.length} node(s).`);
+            importedNodes.forEach(node => {
+                logger_1.logger.info(`  - ${node.key} (${node.type})`);
+            });
+        }
+    }
+    exports.SinglePackageImportService = SinglePackageImportService;
+    SinglePackageImportService.MAX_UNCOMPRESSED_ZIP_SIZE = 4 * 1024 * 1024 * 1024;
+});

package/commands/configuration-management/staging-package.service.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "uuid", "../../core/utils/file-service", "../../core/utils/logger", "./api/staging-package-api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StagingPackageService = void 0;
+    const uuid_1 = require("uuid");
+    const file_service_1 = require("../../core/utils/file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const staging_package_api_1 = require("./api/staging-package-api");
+    class StagingPackageService {
+        constructor(context) {
+            this.stagingPackageApi = new staging_package_api_1.StagingPackageApi(context);
+        }
+        listStagingPackages(flavors, includeBranches, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const stagingPackages = yield this.stagingPackageApi.findAllStagingPackages(flavors, includeBranches);
+                if (jsonResponse) {
+                    this.exportListOfPackages(stagingPackages);
+                }
+                else {
+                    stagingPackages.forEach(pkg => {
+                        logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
+                    });
+                }
+            });
+        }
+        exportListOfPackages(packages) {
+            const filename = (0, uuid_1.v4)() + ".json";
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(packages), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
+    }
+    exports.StagingPackageService = StagingPackageService;
+});

package/commands/configuration-management/variable.service.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "uuid", "../../core/utils/logger", "./studio.service", "../../core/utils/file-service", "./api/batch-import-export-api", "url", "./api/variable-assignment-candidates-api", "./api/staging-package-variables-api"], factory);
+        define(["require", "exports", "uuid", "../../core/utils/logger", "./connection-variable.helper", "../../core/utils/file-service", "./api/variable-api", "url", "./api/variable-assignment-candidates-api", "./api/staging-package-variables-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -21,18 +21,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     exports.VariableService = void 0;
     const uuid_1 = require("uuid");
     const logger_1 = require("../../core/utils/logger");
-    const studio_service_1 = require("./studio.service");
+    const connection_variable_helper_1 = require("./connection-variable.helper");
     const file_service_1 = require("../../core/utils/file-service");
-    const batch_import_export_api_1 = require("./api/batch-import-export-api");
+    const variable_api_1 = require("./api/variable-api");
     const url_1 = require("url");
     const variable_assignment_candidates_api_1 = require("./api/variable-assignment-candidates-api");
     const staging_package_variables_api_1 = require("./api/staging-package-variables-api");
     class VariableService {
         constructor(context) {
-            this.batchImportExportApi = new batch_import_export_api_1.BatchImportExportApi(context);
+            this.variableApi = new variable_api_1.VariableApi(context);
             this.variableAssignmentCandidatesApi = new variable_assignment_candidates_api_1.VariableAssignmentCandidatesApi(context);
             this.stagingPackageVariablesApi = new staging_package_variables_api_1.StagingPackageVariablesApi(context);
-            this.studioService = new studio_service_1.StudioService(context);
         }
         listVariables(keysByVersion, keysByVersionFile) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -86,8 +85,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile) {
             return __awaiter(this, void 0, void 0, function* () {
                 const variablesExportRequest = yield this.buildKeyVersionPairs(keysByVersion, keysByVersionFile);
-                const variableManifests = yield this.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variablesExportRequest);
-                return this.studioService.fixConnectionVariables(variableManifests);
+                const variableManifests = yield this.variableApi.findVariablesWithValuesByPackageKeysAndVersion(variablesExportRequest);
+                return (0, connection_variable_helper_1.fixConnectionVariables)(variableManifests);
             });
         }
         buildKeyVersionPairs(keysByVersion, keysByVersionFile) {

package/commands/t2tc/api/diff-api.js

@@ -0,0 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiffApi = void 0;
+    class DiffApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        diffPackages(baseVersion, data) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const paramString = baseVersion ? "?" + new URLSearchParams({ "baseVersion": baseVersion }).toString() : "";
+                return this.httpClient().postFile(`/package-manager/api/core/packages/diff/configuration${paramString}`, data);
+            });
+        }
+        hasChanges(baseVersion, data) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const paramString = baseVersion ? "?" + new URLSearchParams({ "baseVersion": baseVersion }).toString() : "";
+                return this.httpClient().postFile(`/package-manager/api/core/packages/diff/configuration/has-changes${paramString}`, data);
+            });
+        }
+    }
+    exports.DiffApi = DiffApi;
+});

package/commands/{configuration-management/api/batch-import-export-api.js → t2tc/api/t2tc-package-api.js}

@@ -18,29 +18,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.BatchImportExportApi = void 0;
+    exports.T2tcPackageApi = void 0;
     const logger_1 = require("../../../core/utils/logger");
-    class BatchImportExportApi {
+    class T2tcPackageApi {
         constructor(context) {
             this.httpClient = () => context.httpClient;
         }
-        findAllActivePackages(flavors, withDependencies = false) {
+        findAllActivePackages(flavors, withDependencies = false, includeBranches = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 queryParams.set("withDependencies", withDependencies.toString());
+                queryParams.set("includeBranches", includeBranches.toString());
                 flavors.forEach(flavor => queryParams.append("flavors", flavor));
                 return this.httpClient().get(`/package-manager/api/core/packages/export/list?${queryParams.toString()}`).catch(e => {
                     throw new logger_1.FatalError(`Problem getting active packages: ${e}`);
                 });
             });
         }
-        findActivePackagesByVariableValue(flavors, variableValue, variableType) {
+        findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 queryParams.set("variableValue", variableValue);
                 if (variableType) {
                     queryParams.set("variableType", variableType);
                 }
+                queryParams.set("includeBranches", includeBranches.toString());
                 flavors.forEach(flavor => queryParams.append("flavors", flavor));
                 return this.httpClient().get(`/package-manager/api/core/packages/export/list-by-variable-value?${queryParams.toString()}`).catch(e => {
                     throw new logger_1.FatalError(`Problem getting active packages by variable value: ${e}`);
@@ -87,27 +89,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        batchExportPackagesMetadata(packageKeys) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const queryParams = new URLSearchParams();
-                packageKeys.forEach(packageKey => queryParams.append("packageKeys", packageKey));
-                return this.httpClient().get(`/package-manager/api/core/packages/metadata/export?${queryParams.toString()}`).catch(e => {
-                    throw new logger_1.FatalError(`Problem exporting packages metadata: ${e}`);
-                });
-            });
-        }
         importPackages(data, overwrite, performValidation) {
             return __awaiter(this, void 0, void 0, function* () {
                 return this.httpClient().postFile("/package-manager/api/core/packages/import/batch", data, { overwrite, performValidation });
             });
         }
-        findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this.httpClient().post("/package-manager/api/core/packages/export/batch/variables-with-assignments", packagesByKeyAndVersion).catch(e => {
-                    throw new logger_1.FatalError(`Problem exporting package variables: ${e}`);
-                });
-            });
-        }
     }
-    exports.BatchImportExportApi = BatchImportExportApi;
+    exports.T2tcPackageApi = T2tcPackageApi;
 });

package/commands/{configuration-management → t2tc}/diff.service.js

@@ -30,21 +30,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         constructor(context) {
             this.diffApi = new diff_api_1.DiffApi(context);
         }
-        diffPackages(file, hasChanges, jsonResponse) {
+        diffPackages(file, hasChanges, baseVersion, jsonResponse) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (hasChanges) {
-                    yield this.hasChanges(file, jsonResponse);
+                    yield this.hasChanges(baseVersion, file, jsonResponse);
                 }
                 else {
-                    yield this.diffPackagesAndReturnDiff(file, jsonResponse);
+                    yield this.diffPackagesAndReturnDiff(baseVersion, file, jsonResponse);
                 }
             });
         }
-        hasChanges(file, jsonResponse) {
+        hasChanges(baseVersion, file, jsonResponse) {
             return __awaiter(this, void 0, void 0, function* () {
                 const packages = new AdmZip(file);
                 const formData = this.buildBodyForDiff(packages);
-                const returnedHasChangesData = yield this.diffApi.hasChanges(formData);
+                const returnedHasChangesData = yield this.diffApi.hasChanges(baseVersion, formData);
                 if (jsonResponse) {
                     this.exportListOfPackageDiffMetadata(returnedHasChangesData);
                 }
@@ -53,11 +53,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        diffPackagesAndReturnDiff(file, jsonResponse) {
+        diffPackagesAndReturnDiff(baseVersion, file, jsonResponse) {
             return __awaiter(this, void 0, void 0, function* () {
                 const packages = new AdmZip(file);
                 const formData = this.buildBodyForDiff(packages);
-                const returnedHasChangesData = yield this.diffApi.diffPackages(formData);
+                const returnedHasChangesData = yield this.diffApi.diffPackages(baseVersion, formData);
                 if (jsonResponse) {
                     this.exportListOfPackageDiffs(returnedHasChangesData);
                 }