@celonis/content-cli 1.1.3 → 1.2.1

package/commands/deployment/deployment-api.js

@@ -0,0 +1,123 @@
+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", "./deployment.interfaces", "../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DeploymentApi = void 0;
+    const deployment_interfaces_1 = require("./deployment.interfaces");
+    const logger_1 = require("../../core/utils/logger");
+    class DeploymentApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        createDeployment(request) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient()
+                    .post("/pacman/api/deployments", request)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem creating deployment: ${e}`);
+                });
+            });
+        }
+        getDeployments(filter, limit, offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                this.addPaginationParams(queryParams, limit, offset);
+                if (filter.packageKey) {
+                    queryParams.set("packageKey", filter.packageKey);
+                }
+                if (filter.targetId) {
+                    queryParams.set("targetId", filter.targetId);
+                }
+                if (filter.deployableType) {
+                    queryParams.set("deployableType", filter.deployableType);
+                }
+                if (filter.status && filter.status !== deployment_interfaces_1.DeploymentStatus.UNKNOWN) {
+                    queryParams.set("status", filter.status);
+                }
+                if (filter.createdBy) {
+                    queryParams.set("createdBy", filter.createdBy);
+                }
+                return this.httpClient()
+                    .get(`/pacman/api/deployments/history?${queryParams.toString()}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem getting deployments: ${e}`);
+                });
+            });
+        }
+        getActiveDeploymentsForPackage(packageKey, targetIds, limit, offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                this.addPaginationParams(queryParams, limit, offset);
+                if (targetIds && targetIds.length > 0) {
+                    queryParams.set("targetIds", targetIds.join(","));
+                }
+                return this.httpClient()
+                    .get(`/pacman/api/deployments/packages/${packageKey}/active?${queryParams.toString()}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem getting active deployments for package ${packageKey}: ${e}`);
+                });
+            });
+        }
+        getActiveDeploymentForTarget(targetId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient()
+                    .get(`/pacman/api/deployments/targets/${targetId}/active`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem getting active deployment for target ${targetId}: ${e}`);
+                });
+            });
+        }
+        getTargets(deployableType, packageKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("deployableType", deployableType);
+                if (packageKey) {
+                    queryParams.set("packageKey", packageKey);
+                }
+                return this.httpClient()
+                    .get(`/pacman/api/deployments/targets?${queryParams.toString()}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem getting targets: ${e}`);
+                });
+            });
+        }
+        getDeployables(flavor) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                if (flavor) {
+                    queryParams.set("flavor", flavor);
+                }
+                return this.httpClient()
+                    .get(`/pacman/api/deployments/deployables?${queryParams.toString()}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem getting deployables: ${e}`);
+                });
+            });
+        }
+        addPaginationParams(queryParams, limit, offset) {
+            const defaultLimit = 100;
+            const defaultOffset = 0;
+            const parsedLimit = limit !== undefined && !isNaN(Number(limit)) ? Number(limit) : defaultLimit;
+            queryParams.set("limit", parsedLimit.toString());
+            const parsedOffset = offset !== undefined && !isNaN(Number(offset)) ? Number(offset) : defaultOffset;
+            queryParams.set("offset", parsedOffset.toString());
+        }
+    }
+    exports.DeploymentApi = DeploymentApi;
+});

package/commands/deployment/deployment.interfaces.js

@@ -0,0 +1,27 @@
+(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.fromString = exports.DeploymentStatus = void 0;
+    var DeploymentStatus;
+    (function (DeploymentStatus) {
+        DeploymentStatus["UNKNOWN"] = "unknown";
+        DeploymentStatus["PENDING"] = "PENDING";
+        DeploymentStatus["IN_PROGRESS"] = "IN_PROGRESS";
+        DeploymentStatus["SUCCESS"] = "SUCCESS";
+        DeploymentStatus["FAILED"] = "FAILED";
+    })(DeploymentStatus || (exports.DeploymentStatus = DeploymentStatus = {}));
+    function fromString(value) {
+        return Object.values(DeploymentStatus).includes(value)
+            ? value
+            : DeploymentStatus.UNKNOWN;
+    }
+    exports.fromString = fromString;
+});

