TA-3767: Migrate Studio commands

.github/CODEOWNERS

@@ -8,5 +8,5 @@
 #/src/commands/action-flows/                       action-flow team
 #/src/commands/analysis/                           filter and foundation team
 #/src/commands/cpm4/                               cpm4 team
-#/src/commands/data-pipeline/                      data-management team
-#/src/commands/studio/                             @celonis/navi
+/src/commands/data-pipeline/                      @Dusan-r @IvanGandacov @EktaCelonis @gorasoCelonis
+/src/commands/studio/                             @celonis/navi

src/commands/data-pipeline/connection/connection-command.service.ts

@@ -0,0 +1,23 @@
+import { Context } from "../../../core/command/cli-context";
+import { ConnectionService } from "./connection.service";
+
+export class ConnectionCommandService {
+
+    private connectionService: ConnectionService;
+
+    constructor(context: Context) {
+        this.connectionService = new ConnectionService(context);
+    }
+
+    public async updateProperty(dataPoolId: string, connectionId: string, property: string, value: string): Promise<void>{
+        await this.connectionService.updateProperty(dataPoolId, connectionId, property, value);
+    }
+
+    public async getProperties(dataPoolId: string, connectionId: string): Promise<void> {
+        await this.connectionService.listProperties(dataPoolId, connectionId);
+    }
+
+    public async listConnections(dataPoolId: string): Promise<any> {
+        await this.connectionService.findAllConnections(dataPoolId);
+    }
+}

src/commands/data-pipeline/connection/connection.commands.ts

@@ -0,0 +1,50 @@
+/**
+ * Commands related to the Data Pool Connections.
+ */
+
+import { Command, OptionValues } from "commander";
+import { Configurator } from "../../../core/command/module-handler";
+import { ConnectionCommandService } from "./connection-command.service";
+import { Context } from "../../../core/command/cli-context";
+
+export class ConnectionCommands {
+
+    register(context: Context, configurator: Configurator) {
+        const listCommand = configurator.command("list");
+        listCommand.command("connection")
+            .description("Command to list all connections in a Data Pool")
+            .option("-p, --profile <profile>", "Profile which you want to use to list connections")
+            .requiredOption("--dataPoolId <dataPoolId>", "ID of the data pool")
+            .action(this.listConnections);
+
+        const getCommand = configurator.command("get");
+        getCommand.command("connection")
+            .description("Programmatically read properties of your connections")
+            .option("-p, --profile <profile>", "Profile which you want to use to update the data pool configuration")
+            .requiredOption("--dataPoolId <dataPoolId>", "Id of the data pool you want to update")
+            .requiredOption("--connectionId <connectionId>", "Id of the connection you want to update")
+            .action(this.getCommandProperties);
+
+        const setCommand = configurator.command("set");
+        setCommand.command("connection")
+            .description("Programmatically update properties of your connections")
+            .option("-p, --profile <profile>", "Profile which you want to use to update the data pool configuration")
+            .requiredOption("--dataPoolId <dataPoolId>", "Id of the data pool you want to update")
+            .requiredOption("--connectionId <connectionId>", "Id of the connection you want to update")
+            .requiredOption("--property <property>", "The property you want to update")
+            .requiredOption("--value <value>", "The value you want to update")
+            .action(this.updateConnectionProperty);
+    }
+
+    async getCommandProperties(context: Context, command: Command, options: OptionValues) {
+        await new ConnectionCommandService(context).getProperties(options.dataPoolId, options.connectionId);
+    }
+
+    async listConnections(context: Context, command: Command, options: OptionValues) {
+        await new ConnectionCommandService(context).listConnections(options.dataPoolId);
+    }
+
+    async updateConnectionProperty(context: Context, command: Command, options: OptionValues) {
+        await new ConnectionCommandService(context).updateProperty(options.dataPoolId, options.connectionId, options.property, options.value);
+    }
+}

src/commands/data-pipeline/connection/connection.service.ts

