TA-4066: Implement git integration

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "CLI Tool to help manage content in Celonis Platform",
   "main": "content-cli.js",
   "bin": {
@@ -26,6 +26,7 @@
     "openid-client": "5.6.1",
     "hpagent": "1.2.0",
     "semver": "7.6.3",
+    "simple-git": "3.28.0",
     "valid-url": "1.0.9",
     "winston": "3.17.0",
     "yaml": "2.7.0"

src/commands/configuration-management/batch-import-export.service.ts

@@ -15,19 +15,23 @@ import { parse, stringify } from "../../core/utils/json";
 import { PackageApi } from "../studio/api/package-api";
 import { BatchImportExportApi } from "./api/batch-import-export-api";
 import { StudioService } from "./studio.service";
+import { GitService } from "../../core/git-profile/git/git.service";
+import * as fs from "node:fs";
 
 export class BatchImportExportService {
 
     private batchImportExportApi: BatchImportExportApi;
 
     private studioPackageApi: PackageApi;
     private studioService: StudioService;
+    private gitService: GitService;
 
     constructor(context: Context) {
         this.batchImportExportApi = new BatchImportExportApi(context);
 
         this.studioPackageApi = new PackageApi(context);
         this.studioService = new StudioService(context);
+        this.gitService = new GitService(context);
     }
 
     public async listActivePackages(flavors: string[]): Promise<void> {
@@ -51,7 +55,7 @@ export class BatchImportExportService {
         this.exportListOfPackages(packagesToExport);
     }
 
-    public async batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean = false): Promise<void> {
+    public async batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean = false, gitBranch: string): Promise<void> {
         let exportedPackagesData: Buffer;
         if (packageKeys) {
             exportedPackagesData = await this.batchImportExportApi.exportPackages(packageKeys, withDependencies);
@@ -89,10 +93,16 @@ export class BatchImportExportService {
             }
         });
 
-        const fileDownloadedMessage = "File downloaded successfully. New filename: ";
-        const filename = `export_${uuidv4()}.zip`;
-        exportedPackagesZip.writeZip(filename);
-        logger.info(fileDownloadedMessage + filename);
+        if (gitBranch) {
+            const extractedDirectory = fileService.extractExportedZipWithNestedZips(exportedPackagesZip);
+            await this.gitService.pushToBranch(extractedDirectory, gitBranch);
+            logger.info("Successfully exported packages to branch: " + gitBranch);
+        } else {
+            const fileDownloadedMessage = "File downloaded successfully. New filename: ";
+            const filename = `export_${uuidv4()}.zip`;
+            exportedPackagesZip.writeZip(filename);
+            logger.info(fileDownloadedMessage + filename);
+        }
     }
 
     public async batchExportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void> {
@@ -107,8 +117,16 @@ export class BatchImportExportService {
         }
     }
 
-    public async batchImportPackages(file: string, overwrite: boolean): Promise<void> {
-        let configs = new AdmZip(file);
+    public async batchImportPackages(file: string, overwrite: boolean, gitBranch: string): Promise<void> {
+        let fileToBeImported: string;
+        if (gitBranch) {
+            fileToBeImported = await this.gitService.pullFromBranch(gitBranch);
+            fileToBeImported = fileService.zipDirectoryInBatchExportFormat(fileToBeImported);
+        } else {
+            fileToBeImported = file;
+        }
+
+        let configs = new AdmZip(fileToBeImported);
         const studioManifests = this.parseEntryData(configs, BatchExportImportConstants.STUDIO_FILE_NAME) as StudioPackageManifest[];
         const variablesManifests: VariableManifestTransport[] = this.parseEntryData(configs, BatchExportImportConstants.VARIABLES_FILE_NAME) as VariableManifestTransport[];
 
@@ -119,6 +137,10 @@ export class BatchImportExportService {
         const postPackageImportData = await this.batchImportExportApi.importPackages(formData, overwrite);
         await this.studioService.processImportedPackages(configs, existingStudioPackages, studioManifests);
 
+        if (gitBranch) {
+            fs.rmSync(fileToBeImported);
+        }
+
         const reportFileName = "config_import_report_" + uuidv4() + ".json";
         fileService.writeToFileWithGivenName(JSON.stringify(postPackageImportData), reportFileName);
         logger.info("Config import report file: " + reportFileName);

src/commands/configuration-management/config-command.service.ts

@@ -36,16 +36,22 @@ export class ConfigCommandService {
         }
     }
 
-    public batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean = false): Promise<void> {
-        return this.batchImportExportService.batchExportPackages(packageKeys, packageKeysByVersion, withDependencies);
+    public batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean = false, gitBranch: string): Promise<void> {
+        return this.batchImportExportService.batchExportPackages(packageKeys, packageKeysByVersion, withDependencies, gitBranch);
     }
 
     public batchExportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void> {
         return this.batchImportExportService.batchExportPackagesMetadata(packageKeys, jsonResponse);
     }
 
-    public batchImportPackages(file: string, overwrite: boolean): Promise<void> {
-        return this.batchImportExportService.batchImportPackages(file, overwrite);
+    public batchImportPackages(file: string, overwrite: boolean, gitBranch: string): Promise<void> {
+        if (file && gitBranch) {
+            throw new Error("You cannot use both file and gitBranch options at the same time. Only one import source can be defined.");
+        }
+        if (!file && !gitBranch) {
+            throw new Error("You must provide either a file or a gitBranch option to import packages.");
+        }
+        return this.batchImportExportService.batchImportPackages(file, overwrite, gitBranch);
     }
 
     public diffPackages(file: string, hasChanges: boolean, jsonResponse: boolean): Promise<void> {

src/commands/configuration-management/module.ts

@@ -27,6 +27,8 @@ class Module extends IModule {
             .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", "")
+            .betaOption("--gitProfile <gitProfile>", "Git profile which you want to use for the Git operations")
+            .betaOption("--gitBranch <gitBranch>", "Git branch in which you want to push the exported file")
             .action(this.batchExportPackages);
 
         const metadataCommand = configCommand.command("metadata")
@@ -42,7 +44,9 @@ class Module extends IModule {
         configCommand.command("import")
             .description("Command to import package configs")
             .option("--overwrite", "Flag to allow overwriting of packages")
-            .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
+            .betaOption("--gitProfile <gitProfile>", "Git profile which you want to use for the Git operations")
+            .betaOption("--gitBranch <gitBranch>", "Git branch from which you want to pull the exported file and import")
+            .option("-f, --file <file>", "Exported packages file (relative path)")
             .action(this.batchImportPackages);
 
         configCommand.command("diff")
@@ -79,15 +83,15 @@ class Module extends IModule {
         if ((options.packageKeys && options.keysByVersion) || (!options.packageKeys && !options.keysByVersion)) {
             throw new Error("Please provide either --packageKeys or --keysByVersion, but not both.");
         }
-        await new ConfigCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies);
+        await new ConfigCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies, options.gitBranch);
     }
 
     private async batchExportPackagesMetadata(context: Context, command: Command, options: OptionValues): Promise<void> {
         await new ConfigCommandService(context).batchExportPackagesMetadata(options.packageKeys, options.json);
     }
 
     private async batchImportPackages(context: Context, command: Command, options: OptionValues): Promise<void> {
-        await new ConfigCommandService(context).batchImportPackages(options.file, options.overwrite);
+        await new ConfigCommandService(context).batchImportPackages(options.file, options.overwrite, options.gitBranch);
     }
 
     private async diffPackages(context: Context, command: Command, options: OptionValues): Promise<void> {

src/commands/git-profile/git-profile-command.service.ts

@@ -0,0 +1,60 @@
+import { QuestionService } from "../../core/utils/question.service";
+import { FatalError, logger } from "../../core/utils/logger";
+import { GitProfileService } from "../../core/git-profile/git-profile.service";
+import { AuthenticationType, GitProfile } from "../../core/git-profile/git-profile.interface";
+
+export class GitProfileCommandService {
+    private gitProfileService = new GitProfileService();
+
+    public async createProfile(setAsDefault: boolean): Promise<void> {
+        const profile: GitProfile = {} as GitProfile;
+        const questions = new QuestionService();
+        try {
+            profile.name = await questions.ask("Name of the Git profile to create: ");
+            profile.username = await questions.ask("Your Git username: ");
+            profile.repository = await questions.ask("Your repository (format: repoOwner/repoName): ");
+            const type = await questions.ask("Authentication type: PAT (1), SSH token (2): " );
+            switch (type) {
+                case "1":
+                    profile.authenticationType = AuthenticationType.PAT;
+                    profile.token = await questions.ask("Your Personal Access Token (PAT): " );
+                    break;
+                case "2":
+                    profile.authenticationType = AuthenticationType.SSH;
+                    break;
+                default:
+                    logger.error(new FatalError("Invalid type"));
+                    break;
+            }
+            // possibly check if the user has sent a valid token that has access in the repository
+
+            this.gitProfileService.storeProfile(profile);
+            if (setAsDefault) {
+                await this.makeDefaultProfile(profile.name);
+            }
+        } finally {
+            await questions.close();
+        }
+        logger.info("Git Profile created successfully!");
+    }
+
+    public async listProfiles(): Promise<void> {
+        this.gitProfileService.readAllProfiles().then((profiles: string[]) => {
+            const defaultProfile = this.gitProfileService.getDefaultProfile();
+            if (profiles) {
+                profiles.forEach(profile => {
+                    if (defaultProfile && defaultProfile === profile) {
+                        logger.info(profile + " (default)");
+                    } else {
+                        logger.info(profile);
+                    }
+                });
+            }
+        });
+    }
+
+    public async makeDefaultProfile(profile: string): Promise<void> {
+        await this.gitProfileService.makeDefaultProfile(profile);
+        logger.info("Default Git profile: " + profile);
+    }
+}

src/commands/git-profile/module.ts

@@ -0,0 +1,53 @@
+/**
+ * Commands to create and list access profiles.
+ */
+
+import { Command, OptionValues } from "commander";
+import { Configurator, IModule } from "../../core/command/module-handler";
+import { Context } from "../../core/command/cli-context";
+import { GitProfileCommandService } from "./git-profile-command.service";
+import { logger } from "../../core/utils/logger";
+
+class Module extends IModule {
+
+    public register(context: Context, configurator: Configurator): void {
+        const gitCommand = configurator.command("git")
+                .beta()
+                .description("Commands related to Git settings");
+
+        const gitProfileCommand = gitCommand.command("profile")
+            .beta()
+            .description("Manage Git profiles required to use git-related operations.");
+
+        gitProfileCommand.command("list")
+                .description("Command to list all stored Git profiles")
+                .beta()
+                .action(this.listProfiles);
+
+        gitProfileCommand.command("create")
+                .description("Command to create a new Git profile")
+                .option("--setAsDefault", "Set this Git profile as default")
+                .beta()
+                .action(this.createProfile);
+
+        gitProfileCommand.command("default <profile>")
+                .description("Command to set a Git profile as default")
+                .beta()
+                .action(this.defaultProfile);
+    }
+
+    private async defaultProfile(context: Context, command: Command): Promise<void> {
+        const profile = command.args[0];
+        await new GitProfileCommandService().makeDefaultProfile(profile);
+    }
+
+    private async createProfile(context: Context, command: Command, options: OptionValues): Promise<void> {
+        await new GitProfileCommandService().createProfile(options.setAsDefault);
+    }
+
+    private async listProfiles(context: Context, command: Command): Promise<void> {
+        await new GitProfileCommandService().listProfiles();
+    }
+}
+
+export = Module;

src/content-cli.ts

@@ -63,11 +63,11 @@ async function run(): Promise<void> {
     await context.init();
 
     const moduleHandler = new ModuleHandler(program, context);
-    
+
     configureRootCommands(moduleHandler.configurator);
 
     moduleHandler.discoverAndRegisterModules(__dirname, program.opts().dev);
-    
+
     try {
         program.parse(process.argv);
     } catch (error) {

src/core/command/cli-context.ts

@@ -2,6 +2,8 @@ import { HttpClient } from "../http/http-client";
 import {ProfileService} from "../profile/profile.service";
 import {FatalError, logger} from "../utils/logger";
 import {Profile} from "../profile/profile.interface";
+import { GitProfileService } from "../git-profile/git-profile.service";
+import { GitProfile } from "../git-profile/git-profile.interface";
 
 /**
  * The execution context object is passed to the modules to access
@@ -13,14 +15,18 @@ export class Context {
 
     public _httpClient: HttpClient;
     public profile: Profile;
+    public gitProfile: GitProfile;
 
     private log = logger;
     private profileName: string | undefined;
+    private gitProfileName: string | undefined;
 
     private profileService = new ProfileService();
+    private gitProfileService = new GitProfileService();
 
     constructor(options: any) {
         this.profileName = options.profile;
+        this.gitProfileName = options.gitProfile;
     }
 
     public get httpClient(): HttpClient {
@@ -32,6 +38,7 @@ export class Context {
 
     public async init(): Promise<void> {
         await this.loadProfile(this.profileName);
+        await this.loadGitProfile(this.gitProfileName);
 
         if (this.profile) {
             // only if a profile is available, it makes sense to provide an initialized
@@ -59,4 +66,22 @@ export class Context {
         }
     }
 
+    private async loadGitProfile(gitProfileName: string | undefined): Promise<void> {
+        if (!gitProfileName) {
+            this.log.debug("Git Profile name not specified, using default profile");
+            gitProfileName = this.gitProfileService.getDefaultProfile();
+            if (!gitProfileName) {
+                this.log.debug("A default Git profile is not configured.");
+            }
+        }
+        try {
+            this.gitProfile = await this.gitProfileService.findProfile(gitProfileName);
+            this.gitProfileName = gitProfileName;
+            this.log.debug(`Using Git profile ${gitProfileName}`);
+        } catch (err) {
+            this.gitProfile = undefined;
+            this.gitProfileName = undefined;
+        }
+    }
+
 }

src/core/git-profile/git-profile.interface.ts

@@ -0,0 +1,15 @@
+export interface GitProfile {
+    name: string;
+    username?: string;
+    repository: string; // in the format "owner/repository"
+    token?: string;
+    authenticationType: AuthenticationType;
+}
+
+export type AuthenticationType = "SSH" | "Personal Access Token";
+
+// tslint:disable-next-line:variable-name
+export const AuthenticationType: { [key: string]: AuthenticationType } = {
+    SSH: "SSH",
+    PAT: "Personal Access Token",
+};