@celonis/content-cli 1.11.0 → 1.13.1

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'. To export a single standalone package, use 'config package export'.")
+                .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;
+});

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

@@ -13,65 +13,56 @@ 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", "form-data", "stream", "adm-zip", "./interfaces/batch-export-import.constants", "../../core/utils/file-service", "../../core/utils/logger", "../../core/utils/json", "../studio/api/package-api", "./api/batch-import-export-api", "./studio.service", "../../core/git-profile/git/git.service", "fs", "../../core/utils/file.constants"], factory);
+        define(["require", "exports", "uuid", "form-data", "stream", "adm-zip", "./batch-export-import.constants", "../../core/utils/file-service", "../../core/utils/logger", "../../core/utils/json", "../studio/api/package-api", "./api/t2tc-package-api", "../configuration-management/api/variable-api", "../configuration-management/connection-variable.helper", "./studio.service", "../../core/git-profile/git/git.service", "fs", "../../core/utils/file.constants", "node:path"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.BatchImportExportService = void 0;
+    exports.T2tcPackageService = void 0;
     const uuid_1 = require("uuid");
     const FormData = require("form-data");
     const stream_1 = require("stream");
     const AdmZip = require("adm-zip");
-    const batch_export_import_constants_1 = require("./interfaces/batch-export-import.constants");
+    const batch_export_import_constants_1 = require("./batch-export-import.constants");
     const file_service_1 = require("../../core/utils/file-service");
     const logger_1 = require("../../core/utils/logger");
     const json_1 = require("../../core/utils/json");
     const package_api_1 = require("../studio/api/package-api");
-    const batch_import_export_api_1 = require("./api/batch-import-export-api");
+    const t2tc_package_api_1 = require("./api/t2tc-package-api");
+    const variable_api_1 = require("../configuration-management/api/variable-api");
+    const connection_variable_helper_1 = require("../configuration-management/connection-variable.helper");
     const studio_service_1 = require("./studio.service");
     const git_service_1 = require("../../core/git-profile/git/git.service");
     const fs = require("fs");
     const file_constants_1 = require("../../core/utils/file.constants");
-    class BatchImportExportService {
+    const node_path_1 = require("node:path");
+    class T2tcPackageService {
         constructor(context) {
-            this.batchImportExportApi = new batch_import_export_api_1.BatchImportExportApi(context);
+            this.t2tcPackageApi = new t2tc_package_api_1.T2tcPackageApi(context);
+            this.variableApi = new variable_api_1.VariableApi(context);
             this.studioPackageApi = new package_api_1.PackageApi(context);
             this.studioService = new studio_service_1.StudioService(context);
             this.gitService = new git_service_1.GitService(context);
         }
         listActivePackages(flavors, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
-                const activePackages = yield this.batchImportExportApi.findAllActivePackages(flavors, false, includeBranches);
+                const activePackages = yield this.t2tcPackageApi.findAllActivePackages(flavors, false, includeBranches);
                 activePackages.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
             });
         }
-        listStagingPackages(flavors, includeBranches, jsonResponse) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const stagingPackages = yield this.batchImportExportApi.findAllStagingPackages(flavors, includeBranches);
-                if (jsonResponse) {
-                    this.exportListOfPackages(stagingPackages);
-                }
-                else {
-                    stagingPackages.forEach(pkg => {
-                        logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
-                    });
-                }
-            });
-        }
         findAndExportListOfPackages(flavors, packageKeys, keysByVersion, withDependencies, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
                 let packagesToExport;
                 if (keysByVersion.length) {
-                    packagesToExport = yield this.batchImportExportApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
+                    packagesToExport = yield this.t2tcPackageApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
                 }
                 else if (packageKeys.length) {
-                    packagesToExport = yield this.batchImportExportApi.findActivePackagesByKeys(packageKeys, withDependencies);
+                    packagesToExport = yield this.t2tcPackageApi.findActivePackagesByKeys(packageKeys, withDependencies);
                 }
                 else {
-                    packagesToExport = yield this.batchImportExportApi.findAllActivePackages(flavors, withDependencies, includeBranches);
+                    packagesToExport = yield this.t2tcPackageApi.findAllActivePackages(flavors, withDependencies, includeBranches);
                 }
                 packagesToExport = yield this.studioService.getExportPackagesWithStudioData(packagesToExport, withDependencies);
                 this.exportListOfPackages(packagesToExport);
@@ -79,7 +70,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         listPackagesByKeysWithVersion(keysByVersion, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
-                const exportedPackages = yield this.batchImportExportApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
+                const exportedPackages = yield this.t2tcPackageApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
                 exportedPackages.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
@@ -89,16 +80,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 let exportedPackagesData;
                 if (packageKeys) {
-                    exportedPackagesData = yield this.batchImportExportApi.exportPackages(packageKeys, withDependencies);
+                    exportedPackagesData = yield this.t2tcPackageApi.exportPackages(packageKeys, withDependencies);
                 }
                 else {
-                    exportedPackagesData = yield this.batchImportExportApi.exportPackagesByVersions(packageKeysByVersion, withDependencies);
+                    exportedPackagesData = yield this.t2tcPackageApi.exportPackagesByVersions(packageKeysByVersion, withDependencies);
                 }
                 const exportedPackagesZip = new AdmZip(exportedPackagesData);
                 const manifest = (0, json_1.parse)(exportedPackagesZip.getEntry(batch_export_import_constants_1.BatchExportImportConstants.MANIFEST_FILE_NAME).getData().toString());
                 const versionsByPackageKey = this.getVersionsByPackageKey(manifest);
                 let exportedVariables = yield this.getVersionedVariablesForPackagesWithKeys(versionsByPackageKey);
-                exportedVariables = this.studioService.fixConnectionVariables(exportedVariables);
+                exportedVariables = (0, connection_variable_helper_1.fixConnectionVariables)(exportedVariables);
                 exportedPackagesZip.addFile(batch_export_import_constants_1.BatchExportImportConstants.VARIABLES_FILE_NAME, Buffer.from((0, json_1.stringify)(exportedVariables), "utf8"), "", file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS);
                 const studioPackageKeys = manifest.filter(packageManifest => packageManifest.flavor === batch_export_import_constants_1.BatchExportImportConstants.STUDIO)
                     .map(packageManifest => packageManifest.packageKey);
@@ -125,19 +116,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchExportPackagesMetadata(packageKeys, jsonResponse) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const exportedPackagesMetadata = yield this.batchImportExportApi.batchExportPackagesMetadata(packageKeys);
-                if (jsonResponse) {
-                    this.exportListOfPackagesMetadata(exportedPackagesMetadata);
-                }
-                else {
-                    exportedPackagesMetadata.forEach(pkg => {
-                        logger_1.logger.info(`${pkg.key} - Has Unpublished Changes: ${pkg.hasUnpublishedChanges}`);
-                    });
-                }
-            });
-        }
         batchImportPackages(sourcePath, overwrite, gitBranch, performValidation = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 let sourceToBeImported;
@@ -158,10 +136,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 configs = yield this.studioService.mapSpaces(configs, studioManifests);
                 const existingStudioPackages = yield this.studioPackageApi.findAllPackages();
                 const formData = this.buildBodyForImport(configs, sourceToBeImported, variablesManifests);
-                const postPackageImportData = yield this.batchImportExportApi.importPackages(formData, overwrite, performValidation);
+                const postPackageImportData = yield this.t2tcPackageApi.importPackages(formData, overwrite, performValidation);
                 yield this.studioService.processImportedPackages(configs, existingStudioPackages, studioManifests);
                 if (gitBranch) {
-                    fs.rmSync(temporaryGitFolder, { recursive: true });
+                    fs.rmSync(temporaryGitFolder, { recursive: true, force: true });
                 }
                 fs.rmSync(sourceToBeImported);
                 const reportFileName = "config_import_report_" + (0, uuid_1.v4)() + ".json";
@@ -171,14 +149,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         findAndExportListOfActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
-                let packagesToExport = yield this.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
+                let packagesToExport = yield this.t2tcPackageApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
                 packagesToExport = yield this.studioService.getExportPackagesWithStudioData(packagesToExport, false);
                 this.exportListOfPackages(packagesToExport);
             });
         }
         listActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