package/commands/deployment/deployment.service.js

@@ -0,0 +1,132 @@
+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", "./deployment-api", "./deployment.interfaces", "../../core/utils/file-service", "../../core/utils/logger", "uuid"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DeploymentService = void 0;
+    const deployment_api_1 = require("./deployment-api");
+    const deployment_interfaces_1 = require("./deployment.interfaces");
+    const file_service_1 = require("../../core/utils/file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const uuid_1 = require("uuid");
+    class DeploymentService {
+        constructor(context) {
+            this.deploymentApi = new deployment_api_1.DeploymentApi(context);
+        }
+        createDeployment(packageKey, packageVersion, deployableType, targetId, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const request = {
+                    packageKey,
+                    packageVersion,
+                    deployableType,
+                    targetId
+                };
+                const deployment = yield this.deploymentApi.createDeployment(request);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(deployment), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    logger_1.logger.info(`Deployment created with ID: ${deployment.id}, Status: ${deployment.status}`);
+                }
+            });
+        }
+        getDeployments(jsonResponse, packageKey, targetId, deployableType, status, createdBy, limit, offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const filter = {
+                    packageKey,
+                    targetId,
+                    deployableType,
+                    status: (0, deployment_interfaces_1.fromString)(status),
+                    createdBy
+                };
+                const deployments = yield this.deploymentApi.getDeployments(filter, limit, offset);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(deployments), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    deployments.forEach(deployment => {
+                        logger_1.logger.info(`ID: ${deployment.id}, Package: ${deployment.packageKey}, Version: ${deployment.packageVersion}, Status: ${deployment.status}, Created at: ${new Date(deployment.createdAt).toISOString()}`);
+                    });
+                }
+            });
+        }
+        getActiveDeploymentForTarget(targetId, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const deployment = yield this.deploymentApi.getActiveDeploymentForTarget(targetId);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(deployment), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    logger_1.logger.info(`ID: ${deployment.id}, Package: ${deployment.packageKey}, Version: ${deployment.packageVersion}, Status: ${deployment.status}, Deployed at: ${new Date(deployment.deployedAt).toISOString()}`);
+                }
+            });
+        }
+        getActiveDeploymentsForPackage(packageKey, jsonResponse, targetIds, limit, offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const deployments = yield this.deploymentApi.getActiveDeploymentsForPackage(packageKey, targetIds, limit, offset);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(deployments), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    deployments.forEach(deployment => {
+                        logger_1.logger.info(`ID: ${deployment.id}, Package: ${deployment.packageKey}, Version: ${deployment.packageVersion}, Status: ${deployment.status}, Deployed at: ${new Date(deployment.deployedAt).toISOString()}`);
+                    });
+                }
+            });
+        }
+        getTargets(jsonResponse, deployableType, packageKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const targets = yield this.deploymentApi.getTargets(deployableType, packageKey);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(targets), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    targets.forEach(target => {
+                        logger_1.logger.info(`ID: ${target.id}, Name: ${target.name}`);
+                    });
+                }
+            });
+        }
+        getDeployables(jsonResponse, flavor) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const deployables = yield this.deploymentApi.getDeployables(flavor);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(deployables), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    deployables.forEach(deployable => {
+                        logger_1.logger.info(`Name: ${deployable.name}, Type: ${deployable.type}`);
+                    });
+                }
+            });
+        }
+    }
+    exports.DeploymentService = DeploymentService;
+});

package/commands/deployment/module.js