@@ -0,0 +1,62 @@
+import { logger } from "../../../core/utils/logger";
+import { Context } from "../../../core/command/cli-context";
+import { DataPoolApi } from "../data-pool/data-pool-api";
+
+export class ConnectionService {
+
+    private dataPoolApi: DataPoolApi;
+
+    constructor(context: Context) {
+        this.dataPoolApi = new DataPoolApi(context)
+    }
+
+    public async findAllConnections(dataPoolId: string): Promise<any[]> {
+        const connections =  await this.dataPoolApi.listConnections(dataPoolId);
+        connections.forEach(connection => {
+            logger.info(`Connection ID: ${connection.id} - Name: ${connection.name} - Type: ${connection.type}`);
+        })
+        return connections;
+    }
+
+    public async listProperties(dataPoolId: string, connectionId: string): Promise<any[]> {
+        const connection =  await this.dataPoolApi.getConnection(dataPoolId, connectionId);
+        const type = connection.type;
+        const typedConnection = await this.dataPoolApi.getTypedConnection(dataPoolId, connectionId, type);
+        logger.info(`Connection ID: ${connection.id} - Name: ${connection.name} - Type: ${connection.type}`);
+        logger.info(`Properties:`)
+        for (let k in typedConnection) {
+            if (typeof typedConnection[k] === 'object') {
+                for (let o in typedConnection[k]) {
+                    logger.info(`  ${k}.${o} : ${typeof typedConnection[k][o]} := ${typedConnection[k][o]}`)
+                }
+            } else {
+                logger.info(`  ${k} : ${typeof typedConnection[k]} := ${typedConnection[k]}`);
+            }
+        }
+        return typedConnection;
+    }
+
+    public async updateProperty(dataPoolId: string, connectionId: string, property: string, value: string) {
+        const connection =  await this.dataPoolApi.getConnection(dataPoolId, connectionId);
+        const type = connection.type;
+        const typedConnection = await this.dataPoolApi.getTypedConnection(dataPoolId, connectionId, type);
+        const parts = property.split(".");
+        // update the typed connection object
+        let currentObject = typedConnection;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            if (currentObject.hasOwnProperty(part)) {
+                if (i < parts.length - 1) {
+                    currentObject = currentObject[part];
+                } else {
+                    currentObject[part] = value;
+                }
+            } else {
+                logger.error(`Property ${property} not found on connection.`)
+                return;
+            }
+        }
+        await this.dataPoolApi.updateTypedConnection(dataPoolId, connectionId, type, typedConnection);
+        logger.info(`Property ${property} updated.`);
+    }
+}

src/commands/data-pipeline/data-pool/data-pool-api.ts

@@ -0,0 +1,55 @@
+import { DataPoolInstallVersionReport, DataPoolPageTransport } from "./data-pool-manager.interfaces";
+import { FatalError } from "../../../core/utils/logger";
+import { Context } from "../../../core/command/cli-context";
+import { HttpClient } from "../../../core/http/http-client";
+
+export class DataPoolApi {
+
+    private httpClient: HttpClient;
+
+    constructor(context: Context) {
+        this.httpClient = context.httpClient;
+    }
+
+    public async findAllPagedPools(limit: string, page: string): Promise<DataPoolPageTransport> {
+        return this.httpClient.get(`/integration/api/pools/paged?limit=${limit}&page=${page}`).catch(e => {
+            throw new FatalError(`Problem getting data pools: : ${e}`);
+        });
+    }
+
+    public async executeDataPoolsBatchImport(importRequest: string): Promise<DataPoolInstallVersionReport> {
+        return this.httpClient.post("/integration/api/pool/batch-import", importRequest).catch(e => {
+            throw new FatalError(`Data Pool batch import failed: : ${e}`);
+        });
+    }
+
+    public async exportDataPool(poolId: string): Promise<string> {
+        return this.httpClient.get(`/integration/api/pools/${poolId}/v2/export`).catch(e => {
+            throw new FatalError(`Data Pool export failed: : ${e}`);
+        });
+    }
+
+    public async listConnections(poolId: string): Promise<any> {
+        return this.httpClient.get(`/integration/api/pools/${poolId}/overviews/data-sources`).catch(e => {
+            throw new FatalError(`Can not list connections: : ${e}`);
+        });
+    }
+
+    public async getConnection(poolId: string, connectionId: string): Promise<any> {
+        return this.httpClient.get(`/integration/api/pools/${poolId}/data-sources/${connectionId}`).catch(e => {
+            throw new FatalError(`Can not get connection: : ${e}`);
+        });
+    }
+
+    public async getTypedConnection(poolId: string, connectionId: string, type: string): Promise<any> {
+        return this.httpClient.get(`/integration/api/datasource/${type}/${connectionId}`).catch(e => {
+            throw new FatalError(`Can get typed connection: : ${e}`);
+        });
+    }
+
+    public async updateTypedConnection(poolId: string, connectionId: string, type: string, data: any): Promise<any> {
+        return this.httpClient.put(`/integration/api/datasource/${type}/${connectionId}`, data).catch(e => {
+            throw new FatalError(`Can not update typed connection: ${e}`);
+        });
+    }
+}

src/commands/data-pipeline/data-pool/data-pool-command.service.ts