-                const packagesByVariableValue = yield this.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
+                const packagesByVariableValue = yield this.t2tcPackageApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
                 packagesByVariableValue.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
@@ -206,12 +184,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     });
                 });
             });
-            return this.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variableExportRequest);
-        }
-        exportListOfPackagesMetadata(packagesMetadata) {
-            const filename = (0, uuid_1.v4)() + ".json";
-            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(packagesMetadata), filename);
-            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+            return this.variableApi.findVariablesWithValuesByPackageKeysAndVersion(variableExportRequest);
         }
         buildBodyForImport(configs, sourcePath, variablesManifests) {
             const formData = new FormData();
@@ -257,10 +230,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             else {
                 const fileDownloadedMessage = "File downloaded successfully. New filename: ";
                 const filename = `export_${(0, uuid_1.v4)()}.zip`;
-                exportedZip.writeZip(filename, () => fs.chmodSync(filename, file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS));
+                const fullFilePath = (0, node_path_1.resolve)(process.cwd(), filename);
+                exportedZip.writeZip(fullFilePath, () => fs.chmodSync(fullFilePath, file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS));
                 logger_1.logger.info(fileDownloadedMessage + filename);
             }
         }
     }
-    exports.BatchImportExportService = BatchImportExportService;
+    exports.T2tcPackageService = T2tcPackageService;
 });