@@ -0,0 +1,113 @@
+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", "./deployment.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const deployment_service_1 = require("./deployment.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const deploymentCommand = configurator.command("deployment").beta();
+            deploymentCommand.command("create")
+                .beta()
+                .description("Create a new deployment")
+                .requiredOption("--packageKey <packageKey>", "Identifier of the package to deploy")
+                .requiredOption("--packageVersion <packageVersion>", "Version of the package to deploy")
+                .requiredOption("--deployableType <deployableType>", "The type of the deployable")
+                .requiredOption("--targetId <targetId>", "Identifier of the target to deploy to")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.createDeployment);
+            const listCommand = deploymentCommand.command("list").beta();
+            listCommand.command("history")
+                .beta()
+                .description("List deployment history")
+                .option("--packageKey <packageKey>", "Filter deployment history by package key")
+                .option("--targetId <targetId>", "Filter deployment history by target ID")
+                .option("--deployableType <deployableType>", "Filter deployment history by deployable type")
+                .option("--status <status>", "Filter deployment history by status")
+                .option("--createdBy <createdBy>", "Filter deployment history by creator")
+                .option("--limit <limit>", "Limit the number of results returned")
+                .option("--offset <offset>", "Offset for pagination")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.listDeploymentHistory);
+            listCommand.command("active")
+                .beta()
+                .description("Get the active deployment(s) for a given target or package.\n" +
+                "You can use the command to list the active deployment(s) for a specific target or for a specific package.\n" +
+                "The targetIds filter is available only for getting the active deployments for a given package. \n" +
+                "Listing active deployments for a package returns paginated results. Use the limit and offset parameters to navigate through the results.")
+                .option("--packageKey <packageKey>", "Identifier of the package to get the active deployment for")
+                .option("--targetId <targetId>", "Identifier of the target to get the active deployment for")
+                .option("--targetIds <targetIds>", "Comma-separated list of target IDs to get the active deployments for (only with packageKey)")
+                .option("--limit <limit>", "Limit the number of results returned")
+                .option("--offset <offset>", "Offset for pagination")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.listActiveDeployments);
+            listCommand.command("deployables")
+                .beta()
+                .description("List all deployables")
+                .option("--flavor <flavor>", "Filter deployables by flavor")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.listDeployables);
+            listCommand.command("targets")
+                .beta()
+                .description("List all targets for a given deployable type and package key")
+                .requiredOption("--deployableType <deployableType>", "The type of the deployable")
+                .option("--packageKey <packageKey>", "Identifier of the package to list targets for")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.listTargets);
+        }
+        createDeployment(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new deployment_service_1.DeploymentService(context).createDeployment(options.packageKey, options.packageVersion, options.deployableType, options.targetId, options.json);
+            });
+        }
+        listDeploymentHistory(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new deployment_service_1.DeploymentService(context).getDeployments(options.json, options.packageKey, options.targetId, options.deployableType, options.status, options.createdBy, options.limit, options.offset);
+            });
+        }
+        listActiveDeployments(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (options.packageKey && options.targetId) {
+                    throw new Error("Please provide either --packageKey or --targetId, not both.");
+                }
+                if (options.packageKey) {
+                    const targetIds = options.targetIds ? options.targetIds.split(",") : [];
+                    yield new deployment_service_1.DeploymentService(context).getActiveDeploymentsForPackage(options.packageKey, options.json, targetIds, options.limit, options.offset);
+                }
+                else if (options.targetId) {
+                    yield new deployment_service_1.DeploymentService(context).getActiveDeploymentForTarget(options.targetId, options.json);
+                }
+                else {
+                    throw new Error("Either --packageKey or --targetId must be provided.");
+                }
+            });
+        }
+        listDeployables(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new deployment_service_1.DeploymentService(context).getDeployables(options.json, options.flavor);
+            });
+        }
+        listTargets(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new deployment_service_1.DeploymentService(context).getTargets(options.json, options.deployableType, options.packageKey);
+            });
+        }
+    }
+    return Module;
+});