@@ -0,0 +1,49 @@
+import { ContentService } from "../../../core/http/http-shared/content.service";
+import { DataPoolManagerFactory } from "./data-pool-manager.factory";
+import { Context } from "../../../core/command/cli-context";
+import { DataPoolService } from "./data-pool-service";
+import { logger } from "../../../core/utils/logger";
+
+export class DataPoolCommandService {
+    private contentService = new ContentService();
+    private dataPoolManagerFactory: DataPoolManagerFactory;
+    private dataPoolService: DataPoolService;
+
+    constructor(context: Context) {
+        this.dataPoolManagerFactory = new DataPoolManagerFactory(context);
+        this.dataPoolService = new DataPoolService(context);
+    }
+
+    public async pullDataPool(id: string): Promise<void> {
+        await this.contentService.pull(this.dataPoolManagerFactory.createManager(id, null));
+    }
+
+    public async pushDataPool(filename: string): Promise<void> {
+        await this.contentService.push(this.dataPoolManagerFactory.createManager(null, filename));
+    }
+
+    public async exportDataPool(poolId: string, outputToJsonFile: boolean): Promise<void> {
+        await this.dataPoolService.exportDataPool(poolId, outputToJsonFile);
+    }
+
+    public async pushDataPools(): Promise<void> {
+        await this.contentService.batchPush(this.dataPoolManagerFactory.createManagers());
+    }
+
+    public async batchImportDataPools(requestFile: string, outputToJsonFile: boolean): Promise<void> {
+        await this.dataPoolService.batchImportDataPools(requestFile, outputToJsonFile);
+    }
+
+    public async updateDataPool(id: string, filename: string): Promise<any> {
+        await this.contentService.update(this.dataPoolManagerFactory.createManager(id, filename));
+    }
+
+    public async listDataPools(jsonResponse: boolean): Promise<any> {
+        logger.info(jsonResponse);
+        if (jsonResponse) {
+            await this.dataPoolService.findAndExportAllPools();
+        } else {
+            await this.dataPoolService.listDataPools();
+        }
+    }
+}

src/commands/data-pipeline/data-pool/data-pool-manager.factory.ts

@@ -0,0 +1,47 @@
+import * as path from "path";
+import { DataPoolManager } from "./data-pool.manager";
+import { FatalError, logger } from "../../../core/utils/logger";
+import * as fs from "node:fs";
+import { Context } from "../../../core/command/cli-context";
+
+export class DataPoolManagerFactory {
+
+    private readonly context: Context;
+
+    constructor(context: Context) {
+        this.context = context;
+    }
+
+    public createManager(id: string, filename: string): DataPoolManager {
+        const dataPoolManager = new DataPoolManager(this.context);
+        dataPoolManager.id = id;
+        if (filename !== null) {
+            dataPoolManager.content = this.readFile(filename);
+        }
+        return dataPoolManager;
+    }
+
+    public createManagers(): DataPoolManager[] {
+        const dataPools = fs.readdirSync(process.cwd());
+        return dataPools
+            .filter(filePath => {
+                if (filePath.startsWith(DataPoolManager.DATA_POOL_FILE_NAME_PREFIX) && filePath.endsWith(".json")) {
+                    const file = fs.lstatSync(filePath);
+                    return file.isFile();
+                }
+                return false;
+            })
+            .map(dataPool => {
+                const dataPoolManager = new DataPoolManager(this.context);
+                dataPoolManager.content = this.readFile(dataPool);
+                return dataPoolManager;
+            });
+    }
+
+    private readFile(filename: string): string {
+        if (!fs.existsSync(path.resolve(process.cwd(), filename))) {
+            logger.error(new FatalError("The provided file does not exit"));
+        }
+        return fs.readFileSync(path.resolve(process.cwd(), filename), { encoding: "utf-8" });
+    }
+}

src/commands/data-pipeline/data-pool/data-pool-manager.interfaces.ts

@@ -0,0 +1,30 @@
+export declare type DataPoolStatus = "CANCEL" | "FAIL" | "QUEUED" | "RUNNING" | "SKIPPED" | "SUCCESS" | "UNCONFIGURED";
+export type Tag = {};
+
+export declare class DataSourceSlimTransport {
+    id: string;
+    name: string;
+    imported: boolean;
+    importedPoolId: string;
+}
+
+export interface DataPoolSlimTransport {
+    id: string;
+    name: string;
+    status: DataPoolStatus;
+    lastExecutionStartDate: Date;
+    createdBy: string;
+    tags: Tag[];
+    rawDataSize: number;
+    dataSources: DataSourceSlimTransport[];
+}
+export declare class DataPoolPageTransport {
+    content: DataPoolSlimTransport[];
+    pageSize: number;
+    pageNumber: number;
+    totalCount: number;
+}
+
+export declare class DataPoolInstallVersionReport {
+    dataModelIdMappings: Map<string, string>;
+}