@contrail/cli 1.0.71 → 2.0.1

package/{lib → dist/helpers}/workflow-template-definitions/workflow-template-definition-deployer.js

@@ -1,151 +1,156 @@
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { getInstalledApps, getWorkflowTemplateDefinitionsForApp } from '../api/apps';
-import { createWorkflowTemplate } from '../api/event-workflow-templates';
-import { createWorkflowTemplateDefinition, deleteWorkflowTemplateDefinition, updateWorkflowTemplateDefinition as apiUpdateWorkflowTemplateDefinition } from '../api/event-workflow-template-definition';
-import { getActionDeclarationIdentifier, getActionsForApp } from '../apps/deploy-app/actions-deployer';
-export class WorkflowTemplateDefinitionDeployer {
-    async cliInstallWorkflowTemplateDefinitions() {
-        const installedApps = await getInstalledApps();
-        if (!installedApps.length) {
-            console.log('%s \nNo apps are currently installed. You must install an app before installing its associated workflow template definitions.', chalk.red.bold('WORKFLOW DEFINITION'));
-            return;
-        }
-        const answers = await inquirer.prompt([{
-                type: 'list',
-                name: 'appIdentifier',
-                message: 'Which app\'s workflow would you like to install?',
-                choices: installedApps.map(x => x.app.identifier)
-            }]);
-        const app = installedApps.find(x => x.app.identifier === answers.appIdentifier).app;
-        const workflowTemplateDefinitions = await getWorkflowTemplateDefinitionsForApp({ appId: app.id });
-        for (const definition of workflowTemplateDefinitions) {
-            console.log(chalk.yellow.bold(`- ${definition.name}`));
-        }
-        await this.installWorkflowTemplateDefinitions(workflowTemplateDefinitions);
-    }
-    async installWorkflowTemplateDefinitions(workflowTemplateDefinitions) {
-        let answers = await inquirer.prompt([{
-                type: 'checkbox',
-                name: 'workflowTemplateDefinitionsToInstall',
-                message: 'Which workflow templates would you like to install?',
-                choices: workflowTemplateDefinitions.map(x => { return { value: x.identifier, name: x.name }; }),
-            }]);
-        const workflowTemplateDefinitionsToInstall = workflowTemplateDefinitions.filter(x => answers.workflowTemplateDefinitionsToInstall.includes(x.identifier));
-        answers = await inquirer.prompt([{
-                type: 'confirm',
-                name: 'makeActive',
-                message: 'Should the workflows be active ?(yes)',
-                default: true,
-            }]);
-        const makeActive = answers.makeActive;
-        for (const definition of workflowTemplateDefinitionsToInstall) {
-            const newObject = {
-                name: definition.name,
-                triggerKey: definition.triggerKey,
-                workflowDefinition: definition.workflowDefinition,
-                isActive: makeActive,
-                supportingAppId: definition.supportingAppId,
-            };
-            await createWorkflowTemplate(newObject);
-        }
-        console.log('%s \nInstalled workflows', chalk.green.bold('WORKFLOW DEFINITION'));
-    }
-    async listWorkflowTemplateDefinitions() {
-        const installedApps = await getInstalledApps();
-        const workflowTemplateDefinitions = [];
-        for (const appOrg of installedApps) {
-            workflowTemplateDefinitions.push(...await (await getWorkflowTemplateDefinitionsForApp({ appId: appOrg.appId })).map(x => {
-                return {
-                    appName: appOrg.app.name,
-                    workflowName: x.name,
-                };
-            }));
-        }
-        console.log('(app name) workflow name');
-        console.log('------------------------');
-        console.log(chalk.green.bold(workflowTemplateDefinitions.map(x => `(${x.appName}) ${x.workflowName} `).join('\n')));
-    }
-    async deployWorkflowTemplateDefinitions(appDeclaration, app) {
-        // FETCH ALL WORKFLOWS FROM THE API.
-        const existingWorkflows = await getWorkflowTemplateDefinitionsForApp({ appId: app.id });
-        // UPSERT / DELETE BASED ON WORKFLOW IDENTIFIER
-        console.log('%s \tDeploying workflow definitions.', chalk.yellow.bold('WORKFLOW DEFINITION'));
-        if (appDeclaration.workflows) {
-            const localWorkflows = Object.keys(appDeclaration.workflows);
-            if ((localWorkflows === null || localWorkflows === void 0 ? void 0 : localWorkflows.length) > 0) {
-                for (const workflowKey of localWorkflows) {
-                    await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], app, existingWorkflows);
-                }
-            }
-            // remove old templates that were removed by the app publisher
-            const localIdentifiers = localWorkflows.map(x => this.getWorkflowDeclarationIdentifier(x, app));
-            const workflowTemplateDefinitionsToDelete = existingWorkflows.filter(x => !localIdentifiers.includes(x.identifier));
-            for (const templateToDelete of workflowTemplateDefinitionsToDelete) {
-                await deleteWorkflowTemplateDefinition(templateToDelete.id);
-            }
-        }
-    }
-    async deployWorkflow(workflowKey, workflow, app, existingWorkflows) {
-        console.log(`%s \tDeploying workflow definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-        const identifier = this.getWorkflowDeclarationIdentifier(workflowKey, app);
-        const existingDefinition = existingWorkflows.find(ad => ad.identifier === identifier);
-        if (existingDefinition) {
-            return await this.updateWorkflowTemplateDefinition(existingDefinition, workflow, app);
-        }
-        return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
-    }
-    async createNewWorkflowDefinition(workflowKey, workflowDeclaration, app) {
-        await this.populateActionIds(workflowDeclaration, app);
-        const newObject = {
-            identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
-            name: workflowDeclaration.name,
-            ownerKey: `app:${app.id}`,
-            triggerKey: workflowDeclaration.triggerKey,
-            workflowDefinition: workflowDeclaration.workflowDefinition,
-            public: workflowDeclaration.public,
-            isActive: workflowDeclaration.isActive,
-            messageGroupId: workflowDeclaration.messageGroupId,
-            parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
-        };
-        const workflowTemplate = await createWorkflowTemplateDefinition(newObject);
-        console.log(`%s      Created new workflow definition definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-        return workflowTemplate;
-    }
-    async populateActionIds(workflowDefinition, app) {
-        var _a;
-        const availableAppActions = await getActionsForApp(app);
-        if (!((_a = workflowDefinition.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
-            return;
-        }
-        for (const path of workflowDefinition.workflowDefinition.paths) {
-            if (!(path === null || path === void 0 ? void 0 : path.actionDefinitionConfigs)) {
-                continue;
-            }
-            for (const actionConfiguration of path.actionDefinitionConfigs) {
-                const actionKey = actionConfiguration.action;
-                const action = availableAppActions.find(action => action.identifier === getActionDeclarationIdentifier(actionKey, app));
-                if (!action) {
-                    throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDefinition.name}`);
-                }
-                actionConfiguration.id = action.id;
-            }
-        }
-    }
-    async updateWorkflowTemplateDefinition(existingWorkflowDefinition, workflowDefinition, app) {
-        await this.populateActionIds(workflowDefinition, app);
-        const updates = Object.assign(new Object(), {
-            name: workflowDefinition.name,
-            triggerKey: workflowDefinition.triggerKey,
-            workflowDefinition: workflowDefinition.workflowDefinition,
-            messageGroupId: workflowDefinition.messageGroupId,
-            parallelWorkerCount: workflowDefinition.parallelWorkerCount,
-        });
-        const updatedWorkflowDefinition = await apiUpdateWorkflowTemplateDefinition({ id: existingWorkflowDefinition.id, updates });
-        console.log(`%s      Updated existing workflow definition: ${updatedWorkflowDefinition.identifier}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-        return updatedWorkflowDefinition;
-    }
-    getWorkflowDeclarationIdentifier(actionKey, app) {
-        return app.identifier + ':' + actionKey;
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTemplateDefinitionDeployer = void 0;
+const tslib_1 = require("tslib");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const apps_1 = require("../../api/apps");
+const event_workflow_templates_1 = require("../../api/event-workflow-templates");
+const event_workflow_template_definition_1 = require("../../api/event-workflow-template-definition");
+const actions_deployer_1 = require("../app/actions-deployer");
+class WorkflowTemplateDefinitionDeployer {
+    async cliInstallWorkflowTemplateDefinitions() {
+        const installedApps = await (0, apps_1.getInstalledApps)();
+        if (!installedApps.length) {
+            console.log('%s \nNo apps are currently installed. You must install an app before installing its associated workflow template definitions.', chalk_1.default.red.bold('WORKFLOW DEFINITION'));
+            return;
+        }
+        const answers = await inquirer_1.default.prompt([{
+                type: 'list',
+                name: 'appIdentifier',
+                message: 'Which app\'s workflow would you like to install?',
+                choices: installedApps.map(x => x.app.identifier)
+            }]);
+        const app = installedApps.find(x => x.app.identifier === answers.appIdentifier).app;
+        const workflowTemplateDefinitions = await (0, apps_1.getWorkflowTemplateDefinitionsForApp)({ appId: app.id });
+        for (const definition of workflowTemplateDefinitions) {
+            console.log(chalk_1.default.yellow.bold(`- ${definition.name}`));
+        }
+        await this.installWorkflowTemplateDefinitions(workflowTemplateDefinitions);
+    }
+    async installWorkflowTemplateDefinitions(workflowTemplateDefinitions) {
+        let answers = await inquirer_1.default.prompt([{
+                type: 'checkbox',
+                name: 'workflowTemplateDefinitionsToInstall',
+                message: 'Which workflow templates would you like to install?',
+                choices: workflowTemplateDefinitions.map(x => { return { value: x.identifier, name: x.name }; }),
+            }]);
+        const workflowTemplateDefinitionsToInstall = workflowTemplateDefinitions.filter(x => answers.workflowTemplateDefinitionsToInstall.includes(x.identifier));
+        answers = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'makeActive',
+                message: 'Should the workflows be active ?(yes)',
+                default: true,
+            }]);
+        const makeActive = answers.makeActive;
+        for (const definition of workflowTemplateDefinitionsToInstall) {
+            const newObject = {
+                name: definition.name,
+                triggerKey: definition.triggerKey,
+                workflowDefinition: definition.workflowDefinition,
+                isActive: makeActive,
+                supportingAppId: definition.supportingAppId,
+            };
+            await (0, event_workflow_templates_1.createWorkflowTemplate)(newObject);
+        }
+        console.log('%s \nInstalled workflows', chalk_1.default.green.bold('WORKFLOW DEFINITION'));
+    }
+    async listWorkflowTemplateDefinitions() {
+        const installedApps = await (0, apps_1.getInstalledApps)();
+        const workflowTemplateDefinitions = [];
+        for (const appOrg of installedApps) {
+            workflowTemplateDefinitions.push(...await (await (0, apps_1.getWorkflowTemplateDefinitionsForApp)({ appId: appOrg.appId })).map(x => {
+                return {
+                    appName: appOrg.app.name,
+                    workflowName: x.name,
+                };
+            }));
+        }
+        console.log('(app name) workflow name');
+        console.log('------------------------');
+        console.log(chalk_1.default.green.bold(workflowTemplateDefinitions.map(x => `(${x.appName}) ${x.workflowName} `).join('\n')));
+    }
+    async deployWorkflowTemplateDefinitions(appDeclaration, app) {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await (0, apps_1.getWorkflowTemplateDefinitionsForApp)({ appId: app.id });
+        // UPSERT / DELETE BASED ON WORKFLOW IDENTIFIER
+        console.log('%s \tDeploying workflow definitions.', chalk_1.default.yellow.bold('WORKFLOW DEFINITION'));
+        if (appDeclaration.workflows) {
+            const localWorkflows = Object.keys(appDeclaration.workflows);
+            if ((localWorkflows === null || localWorkflows === void 0 ? void 0 : localWorkflows.length) > 0) {
+                for (const workflowKey of localWorkflows) {
+                    await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], app, existingWorkflows);
+                }
+            }
+            // remove old templates that were removed by the app publisher
+            const localIdentifiers = localWorkflows.map(x => this.getWorkflowDeclarationIdentifier(x, app));
+            const workflowTemplateDefinitionsToDelete = existingWorkflows.filter(x => !localIdentifiers.includes(x.identifier));
+            for (const templateToDelete of workflowTemplateDefinitionsToDelete) {
+                await (0, event_workflow_template_definition_1.deleteWorkflowTemplateDefinition)(templateToDelete.id);
+            }
+        }
+    }
+    async deployWorkflow(workflowKey, workflow, app, existingWorkflows) {
+        console.log(`%s \tDeploying workflow definitions: ${workflowKey}`, chalk_1.default.yellow.bold('WORKFLOW DEFINITION'));
+        const identifier = this.getWorkflowDeclarationIdentifier(workflowKey, app);
+        const existingDefinition = existingWorkflows.find(ad => ad.identifier === identifier);
+        if (existingDefinition) {
+            return await this.updateWorkflowTemplateDefinition(existingDefinition, workflow, app);
+        }
+        return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
+    }
+    async createNewWorkflowDefinition(workflowKey, workflowDeclaration, app) {
+        await this.populateActionIds(workflowDeclaration, app);
+        const newObject = {
+            identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
+            name: workflowDeclaration.name,
+            ownerKey: `app:${app.id}`,
+            triggerKey: workflowDeclaration.triggerKey,
+            workflowDefinition: workflowDeclaration.workflowDefinition,
+            public: workflowDeclaration.public,
+            isActive: workflowDeclaration.isActive,
+            messageGroupId: workflowDeclaration.messageGroupId,
+            parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
+        };
+        const workflowTemplate = await (0, event_workflow_template_definition_1.createWorkflowTemplateDefinition)(newObject);
+        console.log(`%s      Created new workflow definition definitions: ${workflowKey}`, chalk_1.default.yellow.bold('WORKFLOW DEFINITION'));
+        return workflowTemplate;
+    }
+    async populateActionIds(workflowDefinition, app) {
+        var _a;
+        const availableAppActions = await (0, actions_deployer_1.getActionsForApp)(app);
+        if (!((_a = workflowDefinition.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
+            return;
+        }
+        for (const path of workflowDefinition.workflowDefinition.paths) {
+            if (!(path === null || path === void 0 ? void 0 : path.actionDefinitionConfigs)) {
+                continue;
+            }
+            for (const actionConfiguration of path.actionDefinitionConfigs) {
+                const actionKey = actionConfiguration.action;
+                const action = availableAppActions.find(action => action.identifier === (0, actions_deployer_1.getActionDeclarationIdentifier)(actionKey, app));
+                if (!action) {
+                    throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDefinition.name}`);
+                }
+                actionConfiguration.id = action.id;
+            }
+        }
+    }
+    async updateWorkflowTemplateDefinition(existingWorkflowDefinition, workflowDefinition, app) {
+        await this.populateActionIds(workflowDefinition, app);
+        const updates = Object.assign(new Object(), {
+            name: workflowDefinition.name,
+            triggerKey: workflowDefinition.triggerKey,
+            workflowDefinition: workflowDefinition.workflowDefinition,
+            messageGroupId: workflowDefinition.messageGroupId,
+            parallelWorkerCount: workflowDefinition.parallelWorkerCount,
+        });
+        const updatedWorkflowDefinition = await (0, event_workflow_template_definition_1.updateWorkflowTemplateDefinition)({ id: existingWorkflowDefinition.id, updates });
+        console.log(`%s      Updated existing workflow definition: ${updatedWorkflowDefinition.identifier}`, chalk_1.default.yellow.bold('WORKFLOW DEFINITION'));
+        return updatedWorkflowDefinition;
+    }
+    getWorkflowDeclarationIdentifier(actionKey, app) {
+        return app.identifier + ':' + actionKey;
+    }
+}
+exports.WorkflowTemplateDefinitionDeployer = WorkflowTemplateDefinitionDeployer;

package/{lib/workflow-templates/local-workflow-template-deployer.d.ts → dist/helpers/workflow-templates/helper.d.ts}

@@ -1,11 +1,17 @@
-import { WorkflowTemplate, WorkflowTemplateDeclaration } from '../interfaces';
-export declare class LocalWorkflowTemplateDeployer {
-    deployWorkflows(wtDeclaration: WorkflowTemplateDeclaration): Promise<void>;
-    deployWorkflowTemplate(workflowKey: string, workflow: WorkflowTemplate, existingWorkflows: Array<any>): Promise<any>;
-    private createNewWorkflowTemplate;
-    private populateActionIds;
-    private updateWorkflowTemplate;
-    deleteWorkflowTemplates(wtDeclaration: WorkflowTemplateDeclaration): Promise<void>;
-}
-export declare function getWorkflowTemplateIdentifier(workflowKey: string): string;
-export declare function getActionByIdentifier(identifier: string): Promise<any>;
+import { WorkflowTemplate, WorkflowTemplateDeclaration } from '../../interfaces';
+export declare class LocalWorkflowTemplateDeployer {
+    deployWorkflows(wtDeclaration: WorkflowTemplateDeclaration): Promise<void>;
+    deployWorkflowTemplate(workflowKey: string, workflow: WorkflowTemplate, existingWorkflows: Array<any>): Promise<any>;
+    private createNewWorkflowTemplate;
+    private populateActionIds;
+    private updateWorkflowTemplate;
+    deleteWorkflowTemplates(wtDeclaration: WorkflowTemplateDeclaration): Promise<void>;
+}
+export declare function getWorkflowTemplateIdentifier(workflowKey: string): string;
+export declare function getActionByIdentifier(identifier: string): Promise<any>;
+export declare class WorkflowTemplateDeployer {
+    deleteWorkflowTemplates(): Promise<void>;
+    listExistingWorkflowTemplates(): Promise<void>;
+}
+export declare function deleteWorkflowTemplates(): Promise<void>;
+export declare function localDeployWorkflowTemplate(saveFileLocation: string): Promise<void>;

package/dist/helpers/workflow-templates/helper.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localDeployWorkflowTemplate = exports.deleteWorkflowTemplates = exports.WorkflowTemplateDeployer = exports.getActionByIdentifier = exports.getWorkflowTemplateIdentifier = exports.LocalWorkflowTemplateDeployer = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const event_workflow_action_definition_1 = require("../../api/event-workflow-action-definition");
+const event_workflow_templates_1 = require("../../api/event-workflow-templates");
+const login_1 = require("../../auth/login");
+const yaml = require('js-yaml');
+class LocalWorkflowTemplateDeployer {
+    async deployWorkflows(wtDeclaration) {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await (0, event_workflow_templates_1.getExistingWorkflowTemplates)();
+        // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
+        console.log('%s \tDeploying workflow templates.', chalk_1.default.yellow.bold('WORKFLOW TEMPLATES'));
+        for (const workflowKey of Object.keys(wtDeclaration.workflows)) {
+            await this.deployWorkflowTemplate(workflowKey, wtDeclaration.workflows[workflowKey], existingWorkflows);
+        }
+    }
+    async deployWorkflowTemplate(workflowKey, workflow, existingWorkflows) {
+        console.log(`%s \tDeploying workflow: ${workflowKey}`, chalk_1.default.yellow.bold('WORKFLOW TEMPLATES'));
+        const identifier = getWorkflowTemplateIdentifier(workflowKey);
+        const existingTemplate = existingWorkflows.find(ad => ad.identifier === identifier);
+        if (existingTemplate) {
+            return await this.updateWorkflowTemplate(workflowKey, existingTemplate, workflow);
+        }
+        return await this.createNewWorkflowTemplate(workflowKey, workflow);
+    }
+    async createNewWorkflowTemplate(workflowKey, workflowTemplate) {
+        await this.populateActionIds(workflowTemplate, workflowKey);
+        const newObject = {
+            identifier: getWorkflowTemplateIdentifier(workflowKey),
+            name: workflowTemplate.name,
+            triggerKey: workflowTemplate.triggerKey,
+            workflowDefinition: workflowTemplate.workflowDefinition,
+            isActive: workflowTemplate.isActive,
+            supportingAppId: workflowTemplate.supportingAppId,
+            messageGroupId: workflowTemplate.messageGroupId,
+            parallelWorkerCount: workflowTemplate.parallelWorkerCount,
+        };
+        const newWorkflowTemplate = await (0, event_workflow_templates_1.createWorkflowTemplate)(newObject);
+        console.log(`%s      Created new workflow definition: ${workflowKey}`, chalk_1.default.yellow.bold('WORKFLOW TEMPLATES'));
+        return newWorkflowTemplate;
+    }
+    async populateActionIds(workflowTemplate, workflowKey) {
+        var _a;
+        if (!((_a = workflowTemplate === null || workflowTemplate === void 0 ? void 0 : workflowTemplate.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
+            return;
+        }
+        for (const path of workflowTemplate.workflowDefinition.paths) {
+            if (!(path === null || path === void 0 ? void 0 : path.actionDefinitionConfigs)) {
+                continue;
+            }
+            for (const actionConfiguration of path.actionDefinitionConfigs) {
+                const actionKey = actionConfiguration.action;
+                try {
+                    const actionEntity = await getActionByIdentifier(actionKey);
+                    actionConfiguration.id = actionEntity.id;
+                }
+                catch (e) {
+                    console.log(e);
+                }
+                if (!actionConfiguration.id) {
+                    throw new Error(`Could not find action ${actionKey} declared in ${workflowKey}`);
+                }
+            }
+        }
+    }
+    async updateWorkflowTemplate(workflowKey, existingWorkflowTemplate, workflowTemplate) {
+        await this.populateActionIds(workflowTemplate, workflowKey);
+        const updates = Object.assign(new Object(), {
+            name: workflowTemplate.name,
+            triggerKey: workflowTemplate.triggerKey,
+            workflowDefinition: workflowTemplate.workflowDefinition
+        });
+        const updatedWorkflowTemplate = await (0, event_workflow_templates_1.updateWorkflowTemplate)({ id: existingWorkflowTemplate.id, updates });
+        console.log(`%s      Updated existing workflow template: ${updatedWorkflowTemplate.identifier}`, chalk_1.default.yellow.bold('WORKFLOW TEMPLATES'));
+        return updatedWorkflowTemplate;
+    }
+    async deleteWorkflowTemplates(wtDeclaration) {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await (0, event_workflow_templates_1.getExistingWorkflowTemplates)();
+        // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
+        console.log('%s \tDELETING workflow templates.', chalk_1.default.yellow.bold('WORKFLOW TEMPLATES'));
+        for (const workflowKey of Object.keys(wtDeclaration.workflows)) {
+            const identifier = getWorkflowTemplateIdentifier(workflowKey);
+            const existingTemplate = existingWorkflows.find(ad => ad.identifier === identifier);
+            if (existingTemplate) {
+                try {
+                    await (0, event_workflow_templates_1.deleteWorkflowTemplate)(identifier);
+                }
+                catch (e) {
+                    console.log('%s \tFAILED to delete workflow template %s.', chalk_1.default.red.bold('WORKFLOW TEMPLATES'), identifier);
+                }
+            }
+            else {
+                console.log('%s \tUnable to locate workflow template %s.', chalk_1.default.yellow.bold('WORKFLOW TEMPLATES'), identifier);
+            }
+        }
+    }
+}
+exports.LocalWorkflowTemplateDeployer = LocalWorkflowTemplateDeployer;
+function getWorkflowTemplateIdentifier(workflowKey) {
+    return workflowKey;
+}
+exports.getWorkflowTemplateIdentifier = getWorkflowTemplateIdentifier;
+async function getActionByIdentifier(identifier) {
+    const result = await (0, event_workflow_action_definition_1.getEventWorkflowActionDefinition)({ identifier });
+    return result.length > 0 ? result[0] : {};
+}
+exports.getActionByIdentifier = getActionByIdentifier;
+class WorkflowTemplateDeployer {
+    async deleteWorkflowTemplates() {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await (0, event_workflow_templates_1.getExistingWorkflowTemplates)();
+        const answers = await inquirer_1.default.prompt([{
+                type: 'checkbox',
+                name: 'wfTemplatesToDelete',
+                message: 'Which templates would you like to delete (one or more)?',
+                choices: existingWorkflows.map(x => { return { value: x.id, name: `(${x.createdOn}) ${x.name}` }; })
+            }]);
+        for (const idToDelete of answers.wfTemplatesToDelete) {
+            await (0, event_workflow_templates_1.deleteWorkflowTemplate)(idToDelete);
+        }
+        console.log('%s \tDeleted workflow templates!', chalk_1.default.green.bold('WORKFLOW TEMPLATES'));
+    }
+    async listExistingWorkflowTemplates() {
+        const templates = await (0, event_workflow_templates_1.getExistingWorkflowTemplates)();
+        console.log('(Date Created) (active) workflow name');
+        console.log('------------------------');
+        console.log(chalk_1.default.green.bold(templates.map(x => `(${x.createdOn}) (${x.isActive ? 'active' : 'inactive'}) ${x.name} `).join('\n')));
+    }
+}
+exports.WorkflowTemplateDeployer = WorkflowTemplateDeployer;
+async function deleteWorkflowTemplates() {
+    await (0, login_1.authUser)();
+    await new WorkflowTemplateDeployer().deleteWorkflowTemplates();
+}
+exports.deleteWorkflowTemplates = deleteWorkflowTemplates;
+async function localDeployWorkflowTemplate(saveFileLocation) {
+    let wtDeclaration;
+    try {
+        wtDeclaration = loadTemplateConfig(saveFileLocation);
+    }
+    catch (e) {
+        console.log(`%s Workflow Deletion Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+        return;
+    }
+    await (0, login_1.authUser)();
+    await new LocalWorkflowTemplateDeployer().deployWorkflows(wtDeclaration);
+}
+exports.localDeployWorkflowTemplate = localDeployWorkflowTemplate;
+function loadTemplateConfig(saveFile) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const doc = yaml.load(fs_1.default.readFileSync(path.resolve(path.join(TARGET_DIR, saveFile)), 'utf8'));
+        console.log(doc);
+        return doc;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });