@celonis/content-cli 0.5.3 → 0.5.5

package/api/data-pool-api.js

@@ -42,6 +42,34 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        listConnections(poolId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/integration/api/pools/${poolId}/overviews/data-sources`).catch(e => {
+                    throw new logger_1.FatalError(`Can not list connections: : ${e}`);
+                });
+            });
+        }
+        getConnection(poolId, connectionId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/integration/api/pools/${poolId}/data-sources/${connectionId}`).catch(e => {
+                    throw new logger_1.FatalError(`Can not get connection: : ${e}`);
+                });
+            });
+        }
+        getTypedConnection(poolId, connectionId, type) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/integration/api/datasource/${type}/${connectionId}`).catch(e => {
+                    throw new logger_1.FatalError(`Can get typed connection: : ${e}`);
+                });
+            });
+        }
+        updateTypedConnection(poolId, connectionId, type, data) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.put(`/integration/api/datasource/${type}/${connectionId}`, data).catch(e => {
+                    throw new logger_1.FatalError(`Can not update typed connection: ${e}`);
+                });
+            });
+        }
     }
     DataPoolApi.INSTANCE = new DataPoolApi();
     exports.dataPoolApi = DataPoolApi.INSTANCE;

package/api/variable-assignment-apis.js

@@ -0,0 +1,20 @@
+(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.variableAssignmentApis = {
+        DATA_MODEL: {
+            url: "/package-manager/api/compute-pools/pools-with-data-models"
+        },
+        CONNECTION: {
+            url: "/process-automation-v2/api/connections"
+        }
+    };
+});

package/api/variables-api.js

@@ -13,13 +13,14 @@ 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", "../services/http-client-service.v2", "../util/logger"], factory);
+        define(["require", "exports", "../services/http-client-service.v2", "../util/logger", "./variable-assignment-apis"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const http_client_service_v2_1 = require("../services/http-client-service.v2");
     const logger_1 = require("../util/logger");
+    const variable_assignment_apis_1 = require("./variable-assignment-apis");
     class VariablesApi {
         assignVariableValues(packageKey, variablesAssignments) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -28,7 +29,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        getCandidateAssignments(type, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!VariablesApi.ASSIGNMENT_APIS[type]) {
+                    throw new logger_1.FatalError(`Variable type ${type} not supported.`);
+                }
+                const apiUrl = VariablesApi.ASSIGNMENT_APIS[type].url + (params.toString().length ? `?${params.toString()}` : "");
+                return http_client_service_v2_1.httpClientV2.get(apiUrl).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting variables assignment values for type ${type}: ${e}`);
+                });
+            });
+        }
     }
     VariablesApi.INSTANCE = new VariablesApi();
+    VariablesApi.ASSIGNMENT_APIS = variable_assignment_apis_1.variableAssignmentApis;
     exports.variablesApi = VariablesApi.INSTANCE;
 });

package/commands/connection.command.js

@@ -0,0 +1,40 @@
+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", "../services/connection/connection.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const connection_service_1 = require("../services/connection/connection.service");
+    class ConnectionCommand {
+        updateProperty(profile, dataPoolId, connectionId, property, value) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield connection_service_1.connectionService.updateProperty(dataPoolId, connectionId, property, value);
+            });
+        }
+        getProperties(profile, dataPoolId, connectionId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield connection_service_1.connectionService.listProperties(dataPoolId, connectionId);
+            });
+        }
+        listConnections(profile, dataPoolId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield connection_service_1.connectionService.findAllConnections(dataPoolId);
+            });
+        }
+    }
+    exports.ConnectionCommand = ConnectionCommand;
+});

package/commands/variable.command.js

@@ -0,0 +1,35 @@
+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", "../services/package-manager/variable-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const variable_service_1 = require("../services/package-manager/variable-service");
+    class VariableCommand {
+        listAssignments(variableType, jsonResponse, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (jsonResponse) {
+                    yield variable_service_1.variableService.findAndExportCandidateAssignments(variableType, params);
+                }
+                else {
+                    yield variable_service_1.variableService.listCandidateAssignments(variableType, params);
+                }
+            });
+        }
+    }
+    exports.VariableCommand = VariableCommand;
+});

package/content-cli-get.js

@@ -0,0 +1,52 @@
+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", "./commands/connection.command", "commander", "./util/context-initializer", "./util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const connection_command_1 = require("./commands/connection.command");
+    const commander = require("commander");
+    const context_initializer_1 = require("./util/context-initializer");
+    const logger_1 = require("./util/logger");
+    class Get {
+        static connection(program) {
+            program
+                .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((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new connection_command_1.ConnectionCommand().getProperties(cmd.profile, cmd.dataPoolId, cmd.connectionId);
+                process.exit();
+            }));
+            return program;
+        }
+    }
+    context_initializer_1.ContextInitializer.initContext()
+        .then(() => {
+        Get.connection(commander);
+        commander.parse(process.argv);
+    })
+        .catch(e => {
+        logger_1.logger.error(e);
+    });
+    if (!process.argv.slice(2).length) {
+        commander.outputHelp();
+        process.exit(1);
+    }
+});

package/content-cli-list.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", "./commands/package.command", "./commands/space.command", "./commands/data-pool.command", "./commands/asset.command", "./util/logger", "commander", "./util/context-initializer"], factory);
+        define(["require", "exports", "./commands/package.command", "./commands/space.command", "./commands/data-pool.command", "./commands/asset.command", "./util/logger", "commander", "./util/context-initializer", "./commands/connection.command", "./commands/variable.command"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -25,6 +25,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const logger_1 = require("./util/logger");
     const commander = require("commander");
     const context_initializer_1 = require("./util/context-initializer");
+    const connection_command_1 = require("./commands/connection.command");
+    const variable_command_1 = require("./commands/variable.command");
     class List {
         static packages(program) {
             program
@@ -64,6 +66,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static connections(program) {
+            program
+                .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((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new connection_command_1.ConnectionCommand().listConnections(cmd.profile, cmd.dataPoolId);
+                process.exit();
+            }));
+            return program;
+        }
         static assets(program) {
             program
                 .command("assets")
@@ -77,6 +91,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static assignments(program) {
+            program
+                .command("assignments")
+                .description("Command to list possible variable assignments for a type")
+                .option("-p, --profile <profile>", "Profile which you want to use to list possible variable assignments")
+                .option("--json", "Return response as json type", "")
+                .requiredOption("--type <type>", "Type of variable")
+                .option("--params <params>", "Variable query params")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new variable_command_1.VariableCommand().listAssignments(cmd.type, cmd.json, cmd.params);
+                process.exit();
+            }));
+            return program;
+        }
     }
     exports.List = List;
     process.on("unhandledRejection", (e, promise) => {
@@ -87,6 +115,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         List.spaces(commander);
         List.dataPools(commander);
         List.assets(commander);
+        List.connections(commander);
+        List.assignments(commander);
         commander.parse(process.argv);
     };
     context_initializer_1.ContextInitializer.initContext()

package/content-cli-set.js

@@ -0,0 +1,54 @@
+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", "./commands/connection.command", "commander", "./util/context-initializer", "./util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const connection_command_1 = require("./commands/connection.command");
+    const commander = require("commander");
+    const context_initializer_1 = require("./util/context-initializer");
+    const logger_1 = require("./util/logger");
+    class Set {
+        static connection(program) {
+            program
+                .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((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new connection_command_1.ConnectionCommand().updateProperty(cmd.profile, cmd.dataPoolId, cmd.connectionId, cmd.property, cmd.value);
+                process.exit();
+            }));
+            return program;
+        }
+    }
+    context_initializer_1.ContextInitializer.initContext()
+        .then(() => {
+        Set.connection(commander);
+        commander.parse(process.argv);
+    })
+        .catch(e => {
+        logger_1.logger.error(e);
+    });
+    if (!process.argv.slice(2).length) {
+        commander.outputHelp();
+        process.exit(1);
+    }
+});

package/content-cli.js

@@ -26,6 +26,8 @@
     program.command("push", "Commands to push content.");
     program.command("update", "Commands to update content.");
     program.command("list", "Commands to list content.").alias("ls");
