@contrail/cli 1.0.39 → 1.0.41

package/lib/types/parse-types.js

@@ -1,4 +1,4 @@
-import { GetSuggestedTypes, GetTypesFromTemplate } from '@contrail/types';
+import { GetSuggestedTypes, GetTypesFromTemplate, GetTypesFromTemplateWithOptionSetsFromData } from '@contrail/types';
 import chalk from 'chalk';
 import fs from 'fs';
 import { getSeparatorByPlatform } from '../common';
@@ -62,6 +62,25 @@ export async function ParseTypesFromTemplateFromLocalFiles(args) {
     }
     console.log('%s Parsing Complete.', chalk.green.bold('COMPLETE'));
 }
+export async function ParseTypesFromTemplateAndDataFromLocalFiles(args) {
+    try {
+        if ((args === null || args === void 0 ? void 0 : args.length) < 5) {
+            throw new Error('File names must be included.');
+        }
+        console.log('%s Parsing', chalk.yellow.bold('TYPES AND OPTION SETS'));
+        const templateFileLocation = args[3];
+        const dataFileLocations = args.slice(4);
+        console.log('Using Template File Location: ', templateFileLocation);
+        console.log('Using Data File Location: ', dataFileLocations);
+        await parseTypesFromTemplateAndDataFromLocalFiles(templateFileLocation, dataFileLocations);
+        console.log('%s Parsed', chalk.yellow.bold('TYPES AND OPTION SETS'));
+    }
+    catch (e) {
+        console.log(`%s Parsing Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Parsing Complete.', chalk.green.bold('COMPLETE'));
+}
 async function loadDataFromLocalCSV(fileName) {
     const CURRENT_DIR = process.cwd();
     try {
@@ -113,6 +132,34 @@ async function parseTypesFromTemplateFromLocalFiles(templateFileLocation, dataFi
     saveData({ optionSets: types.OptionSets }, 'parsed_optionSets.yml');
     saveData({ TypePropertiesByEntity: types.TypePropertiesByEntity }, 'parsed_TypePropertiesByEntity.yml');
 }
+async function parseTypesFromTemplateAndDataFromLocalFiles(templateFileLocation, dataFileLocations) {
+    let templateCSVData = [];
+    try {
+        console.log('Getting template from fileLocation: ', templateFileLocation);
+        templateCSVData = await loadDataFromLocalCSV(templateFileLocation);
+        console.log(`CSV import was successful. ${templateCSVData === null || templateCSVData === void 0 ? void 0 : templateCSVData.length} rows found.`);
+    }
+    catch (e) {
+        console.log('Error importing csv data.', e);
+        throw e;
+    }
+    const dataCSVData = [];
+    for (const dataFileLocation of dataFileLocations) {
+        try {
+            console.log('Getting data for dataFileLocation: ', dataFileLocation);
+            const csvData = await loadDataFromLocalCSV(dataFileLocation);
+            console.log(`CSV import was successful. ${csvData === null || csvData === void 0 ? void 0 : csvData.length} rows found. Adding to total rows.`);
+            dataCSVData.push(...csvData);
+        }
+        catch (e) {
+            console.log('Error importing csv data.', e);
+            throw e;
+        }
+    }
+    const types = GetTypesFromTemplateWithOptionSetsFromData(templateCSVData, dataCSVData);
+    saveData({ optionSets: types.OptionSets }, 'parsed_optionSets.yml');
+    saveData({ TypePropertiesByEntity: types.TypePropertiesByEntity }, 'parsed_TypePropertiesByEntity.yml');
+}
 async function parseTypesFromFiles(fileIds) {
     await authUser();
     // get csv data

package/lib/workflow-template-definitions/workflow-template-definition-commands.d.ts

@@ -0,0 +1,2 @@
+export declare function cliInstallWorkflowTemplateDefinitions(): Promise<void>;
+export declare function listWorkflowTemplateDefinitions(): Promise<void>;

package/lib/workflow-template-definitions/workflow-template-definition-commands.js

@@ -0,0 +1,10 @@
+import { authUser } from '../auth/login';
+import { WorkflowTemplateDefinitionDeployer } from './workflow-template-definition-deployer';
+export async function cliInstallWorkflowTemplateDefinitions() {
+    await authUser();
+    await new WorkflowTemplateDefinitionDeployer().cliInstallWorkflowTemplateDefinitions();
+}
+export async function listWorkflowTemplateDefinitions() {
+    await authUser();
+    await new WorkflowTemplateDefinitionDeployer().listWorkflowTemplateDefinitions();
+}

package/lib/workflow-template-definitions/workflow-template-definition-deployer.d.ts

@@ -0,0 +1,12 @@
+import { App, AppDeclaration, WorkflowDefinition, WorkflowTemplate } from '../interfaces';
+export declare class WorkflowTemplateDefinitionDeployer {
+    cliInstallWorkflowTemplateDefinitions(): Promise<void>;
+    installWorkflowTemplateDefinitions(workflowTemplateDefinitions: WorkflowTemplate[]): Promise<void>;
+    listWorkflowTemplateDefinitions(): Promise<void>;
+    deployWorkflowTemplateDefinitions(appDeclaration: AppDeclaration, app: App): Promise<void>;
+    deployWorkflow(workflowKey: string, workflow: WorkflowDefinition, app: App, existingWorkflows: Array<any>): Promise<any>;
+    private createNewWorkflowDefinition;
+    private populateActionIds;
+    private updateWorkflowTemplateDefinition;
+    getWorkflowDeclarationIdentifier(actionKey: any, app: App): string;
+}

package/lib/workflow-template-definitions/workflow-template-definition-deployer.js

@@ -0,0 +1,148 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getInstalledApps, getWorkflowTemplateDefinitionsForApp } from '../api/apps';
+import { createWorkflowTemplate } from '../api/event-workflow-templates';
+import { createWorkflowTemplateDefinition, 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;
+        }
+        let 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}`));
+        }
+        answers = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'shouldInstall',
+                message: 'Confirmation: would you like to install these workflows? (yes)',
+                default: true,
+            }]);
+        if (!answers.shouldInstall) {
+            console.log('%s      Canceling installing workflows template definitions.', chalk.yellow.bold('WORKFLOW DEFINITION TEMPLATE'));
+            return;
+        }
+        await this.installWorkflowTemplateDefinitions(workflowTemplateDefinitions);
+    }
+    async installWorkflowTemplateDefinitions(workflowTemplateDefinitions) {
+        const 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 workflowTemplateDefinitions) {
+            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);
+                }
+            }
+        }
+    }
+    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;
+    }
+}