package/commands/view/module.js

@@ -0,0 +1,54 @@
+/**
+ * Commands related to the View feature.
+ */
+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", "./view-bookmarks-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const view_bookmarks_command_service_1 = require("./view-bookmarks-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const pullCommand = configurator.command("pull");
+            pullCommand
+                .command("view-bookmarks")
+                .description("Command to pull view bookmarks")
+                .option("--type <type>", "Type of view bookmarks to pull: USER (default), SHARED, or ALL")
+                .requiredOption("--id <id>", "ID of the view (board) to pull bookmarks from")
+                .action(this.pullViewBookmarks);
+            const pushCommand = configurator.command("push");
+            pushCommand
+                .command("view-bookmarks")
+                .description("Command to push view bookmarks to a board")
+                .requiredOption("--id <id>", "ID of the view (board) to push bookmarks into")
+                .requiredOption("-f, --file <file>", "The file to push")
+                .action(this.pushViewBookmarks);
+        }
+        pullViewBookmarks(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new view_bookmarks_command_service_1.ViewBookmarksCommandService(context).pullViewBookmarks(options.id, options.type);
+            });
+        }
+        pushViewBookmarks(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new view_bookmarks_command_service_1.ViewBookmarksCommandService(context).pushViewBookmarks(options.id, options.file);
+            });
+        }
+    }
+    return Module;
+});

package/commands/view/view-bookmarks-command.service.js

@@ -0,0 +1,45 @@
+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", "./view-bookmarks.manager-factory", "../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ViewBookmarksCommandService = void 0;
+    const view_bookmarks_manager_factory_1 = require("./view-bookmarks.manager-factory");
+    const logger_1 = require("../../core/utils/logger");
+    const ALLOWED_VIEW_BOOKMARK_TYPES = ["USER", "SHARED", "ALL"];
+    class ViewBookmarksCommandService {
+        constructor(context) {
+            this.viewBookmarksManagerFactory = new view_bookmarks_manager_factory_1.ViewBookmarksManagerFactory(context);
+        }
+        pullViewBookmarks(boardId, type) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (type !== undefined && !ALLOWED_VIEW_BOOKMARK_TYPES.includes(type.toUpperCase())) {
+                    logger_1.logger.error(new logger_1.FatalError(`Invalid type "${type}". Allowed values are: ${ALLOWED_VIEW_BOOKMARK_TYPES.join(", ")}.`));
+                    return;
+                }
+                yield this.viewBookmarksManagerFactory.createViewBookmarksManager(null, boardId, type).pull();
+            });
+        }
+        pushViewBookmarks(boardId, filename) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.viewBookmarksManagerFactory.createViewBookmarksManager(filename, boardId).push();
+            });
+        }
+    }
+    exports.ViewBookmarksCommandService = ViewBookmarksCommandService;
+});