+    program.command("get", "Commands to get configuration properties.");
+    program.command("set", "Commands to set configuration properties.");
     program.version(version_1.VersionUtils.getCurrentCliVersion());
     program.parse(process.argv);
     if (!process.argv.slice(2).length) {

package/interfaces/variable-assignment-api.interface.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/lib/api/data-pool-api.d.ts

@@ -4,6 +4,10 @@ declare class DataPoolApi {
     findAllPagedPools(limit: string, page: string): Promise<DataPoolPageTransport>;
     executeDataPoolsBatchImport(importRequest: string): Promise<DataPoolInstallVersionReport>;
     exportDataPool(poolId: string): Promise<string>;
+    listConnections(poolId: string): Promise<any>;
+    getConnection(poolId: string, connectionId: string): Promise<any>;
+    getTypedConnection(poolId: string, connectionId: string, type: string): Promise<any>;
+    updateTypedConnection(poolId: string, connectionId: string, type: string, data: any): Promise<any>;
 }
 export declare const dataPoolApi: DataPoolApi;
 export {};

package/lib/api/variable-assignment-apis.d.ts

@@ -0,0 +1,4 @@
+import { VariableAssignmentApi } from "../interfaces/variable-assignment-api.interface";
+export declare const variableAssignmentApis: {
+    [key: string]: VariableAssignmentApi;
+};

package/lib/api/variables-api.d.ts

@@ -1,7 +1,13 @@
+/// <reference types="node" />
 import { ContentNodeTransport, VariablesAssignments } from "../interfaces/package-manager.interfaces";
+import { URLSearchParams } from "url";
 declare class VariablesApi {
     static readonly INSTANCE: VariablesApi;
+    static readonly ASSIGNMENT_APIS: {
+        [key: string]: import("../interfaces/variable-assignment-api.interface").VariableAssignmentApi;
+    };
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<ContentNodeTransport[]>;
+    getCandidateAssignments(type: string, params: URLSearchParams): Promise<object[]>;
 }
 export declare const variablesApi: VariablesApi;
 export {};

package/lib/commands/connection.command.d.ts

@@ -0,0 +1,5 @@
+export declare class ConnectionCommand {
+    updateProperty(profile: string, dataPoolId: string, connectionId: string, property: string, value: string): Promise<void>;
+    getProperties(profile: string, dataPoolId: string, connectionId: string): Promise<void>;
+    listConnections(profile: string, dataPoolId: string): Promise<any>;
+}

package/lib/commands/variable.command.d.ts

@@ -0,0 +1,3 @@
+export declare class VariableCommand {
+    listAssignments(variableType: string, jsonResponse: boolean, params: string): Promise<void>;
+}

package/lib/content-cli-get.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/content-cli-list.d.ts

@@ -4,6 +4,8 @@ export declare class List {
     static packages(program: CommanderStatic): CommanderStatic;
     static spaces(program: CommanderStatic): CommanderStatic;
     static dataPools(program: CommanderStatic): CommanderStatic;
+    static connections(program: CommanderStatic): CommanderStatic;
     static assets(program: CommanderStatic): CommanderStatic;
+    static assignments(program: CommanderStatic): CommanderStatic;
 }
 export {};

package/lib/content-cli-set.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/interfaces/variable-assignment-api.interface.d.ts

@@ -0,0 +1,3 @@
+export interface VariableAssignmentApi {
+    url: string;
+}

package/lib/services/connection/connection.service.d.ts

@@ -0,0 +1,7 @@
+declare class ConnectionService {
+    findAllConnections(dataPoolId: string): Promise<any[]>;
+    listProperties(dataPoolId: string, connectionId: string): Promise<any[]>;
+    updateProperty(dataPoolId: string, connectionId: string, property: string, value: string): Promise<void>;
+}
+export declare const connectionService: ConnectionService;
+export {};

package/lib/services/package-manager/variable-service.d.ts

@@ -2,6 +2,9 @@ import { PackageManagerVariableType, PackageWithVariableAssignments, VariablesAs
 declare class VariableService {
     getVariableAssignmentsForNodes(type?: PackageManagerVariableType): Promise<PackageWithVariableAssignments[]>;
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<void>;
+    listCandidateAssignments(type: string, params: string): Promise<void>;
+    findAndExportCandidateAssignments(type: string, params: string): Promise<void>;
+    private parseParams;
 }
 export declare const variableService: VariableService;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "CLI Tool to help manage content in Celonis EMS",
   "main": "content-cli.js",
   "bin": {

package/services/connection/connection.service.js

@@ -0,0 +1,82 @@
+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", "../../api/data-pool-api", "../../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const data_pool_api_1 = require("../../api/data-pool-api");
+    const logger_1 = require("../../util/logger");
+    class ConnectionService {
+        findAllConnections(dataPoolId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const connections = yield data_pool_api_1.dataPoolApi.listConnections(dataPoolId);
+                connections.forEach(connection => {
+                    logger_1.logger.info(`Connection ID: ${connection.id} - Name: ${connection.name} - Type: ${connection.type}`);
+                });
+                return connections;
+            });
+        }
+        listProperties(dataPoolId, connectionId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const connection = yield data_pool_api_1.dataPoolApi.getConnection(dataPoolId, connectionId);
+                const type = connection.type;
+                const typedConnection = yield data_pool_api_1.dataPoolApi.getTypedConnection(dataPoolId, connectionId, type);
+                logger_1.logger.info(`Connection ID: ${connection.id} - Name: ${connection.name} - Type: ${connection.type}`);
+                logger_1.logger.info(`Properties:`);
+                for (let k in typedConnection) {
+                    if (typeof typedConnection[k] === 'object') {
+                        for (let o in typedConnection[k]) {
+                            logger_1.logger.info(`  ${k}.${o} : ${typeof typedConnection[k][o]} := ${typedConnection[k][o]}`);
+                        }
+                    }
+                    else {
+                        logger_1.logger.info(`  ${k} : ${typeof typedConnection[k]} := ${typedConnection[k]}`);
+                    }
+                }
+                return typedConnection;
+            });
+        }
+        updateProperty(dataPoolId, connectionId, property, value) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const connection = yield data_pool_api_1.dataPoolApi.getConnection(dataPoolId, connectionId);
+                const type = connection.type;
+                const typedConnection = yield data_pool_api_1.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_1.logger.error(`Property ${property} not found on connection.`);
+                        return;
+                    }
+                }
+                yield data_pool_api_1.dataPoolApi.updateTypedConnection(dataPoolId, connectionId, type, typedConnection);
+                logger_1.logger.info(`Property ${property} updated.`);
+            });
+        }
+    }
+    exports.connectionService = new ConnectionService();
+});

package/services/package-manager/variable-service.js

@@ -13,13 +13,17 @@ 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", "../../api/package-api", "../../api/variables-api"], factory);
+        define(["require", "exports", "../../api/package-api", "../../api/variables-api", "uuid", "../../util/logger", "../file-service", "url"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const package_api_1 = require("../../api/package-api");
     const variables_api_1 = require("../../api/variables-api");
+    const uuid_1 = require("uuid");
+    const logger_1 = require("../../util/logger");
+    const file_service_1 = require("../file-service");
+    const url_1 = require("url");
     class VariableService {
         getVariableAssignmentsForNodes(type) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -31,6 +35,39 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 yield variables_api_1.variablesApi.assignVariableValues(packageKey, variablesAssignments);
             });
         }
+        listCandidateAssignments(type, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const parsedParams = this.parseParams(params);
+                const assignments = yield variables_api_1.variablesApi.getCandidateAssignments(type, parsedParams);
+                assignments.forEach(assignment => {
+                    logger_1.logger.info(JSON.stringify(assignment));
+                });
+            });
+        }
+        findAndExportCandidateAssignments(type, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const parsedParams = this.parseParams(params);
+                const assignments = yield variables_api_1.variablesApi.getCandidateAssignments(type, parsedParams);
+                const filename = uuid_1.v4() + ".json";
+                file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(assignments), filename);
+                logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+            });
+        }
+        parseParams(params) {
+            const queryParams = new url_1.URLSearchParams();
+            if (params) {
+                try {
+                    params.split(",").forEach((param) => {
+                        const paramKeyValuePair = param.split("=");
+                        queryParams.set(paramKeyValuePair[0], paramKeyValuePair[1]);
+                    });
+                }
+                catch (e) {
+                    throw new logger_1.FatalError(`Problem parsing query params: ${e}`);
+                }
+            }
+            return queryParams;
+        }
     }
     exports.variableService = new VariableService();
 });