package/lib/{workflows/workflow-template-deployer.d.ts → workflow-templates/local-workflow-template-deployer.d.ts}

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

package/lib/{workflows/workflow-template-deployer.js → workflow-templates/local-workflow-template-deployer.js}

@@ -1,20 +1,16 @@
-import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
-export class WorkflowTemplateDeployer {
+import { getEventWorkflowActionDefinition } from '../api/event-workflow-action-definition';
+import { createWorkflowTemplate, deleteWorkflowTemplate, getExistingWorkflowTemplates, updateWorkflowTemplate as apiUpdateWorkflowTemplate } from '../api/event-workflow-templates';
+export class LocalWorkflowTemplateDeployer {
     async deployWorkflows(wtDeclaration) {
         // FETCH ALL WORKFLOWS FROM THE API.
-        const existingWorkflows = await this.getExistingWorkflowTemplates();
+        const existingWorkflows = await getExistingWorkflowTemplates();
         // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
         console.log('%s \tDeploying workflow templates.', chalk.yellow.bold('WORKFLOW TEMPLATES'));
         for (const workflowKey of Object.keys(wtDeclaration.workflows)) {
             await this.deployWorkflowTemplate(workflowKey, wtDeclaration.workflows[workflowKey], existingWorkflows);
         }
     }
-    async getExistingWorkflowTemplates() {
-        return await new Entities().get({
-            entityName: 'event-workflow-template'
-        });
-    }
     async deployWorkflowTemplate(workflowKey, workflow, existingWorkflows) {
         console.log(`%s \tDeploying workflow: ${workflowKey}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
         const identifier = getWorkflowTemplateIdentifier(workflowKey);
@@ -36,10 +32,7 @@ export class WorkflowTemplateDeployer {
             messageGroupId: workflowTemplate.messageGroupId,
             parallelWorkerCount: workflowTemplate.parallelWorkerCount,
         };
-        const newWorkflowTemplate = await new Entities().create({
-            entityName: 'event-workflow-template',
-            object: newObject,
-        });
+        const newWorkflowTemplate = await createWorkflowTemplate(newObject);
         console.log(`%s      Created new workflow definition: ${workflowKey}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
         return newWorkflowTemplate;
     }
@@ -74,17 +67,13 @@ export class WorkflowTemplateDeployer {
             triggerKey: workflowTemplate.triggerKey,
             workflowDefinition: workflowTemplate.workflowDefinition
         });
-        const updatedWorkflowTemplate = await new Entities().update({
-            entityName: 'event-workflow-template',
-            id: existingWorkflowTemplate.id,
-            object: updates,
-        });
+        const updatedWorkflowTemplate = await apiUpdateWorkflowTemplate({ id: existingWorkflowTemplate.id, updates });
         console.log(`%s      Updated existing workflow template: ${updatedWorkflowTemplate.identifier}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
         return updatedWorkflowTemplate;
     }
     async deleteWorkflowTemplates(wtDeclaration) {
         // FETCH ALL WORKFLOWS FROM THE API.
-        const existingWorkflows = await this.getExistingWorkflowTemplates();
+        const existingWorkflows = await getExistingWorkflowTemplates();
         // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
         console.log('%s \tDELETING workflow templates.', chalk.yellow.bold('WORKFLOW TEMPLATES'));
         for (const workflowKey of Object.keys(wtDeclaration.workflows)) {
@@ -92,7 +81,7 @@ export class WorkflowTemplateDeployer {
             const existingTemplate = existingWorkflows.find(ad => ad.identifier === identifier);
             if (existingTemplate) {
                 try {
-                    await this.deleteWorkflowTemplate(identifier);
+                    await deleteWorkflowTemplate(identifier);
                 }
                 catch (e) {
                     console.log('%s \tFAILED to delete workflow template %s.', chalk.red.bold('WORKFLOW TEMPLATES'), identifier);
@@ -103,25 +92,11 @@ export class WorkflowTemplateDeployer {
             }
         }
     }
-    async deleteWorkflowTemplate(identifier) {
-        return await new Entities().delete({
-            entityName: 'event-workflow-template',
-            id: identifier,
-        });
-    }
-    async listExistingWorkflowTemplates() {
-        const templates = await this.getExistingWorkflowTemplates();
-        console.log(templates);
-        return templates;
-    }
 }
 export function getWorkflowTemplateIdentifier(workflowKey) {
     return workflowKey;
 }
 export async function getActionByIdentifier(identifier) {
-    const result = await new Entities().get({
-        entityName: 'event-workflow-action-definition',
-        criteria: { identifier },
-    });
+    const result = await getEventWorkflowActionDefinition({ identifier });
     return result.length > 0 ? result[0] : {};
 }

package/lib/workflow-templates/workflow-template-commands.d.ts

@@ -0,0 +1,4 @@
+export declare function deleteWorkflowTemplates(): Promise<void>;
+export declare function localDeleteWorkflowTemplate(): Promise<void>;
+export declare function localDeployWorkflowTemplate(): Promise<void>;
+export declare function listWorkflowTemplate(): Promise<any>;

package/lib/{workflows/workflowCommands.js → workflow-templates/workflow-template-commands.js}

@@ -3,8 +3,13 @@ import fs from 'fs';
 import { authUser } from '../auth/login';
 import { getSeparatorByPlatform } from '../common';
 const yaml = require('js-yaml');
+import { LocalWorkflowTemplateDeployer } from './local-workflow-template-deployer';
 import { WorkflowTemplateDeployer } from './workflow-template-deployer';
-export async function deleteWorkflowTemplate() {
+export async function deleteWorkflowTemplates() {
+    await authUser();
+    await new WorkflowTemplateDeployer().deleteWorkflowTemplates();
+}
+export async function localDeleteWorkflowTemplate() {
     let wtDeclaration;
     try {
         wtDeclaration = loadTemplateConfig();
@@ -14,9 +19,9 @@ export async function deleteWorkflowTemplate() {
         return;
     }
     await authUser();
-    await new WorkflowTemplateDeployer().deleteWorkflowTemplates(wtDeclaration);
+    await new LocalWorkflowTemplateDeployer().deleteWorkflowTemplates(wtDeclaration);
 }
-export async function deployWorkflowTemplate() {
+export async function localDeployWorkflowTemplate() {
     let wtDeclaration;
     try {
         wtDeclaration = loadTemplateConfig();
@@ -26,7 +31,7 @@ export async function deployWorkflowTemplate() {
         return;
     }
     await authUser();
-    await new WorkflowTemplateDeployer().deployWorkflows(wtDeclaration);
+    await new LocalWorkflowTemplateDeployer().deployWorkflows(wtDeclaration);
 }
 export async function listWorkflowTemplate() {
     await authUser();

package/lib/workflow-templates/workflow-template-deployer.d.ts

@@ -0,0 +1,4 @@
+export declare class WorkflowTemplateDeployer {
+    deleteWorkflowTemplates(): Promise<void>;
+    listExistingWorkflowTemplates(): Promise<any>;
+}

package/lib/workflow-templates/workflow-template-deployer.js

@@ -0,0 +1,25 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { deleteWorkflowTemplate as apiDeleteWorkflowTemplate } from '../api/event-workflow-templates';
+import { getExistingWorkflowTemplates } from '../api/event-workflow-templates';
+export class WorkflowTemplateDeployer {
+    async deleteWorkflowTemplates() {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await getExistingWorkflowTemplates();
+        const answers = await inquirer.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 apiDeleteWorkflowTemplate(idToDelete);
+        }
+        console.log('%s \tDeleted workflow templates!', chalk.green.bold('WORKFLOW TEMPLATES'));
+    }
+    async listExistingWorkflowTemplates() {
+        const templates = await getExistingWorkflowTemplates();
+        console.log(templates);
+        return templates;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {
@@ -24,7 +24,7 @@
   "license": "ISC",
   "dependencies": {
     "@contrail/sdk": "^1.0.154",
-    "@contrail/types": "^2.0.72",
+    "@contrail/types": "^2.0.74",
     "@contrail/util": "^1.0.17",
     "amazon-cognito-identity-js": "^5.2.3",
     "arg": "^4.0.1",

package/src/api/apps.ts

@@ -0,0 +1,97 @@
+import { Auth } from '../auth/auth';
+import { Entities } from '@contrail/sdk';
+import { App, AppOrg, AppVersion, WorkflowDefinition } from '../interfaces';
+import { authUser } from '../auth/login';
+
+export async function getAllAvailableApps(options: { orgId: string }): Promise<App[]> {
+  const apps: App[] = [];
+  apps.push(...await new Entities().get({
+    entityName: 'app',
+    criteria: {
+      orgId: options.orgId,
+      private: true,
+    },
+  }));
+  apps.push(...await new Entities().get({
+    entityName: 'app',
+    criteria: {
+      orgId: options.orgId,
+      private: false,
+    },
+  }));
+
+  return apps;
+}
+
+export async function getWorkflowTemplateDefinitionsForApp(options: {appId: string}): Promise<WorkflowDefinition[]> {
+  return await new Entities().get({
+    entityName: 'event-workflow-template-definition',
+    criteria: {
+      ownerKey: `app:${options.appId}`
+    }
+  });
+}
+
+export async function getAppVersions(app): Promise<AppVersion[]> {
+  return await new Entities().get({
+    entityName: 'app-version',
+    criteria: {
+      appId: app.id
+    }
+  });
+}
+
+export async function upgradeAppVersion(appOrg, appVersionId): Promise<AppOrg> {
+  return await new Entities().update({
+    entityName: 'app-org',
+    id: appOrg.id,
+    object: {
+      appVersionId: appVersionId
+    }
+  });
+}
+
+export async function deleteAppOrg(appOrgId: string): Promise<AppOrg> {
+  return await new Entities().delete({
+    entityName: 'app-org',
+    id: appOrgId
+  });
+}
+
+export async function getInstalledApps(): Promise<AppOrg[]> {
+  return await new Entities().get({
+    entityName: 'app-org',
+    relations: ['app']
+  });
+}
+
+export async function installAppToOrg(app, configProperties): Promise<AppOrg> {
+  return await new Entities().create({
+    entityName: 'app-org',
+    object: {
+      appId: app.id,
+      appConfig: configProperties
+    }
+  });
+}
+
+export async function getAvailableApps(): Promise<App[]> {
+  const orgId = Auth.config.orgId;
+  const apps = [];
+  apps.push(...await new Entities().get({
+    entityName: 'app',
+    criteria: {
+      orgId,
+      private: true,
+    },
+  }));
+  apps.push(...await new Entities().get({
+    entityName: 'app',
+    criteria: {
+      orgId,
+      private: false,
+    },
+  }));
+
+  return apps;
+}

package/src/api/event-workflow-action-definition.ts

@@ -0,0 +1,8 @@
+import { Entities } from '@contrail/sdk';
+
+export async function getEventWorkflowActionDefinition(criteria: any) {
+  return await new Entities().get({
+    entityName: 'event-workflow-action-definition',
+    criteria
+  });
+}

package/src/api/event-workflow-template-definition.ts

@@ -0,0 +1,16 @@
+import { Entities } from '@contrail/sdk';
+
+export async function createWorkflowTemplateDefinition(object: any) {
+  return await new Entities().create({
+    entityName: 'event-workflow-template-definition',
+    object: object,
+  });
+}
+
+export async function updateWorkflowTemplateDefinition(options: {id: string, updates: any}) {
+  return await new Entities().update({
+    entityName: 'event-workflow-template-definition',
+    id: options.id,
+    object: options.updates,
+  });
+}

package/src/api/event-workflow-templates.ts

@@ -0,0 +1,29 @@
+import { Entities } from '@contrail/sdk';
+
+export async function getExistingWorkflowTemplates() {
+  return await new Entities().get({
+    entityName: 'event-workflow-template'
+  });
+}
+
+export async function createWorkflowTemplate(object) {
+  return await new Entities().create({
+    entityName: 'event-workflow-template',
+    object
+  });
+}
+
+export async function deleteWorkflowTemplate(id: string) {
+  return await new Entities().delete({
+    entityName: 'event-workflow-template',
+    id,
+  });
+}
+
+export async function updateWorkflowTemplate(options: { id: string, updates: any }) {
+  return await new Entities().update({
+    entityName: 'event-workflow-template',
+    id: options.id,
+    object: options.updates,
+  });
+}

package/src/apps/deploy-app/app-deployer.ts

@@ -4,7 +4,8 @@ import { Auth } from '../../auth/auth';
 import { ActionsDeployer, getActionsForApp, deleteAction } from './actions-deployer';
 import { App, AppDeclaration } from '../../interfaces';
 import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
-import { WorkflowDefinitionDeployer } from './workflow-definition-deployer';
+import { WorkflowTemplateDefinitionDeployer } from '../../workflow-template-definitions/workflow-template-definition-deployer';
+import { getAllAvailableApps } from '../../api/apps';
 
 export class AppDeployer {
   public async deploy(appDeclaration: AppDeclaration) {
@@ -17,28 +18,12 @@ export class AppDeployer {
       app = await this.updateExistingApp(appDeclaration, app);
     }
     await new ActionsDeployer().deployActions(appDeclaration, app);
-    await new WorkflowDefinitionDeployer().deployWorkflowDefinitions(appDeclaration, app);
+    await new WorkflowTemplateDefinitionDeployer().deployWorkflowTemplateDefinitions(appDeclaration, app);
   }
 
   public async getExistingApp(appDeclaration: AppDeclaration): Promise<App> {
     const orgId = Auth.config.orgId;
-    const apps = [];
-
-    apps.push(...await new Entities().get({
-      entityName: 'app',
-      criteria: {
-        orgId,
-        private: true,
-      },
-    }));
-    apps.push(...await new Entities().get({
-      entityName: 'app',
-      criteria: {
-        orgId,
-        private: false,
-      },
-    }));
-
+    const apps = await getAllAvailableApps({orgId});
     return apps.find(app => app.identifier === appDeclaration.appIdentifier);
   }