TA-4551: Add command for fetching Package version metadata

DOCUMENTATION.md

@@ -27,6 +27,8 @@
         - [Listing package variables](#listing-package-variables)
         - [Listing assignments](#listing-assignments)
         - [Mapping variables](#mapping-variables)
+    - [Package Version](#package-version)
+        - [Get package version](#get-package-version)
     - [Finding nodes](#finding-nodes)
         - [Find a staging node](#find-a-staging-node)
         - [Find a staging node with configuration](#find-a-staging-node-with-configuration)
@@ -674,6 +676,48 @@ This mapping should be saved and then used during import.
 Since the format of the variables.json file on import is the same JSON structure as the list variables result, you can either map the values to the variables.json file for each variable, or replace the variables.json file with the result of the listing & mapping altogether.
 If the mapping of variables is skipped, you should delete the variables.json file before importing.
 
+### Package Version
+
+The **config versions** command group allows you to retrieve metadata information about specific package versions.
+
+#### Get package version
+
+To get metadata for a specific package version, use the following command:
+```
+content-cli config versions get --packageKey <packageKey> --packageVersion <packageVersion>
+```
+
+For example, to get metadata for version 1.2.3 of a package:
+```
+content-cli config versions get --packageKey my-package --packageVersion 1.2.3
+```
+
+The command will display the version metadata in the console:
+```
+info:    Package Key: my-package-key
+info:    Version: 1.2.3
+info:    History ID: history-id
+info:    Change Date: 2024-01-15T10:30:00.000Z
+info:    Publish Date: 2024-01-15T11:00:00.000Z
+info:    Publish Message: Initial release version
+info:    Deployed: true
+info:    Published By: [email protected]
+```
+
+##### Export version metadata as JSON
+
+To export the version metadata as a JSON file instead of displaying it in the console, use the `--json` option:
+```
+content-cli config versions get --packageKey <packageKey> --packageVersion <packageVersion> --json
+```
+
+This will create a JSON file in the current working directory with a UUID filename:
+```
+info:    File downloaded successfully. New filename: 9560f81f-f746-4117-83ee-dd1f614ad624.json
+```
+
+The JSON file contains the complete version metadata including all fields in a structured format that can be used for automation or further processing.
+
 #### Finding nodes
 
 The **config nodes find** command allows you to retrieve information about a specific node within a package.

src/commands/configuration-management/api/package-version-api.ts

@@ -0,0 +1,21 @@
+import { HttpClient } from "../../../core/http/http-client";
+import { Context } from "../../../core/command/cli-context";
+import { FatalError } from "../../../core/utils/logger";
+import { PackageVersionTransport } from "../interfaces/package-version.interfaces";
+
+export class PackageVersionApi {
+    private httpClient: () => HttpClient;
+
+    constructor(context: Context) {
+        this.httpClient = () => context.httpClient;
+    }
+
+    public async findOne(packageKey: string, version: string): Promise<PackageVersionTransport> {
+        return this.httpClient()
+            .get(`/pacman/api/core/packages/${packageKey}/versions/${version}`)
+            .catch(e => {
+                throw new FatalError(`Problem finding Package with key '${packageKey}' and version '${version}': ${e}`);
+            });
+    }
+}
+

src/commands/configuration-management/interfaces/package-version.interfaces.ts

@@ -0,0 +1,10 @@
+export interface PackageVersionTransport {
+    packageKey: string;
+    historyId: string;
+    version: string;
+    changeDate: string;
+    publishDate: string;
+    publishMessage: string;
+    deployed: boolean;
+    publishedBy: string;
+}

src/commands/configuration-management/module.ts

@@ -10,6 +10,7 @@ import { VariableCommandService } from "./variable-command.service";
 import { NodeService } from "./node.service";
 import { NodeDiffService } from "./node-diff.service";
 import { NodeDependencyService } from "./node-dependency.service";
+import { PackageVersionCommandService } from "./package-version-command.service";
 
 class Module extends IModule {
 
@@ -61,6 +62,16 @@ class Module extends IModule {
             .requiredOption("-f, --file <file>", "Exported packages file (relative or absolute path)")
             .action(this.diffPackages);
 
+        const configVersionCommand = configCommand.command("versions")
+            .description("Commands related to Package version metadata");
+
+        configVersionCommand.command("get")
+            .description("Get version metadata for a specific package version")
+            .requiredOption("--packageKey <packageKey>", "Identifier of the package")
+            .requiredOption("--packageVersion <packageVersion>", "Version of the package")
+            .option("--json", "Return the response as a JSON file")
+            .action(this.getPackageVersion)
+
         const variablesCommand = configCommand.command("variables")
             .description("Commands related to variable configs");
 
@@ -141,6 +152,10 @@ class Module extends IModule {
         await new ConfigCommandService(context).batchExportPackagesMetadata(options.packageKeys, options.json);
     }
 
+    private async getPackageVersion(context: Context, command: Command, options: OptionValues): Promise<void> {
+        await new PackageVersionCommandService(context).getPackageVersion(options.packageKey, options.packageVersion, options.json);
+    }
+
     private async batchImportPackages(context: Context, command: Command, options: OptionValues): Promise<void> {
         if (options.gitProfile && !options.gitBranch) {
             throw new Error("Please specify a branch using --gitBranch when using a Git profile.");

src/commands/configuration-management/package-version-command.service.ts

@@ -0,0 +1,15 @@
+import { Context } from "../../core/command/cli-context";
+import { PackageVersionService } from "./package-version.service";
+
+export class PackageVersionCommandService {
+
+    private packageVersionService: PackageVersionService;
+
+    constructor(context: Context) {
+        this.packageVersionService = new PackageVersionService(context);
+    }
+
+    public async getPackageVersion(packageKey: string, version: string, jsonResponse: boolean): Promise<void> {
+        await this.packageVersionService.findPackageVersion(packageKey, version, jsonResponse);
+    }
+}

src/commands/configuration-management/package-version.service.ts

@@ -0,0 +1,36 @@
+import { Context } from "../../core/command/cli-context";
+import { fileService, FileService } from "../../core/utils/file-service";
+import { logger } from "../../core/utils/logger";
+import { v4 as uuidv4 } from "uuid";
+import { PackageVersionApi } from "./api/package-version-api";
+import { PackageVersionTransport } from "./interfaces/package-version.interfaces";
+
+export class PackageVersionService {
+    private packageVersionApi: PackageVersionApi;
+
+    constructor(context: Context) {
+        this.packageVersionApi = new PackageVersionApi(context);
+    }
+
+    public async findPackageVersion(packageKey: string, version: string, jsonResponse: boolean): Promise<void> {
+        const packageVersionTransport: PackageVersionTransport = await this.packageVersionApi.findOne(packageKey, version);
+        if (jsonResponse) {
+            const filename = uuidv4() + ".json";
+            fileService.writeToFileWithGivenName(JSON.stringify(packageVersionTransport, null, 2), filename);
+            logger.info(FileService.fileDownloadedMessage + filename);
+        } else {
+            this.printPackageVersionTransport(packageVersionTransport);
+        }
+    }
+
+    private printPackageVersionTransport(packageVersionTransport: PackageVersionTransport): void {
+        logger.info(`Package Key: ${packageVersionTransport.packageKey}`);
+        logger.info(`Version: ${packageVersionTransport.version}`);
+        logger.info(`History ID: ${packageVersionTransport.historyId}`);
+        logger.info(`Change Date: ${new Date(packageVersionTransport.changeDate).toISOString()}`);
+        logger.info(`Publish Date: ${new Date(packageVersionTransport.publishDate).toISOString()}`);
+        logger.info(`Publish Message: ${packageVersionTransport.publishMessage}`);
+        logger.info(`Deployed: ${packageVersionTransport.deployed}`);
+        logger.info(`Published By: ${packageVersionTransport.publishedBy}`);
+    }
+}

tests/commands/configuration-management/config-version.spec.ts

@@ -0,0 +1,76 @@
+import { PackageVersionTransport } from "../../../src/commands/configuration-management/interfaces/package-version.interfaces";
+import { mockAxiosGet } from "../../utls/http-requests-mock";
+import { PackageVersionService } from "../../../src/commands/configuration-management/package-version.service";
+import { testContext } from "../../utls/test-context";
+import { loggingTestTransport, mockWriteFileSync } from "../../jest.setup";
+import { FileService } from "../../../src/core/utils/file-service";
+import * as path from "path";
+import {
+    PackageVersionCommandService
+} from "../../../src/commands/configuration-management/package-version-command.service";
+
+describe("Package Version get", () => {
+    const packageVersion: PackageVersionTransport = {
+        packageKey: "test-package-key",
+        historyId: "history-123",
+        version: "1.2.3",
+        changeDate: new Date("2024-01-15T10:30:00Z").toISOString(),
+        publishDate: new Date("2024-01-15T11:00:00Z").toISOString(),
+        publishMessage: "Initial release",
+        deployed: true,
+        publishedBy: "[email protected]",
+    };
+
+    it("Should get package version metadata", async () => {
+        const packageKey = "test-package-key";
+        const version = "1.2.3";
+        mockAxiosGet(`https://myTeam.celonis.cloud/pacman/api/core/packages/${packageKey}/versions/${version}`, packageVersion);
+
+        await new PackageVersionCommandService(testContext).getPackageVersion(packageKey, version, false);
+
+        expect(loggingTestTransport.logMessages.length).toBe(8);
+        expect(loggingTestTransport.logMessages[0].message).toContain(`Package Key: ${packageVersion.packageKey}`);
+        expect(loggingTestTransport.logMessages[1].message).toContain(`Version: ${packageVersion.version}`);
+        expect(loggingTestTransport.logMessages[2].message).toContain(`History ID: ${packageVersion.historyId}`);
+        expect(loggingTestTransport.logMessages[3].message).toContain(`Change Date: ${new Date(packageVersion.changeDate).toISOString()}`);
+        expect(loggingTestTransport.logMessages[4].message).toContain(`Publish Date: ${new Date(packageVersion.publishDate).toISOString()}`);
+        expect(loggingTestTransport.logMessages[5].message).toContain(`Publish Message: ${packageVersion.publishMessage}`);
+        expect(loggingTestTransport.logMessages[6].message).toContain(`Deployed: ${packageVersion.deployed}`);
+        expect(loggingTestTransport.logMessages[7].message).toContain(`Published By: ${packageVersion.publishedBy}`);
+    });
+
+    it("Should get package version metadata and return as JSON", async () => {
+        const packageKey = "test-package-key";
+        const version = "1.2.3";
+        mockAxiosGet(`https://myTeam.celonis.cloud/pacman/api/core/packages/${packageKey}/versions/${version}`, packageVersion);
+
+        await new PackageVersionService(testContext).findPackageVersion(packageKey, version, true);
+
+        const expectedFileName = loggingTestTransport.logMessages[0].message.split(FileService.fileDownloadedMessage)[1];
+
+        expect(mockWriteFileSync).toHaveBeenCalledWith(path.resolve(process.cwd(), expectedFileName), expect.any(String), {encoding: "utf-8"});
+
+        const packageVersionTransport = JSON.parse(mockWriteFileSync.mock.calls[0][1]) as PackageVersionTransport;
+
+        expect(packageVersionTransport).toEqual(packageVersion);
+    });
+
+    it("Should handle package version with empty publish message", async () => {
+        const packageKey = "test-package";
+        const version = "1.0.0";
+        const packageVersionWithEmptyMessage: PackageVersionTransport = {
+            ...packageVersion,
+            packageKey: packageKey,
+            version: version,
+            publishMessage: "",
+        };
+
+        mockAxiosGet(`https://myTeam.celonis.cloud/pacman/api/core/packages/${packageKey}/versions/${version}`, packageVersionWithEmptyMessage);
+
+        await new PackageVersionCommandService(testContext).getPackageVersion(packageKey, version, false);
+
+        expect(loggingTestTransport.logMessages.length).toBe(8);
+        expect(loggingTestTransport.logMessages[5].message).toContain("Publish Message: ");
+    });
+});
+