package/lib/commands/deployment/deployment-api.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "../../core/command/cli-context";
+import { CreateDeploymentRequest, DeployableTransport, DeploymentTransport, GetDeploymentsRequest, TargetTransport } from "./deployment.interfaces";
+export declare class DeploymentApi {
+    private httpClient;
+    constructor(context: Context);
+    createDeployment(request: CreateDeploymentRequest): Promise<DeploymentTransport>;
+    getDeployments(filter: GetDeploymentsRequest, limit?: string, offset?: string): Promise<DeploymentTransport[]>;
+    getActiveDeploymentsForPackage(packageKey: string, targetIds?: string[], limit?: string, offset?: string): Promise<DeploymentTransport[]>;
+    getActiveDeploymentForTarget(targetId: string): Promise<DeploymentTransport>;
+    getTargets(deployableType: string, packageKey?: string): Promise<TargetTransport[]>;
+    getDeployables(flavor?: string): Promise<DeployableTransport[]>;
+    private addPaginationParams;
+}

package/lib/commands/deployment/deployment.interfaces.d.ts

@@ -0,0 +1,43 @@
+export interface DeploymentTransport {
+    id: string;
+    packageKey: string;
+    packageVersion: string;
+    deployableType: string;
+    target: TargetTransport;
+    status: DeploymentStatus;
+    statusMessage: string;
+    createdBy: string;
+    createdAt: string;
+    deployedAt: string;
+}
+export interface TargetTransport {
+    id: string;
+    name: string;
+}
+export interface DeployableTransport {
+    name: string;
+    type: string;
+    targetType: string;
+    flavor: string;
+}
+export declare enum DeploymentStatus {
+    UNKNOWN = "unknown",
+    PENDING = "PENDING",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED"
+}
+export interface CreateDeploymentRequest {
+    packageKey: string;
+    packageVersion: string;
+    deployableType: string;
+    targetId: string;
+}
+export interface GetDeploymentsRequest {
+    packageKey: string;
+    targetId: string;
+    deployableType: string;
+    status: DeploymentStatus;
+    createdBy: string;
+}
+export declare function fromString(value: string): DeploymentStatus;

package/lib/commands/deployment/deployment.service.d.ts

@@ -0,0 +1,11 @@
+import { Context } from "../../core/command/cli-context";
+export declare class DeploymentService {
+    private deploymentApi;
+    constructor(context: Context);
+    createDeployment(packageKey: string, packageVersion: string, deployableType: string, targetId: string, jsonResponse: boolean): Promise<void>;
+    getDeployments(jsonResponse: boolean, packageKey?: string, targetId?: string, deployableType?: string, status?: string, createdBy?: string, limit?: string, offset?: string): Promise<void>;
+    getActiveDeploymentForTarget(targetId: string, jsonResponse: boolean): Promise<void>;
+    getActiveDeploymentsForPackage(packageKey: string, jsonResponse: boolean, targetIds?: string[], limit?: string, offset?: string): Promise<void>;
+    getTargets(jsonResponse: boolean, deployableType: string, packageKey?: string): Promise<void>;
+    getDeployables(jsonResponse: boolean, flavor?: string): Promise<void>;
+}

package/lib/commands/deployment/module.d.ts

@@ -0,0 +1,11 @@
+import { Configurator, IModule } from "../../core/command/module-handler";
+import { Context } from "../../core/command/cli-context";
+declare class Module extends IModule {
+    register(context: Context, configurator: Configurator): void;
+    private createDeployment;
+    private listDeploymentHistory;
+    private listActiveDeployments;
+    private listDeployables;
+    private listTargets;
+}
+export = Module;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "description": "CLI Tool to help manage content in Celonis Platform",
   "main": "content-cli.js",
   "bin": {
@@ -22,7 +22,7 @@
     "adm-zip": "0.5.14",
     "axios": "1.8.4",
     "commander": "13.1.0",
-    "form-data": "4.0.1",
+    "form-data": "4.0.4",
     "openid-client": "5.6.1",
     "hpagent": "1.2.0",
     "semver": "7.6.3",