@celonis/content-cli 1.11.0 → 1.12.0

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,9 +18,9 @@ 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;
         }
@@ -35,16 +35,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        findAllStagingPackages(flavors, includeBranches = false) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const queryParams = new URLSearchParams();
-                queryParams.set("includeBranches", includeBranches.toString());
-                flavors.forEach(flavor => queryParams.append("flavors", flavor));
-                return this.httpClient().get(`/pacman/api/core/staging/packages/export/list?${queryParams.toString()}`).catch(e => {
-                    throw new logger_1.FatalError(`Problem getting staging packages: ${e}`);
-                });
-            });
-        }
         findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
@@ -99,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);
                 }

package/commands/t2tc/module.js

@@ -0,0 +1,105 @@
+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", "../../core/command/module-handler", "./t2tc-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const t2tc_command_service_1 = require("./t2tc-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const t2tcCommand = configurator.command("t2tc")
+                .description("Team-to-Team Copy (T2TC) commands for moving whole packages and their dependencies between teams using the batch transport archive format.");
+            const t2tcPackageCommand = t2tcCommand.command("package")
+                .description("Team-to-Team Copy package commands: list, export, import and diff packages using the batch transport archive.");
+            t2tcPackageCommand.command("list")
+                .description("List packages in the target team. Part of the Team-to-Team Copy export/import workflow.")
+                .option("--json", "Return response as json type", "")
+                .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);
+            t2tcPackageCommand.command("export")
+                .description("Export one or more packages into a Team-to-Team Copy archive. The archive is consumed by 't2tc package import' / 't2tc package diff'.")
+                .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", "")
+                .option("--unzip", "Unzip the exported file", "")
+                .option("--gitProfile <gitProfile>", "Git profile which you want to use for the Git operations")
+                .option("--gitBranch <gitBranch>", "Git branch in which you want to push the exported file")
+                .action(this.batchExportPackages);
+            t2tcPackageCommand.command("import")
+                .description("Import packages from a Team-to-Team Copy archive produced by 't2tc package export'. To import a single standalone package, use 'config package import'.")
+                .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")
+                .option("--gitBranch <gitBranch>", "Git branch from which you want to pull the exported file and import")
+                .option("-f, --file <file>", "Exported packages file (relative path)")
+                .option("-d, --directory <directory>", "Exported packages directory (relative path)")
+                .action(this.batchImportPackages);
+            t2tcPackageCommand.command("diff")
+                .description("Diff a local Team-to-Team Copy archive (from 't2tc package export') against deployed or staging packages.")
+                .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);
+        }
+        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 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);
+            });
+        }
+        batchExportPackages(context, command, options) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if ((options.packageKeys && options.keysByVersion) || (!options.packageKeys && !options.keysByVersion)) {
+                    throw new Error("Please provide either --packageKeys or --keysByVersion, but not both.");
+                }
+                if (options.gitProfile && !options.gitBranch) {
+                    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 t2tc_command_service_1.T2tcCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies, options.gitBranch, options.unzip);
+            });
+        }
+        batchImportPackages(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (options.gitProfile && !options.gitBranch) {
+                    throw new Error("Please specify a branch using --gitBranch when using a Git profile.");
+                }
+                yield new t2tc_command_service_1.T2tcCommandService(context).batchImportPackages(options.file, options.directory, options.overwrite, options.gitBranch, options.validate);
+            });
+        }
+        diffPackages(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new t2tc_command_service_1.T2tcCommandService(context).diffPackages(options.file, options.hasChanges, options.baseVersion, options.json);
+            });
+        }
+    }
+    return Module;
+});

package/commands/{configuration-management → t2tc}/studio.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", "adm-zip", "../studio/interfaces/package-manager.interfaces", "./interfaces/batch-export-import.constants", "../../core/utils/json", "../studio/api/package-api", "../studio/service/data-model.service", "../studio/api/node-api", "../studio/api/space-api", "../studio/api/studio-variables-api", "../studio/service/space.service", "../studio/service/studio-variable.service", "../../core/utils/branches"], factory);
+        define(["require", "exports", "adm-zip", "../studio/interfaces/package-manager.interfaces", "./batch-export-import.constants", "../../core/utils/json", "../studio/api/package-api", "../studio/service/data-model.service", "../studio/api/node-api", "../studio/api/space-api", "../studio/api/studio-variables-api", "../studio/service/space.service", "../studio/service/studio-variable.service", "../../core/utils/branches"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -21,7 +21,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     exports.StudioService = void 0;
     const AdmZip = require("adm-zip");
     const package_manager_interfaces_1 = require("../studio/interfaces/package-manager.interfaces");
-    const batch_export_import_constants_1 = require("./interfaces/batch-export-import.constants");
+    const batch_export_import_constants_1 = require("./batch-export-import.constants");
     const json_1 = require("../../core/utils/json");
     const package_api_1 = require("../studio/api/package-api");
     const data_model_service_1 = require("../studio/service/data-model.service");
@@ -52,14 +52,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 return packagesToExport;
             });
         }
-        fixConnectionVariables(variables) {
-            return variables.map(variableManifest => (Object.assign(Object.assign({}, variableManifest), { variables: variableManifest.variables.map(variable => {
-                    if (variable.type !== package_manager_interfaces_1.PackageManagerVariableType.CONNECTION) {
-                        return variable;
-                    }
-                    return this.fixConnectionVariable(variable);
-                }) })));
-        }
         getStudioPackageManifests(studioPackageKeys) {
             return __awaiter(this, void 0, void 0, function* () {
                 return Promise.all(studioPackageKeys.map((packageKey) => __awaiter(this, void 0, void 0, function* () {
@@ -116,13 +108,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     })) }) : pkg;
             });
         }
-        fixConnectionVariable(variable) {
-            var _a;
-            if (!((_a = variable.value) === null || _a === void 0 ? void 0 : _a.appName)) {
-                return variable;
-            }
-            return Object.assign(Object.assign({}, variable), { metadata: Object.assign(Object.assign({}, variable.metadata), { appName: variable.value.appName }) });
-        }
         deleteScenarioAssets(packageZip) {
             packageZip.getEntries().filter(entry => entry.entryName.startsWith(batch_export_import_constants_1.BatchExportImportConstants.NODES_FOLDER_NAME) && entry.entryName.endsWith(batch_export_import_constants_1.BatchExportImportConstants.JSON_EXTENSION))
                 .forEach(entry => {

package/commands/t2tc/t2tc-command.service.js

@@ -0,0 +1,88 @@
+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", "../../core/utils/file-service", "./t2tc-package.service", "./diff.service", "../configuration-management/staging-package.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.T2tcCommandService = void 0;
+    const file_service_1 = require("../../core/utils/file-service");
+    const t2tc_package_service_1 = require("./t2tc-package.service");
+    const diff_service_1 = require("./diff.service");
+    const staging_package_service_1 = require("../configuration-management/staging-package.service");
+    class T2tcCommandService {
+        constructor(context) {
+            this.t2tcPackageService = new t2tc_package_service_1.T2tcPackageService(context);
+            this.diffService = new diff_service_1.DiffService(context);
+            this.stagingPackageService = new staging_package_service_1.StagingPackageService(context);
+        }
+        listPackages(jsonResponse, flavors, withDependencies, packageKeys, keysByVersion, variableValue, variableType, includeBranches, staging) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (staging) {
+                    yield this.stagingPackageService.listStagingPackages(flavors !== null && flavors !== void 0 ? flavors : [], includeBranches, jsonResponse);
+                }
+                else if (variableValue) {
+                    yield this.listPackagesByVariableValue(jsonResponse, flavors, variableValue, variableType, includeBranches);
+                }
+                else if (jsonResponse) {
+                    yield this.t2tcPackageService.findAndExportListOfPackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], keysByVersion !== null && keysByVersion !== void 0 ? keysByVersion : [], withDependencies, includeBranches);
+                }
+                else if (keysByVersion) {
+                    yield this.t2tcPackageService.listPackagesByKeysWithVersion(keysByVersion, withDependencies);
+                }
+                else {
+                    yield this.t2tcPackageService.listActivePackages(flavors !== null && flavors !== void 0 ? flavors : [], includeBranches);
+                }
+            });
+        }
+        batchExportPackages(packageKeys, packageKeysByVersion, withDependencies, gitBranch, unzip) {
+            return this.t2tcPackageService.batchExportPackages(packageKeys, packageKeysByVersion, withDependencies, gitBranch, unzip);
+        }
+        batchImportPackages(file, directory, overwrite, gitBranch, performValidation = false) {
+            if ((directory || file) && gitBranch) {
+                throw new Error("You cannot use both file/directory and gitBranch options at the same time. Only one import source can be defined.");
+            }
+            if (!directory && !file && !gitBranch) {
+                throw new Error("You must provide either a file/directory or a gitBranch option to import packages.");
+            }
+            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 && file_service_1.fileService.isDirectory(file)) {
+                throw new Error("The file option accepts only zip files.");
+            }
+            if (directory && !file_service_1.fileService.isDirectory(directory)) {
+                throw new Error("The directory option accepts only directories.");
+            }
+            const sourcePath = file !== null && file !== void 0 ? file : directory;
+            return this.t2tcPackageService.batchImportPackages(sourcePath, overwrite, gitBranch, performValidation);
+        }
+        diffPackages(file, hasChanges, baseVersion, jsonResponse) {
+            return this.diffService.diffPackages(file, hasChanges, baseVersion, jsonResponse);
+        }
+        listPackagesByVariableValue(jsonResponse, flavors, variableValue, variableType, includeBranches) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (jsonResponse) {
+                    yield this.t2tcPackageService.findAndExportListOfActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType, includeBranches);
+                }
+                else {
+                    yield this.t2tcPackageService.listActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType, includeBranches);
+                }
+            });
+        }
+    }
+    exports.T2tcCommandService = T2tcCommandService;
+});