Connector Builder

webMethods.io Integration is an integration platform as a service (iPaaS) that lets you connect web apps, on-premise systems, and devices to create integrations and automate tasks.

You can create custom web connectors for webMethods.io Integration using the Connector Builder.

What is a Connector Builder App?

The Connector Builder app is a custom Node.js application that you build using a web application’s APIs. So, for example, if you have a private API or an API that is not in webMethods.io Integration yet, you can create custom webMethods.io Integration actions and triggers for those APIs. Once you have created these custom actions and triggers, you can use them like any other action on webMethods.io integration platform.

How the Connector Builder app works

Once you deploy the app on webMethods.io Integration, it is validated by webMethods.io Integration platform. If the app contains any errors, you will see a relevant error message and error details on the console. Once the app is validated successfully, it will be made available to you locally. You can then share this app with specific users or publish it to webMethods.io Integration to make it available to all the users of webMethods.io Integration. Below is the list of basic terms you should be familiar with before you start creating your first Connector Builder app:

1. Trigger: It reads data from the specified API and can be used to execute a workflow execution.
2. Action: It sends data to the specified API to perform CRUD operations.
3. Authentication: It specifies what credentials are required from the user.
4. Lookup: It searches for specific records in your system or account.

Connector Builder vs Node.js Block

Both the Connector Builder and the existing Node.js Block of webMethods.io Integration serve the same purpose; they let you create custom connectors. The major difference is that the Connector Builder works more like a programming project where you have to create your application from scratch whereas Node.js Block offers you a ready-to-use interface where you just have to enter the core logic for your application. 

However, the Node.js block lets you create only actions, while the Connector Builder lets you create actions and triggers along with the custom authentications. You can choose any one of these options that fits your requirements and start creating your apps!

Requirements

The app can be developed using any Node version between 4.x.x and 8.14.X.

If you have installed any other Node version (for example, v8.9.4.) on your system, you can choose from one the following options:

1. Switch to one of the Node versions between 4.x.x and 8.14.x using tools such as node-windows, nvmn, and run the app locally.

 - For Windows, use:

        -  nvm-windows

        -  nodist

Note: Please use default command prompt. GitBash and MINGW64 are not supported.

 - For nvm on Mac (via homebrew), use:

        - brew install nvm

        - nvm install v6.10.2

OR

2. Build app using your existing Node version (for example, v8.9.4.) and then transpile it using Babel or similar transpiler.

Installing Connector-builder Package

In order to get started with the Connector Builder, you will first need to install it on your system. To do so, run the following command:

 npm install -g @webmethodsio/wmiocli 

Once this is done, you can start building your app!

Quick Setup Guide

If you are familiar with how an iPaaS Connector Builder works, you can use the quick start guide below to start building your connectors. (For a detailed explanation of these steps, jump to Creating Local App section)

Step 1. Install the Connector Builder globally

 npm install -g @webmethodsio/wmiocli 

Step 2. Login to webMethods.io Integration

wmio login

On running this command, you will be prompted to enter your tenant URL, email ID associated with the tenant, and the tenant developer key.  Once you enter these details, you will be logged in to webMethods.io Integration.

At this point your Connector Builder is installed and ready to go!

Step 3. Create a new app with minimum required files

wmio init

You will be prompted to provide a name for the app. 

Step 4. Move into newly created directory

cd <app_name>

Step 5. Install all libraries needed for your Connector Builder app

npm install

You should now have a local working app. You can now start adding codes for your actions/triggers/lookups and authentication. 

Step 6.  Add action,trigger, and lookup

To add new action in your application, use

wmio create action <action_name>

or

wmio action <action_name>

When you execute this command, a new action folder will be created in your app’s directory with a <action_name>.js file in it. You can then add your action code in that file’s execute function and update the input and output schema based on your requirements.

To add new lookup in your application, use

wmio create lookup <lookup_name>

or

wmio lookup <lookup_name>

When you execute this command, a new lookup folder will be created in your app’s directory with a <lookup_name>.js file in it. You can then add your lookup code in that file.

To add new trigger in you application, use

wmio create trigger <trigger_name>

or

wmio trigger <trigger_name>

When you execute this command, a new trigger folder will be created in your app’s directory with a <trigger_name>.js file in it. You can add your trigger code in that file.


Note: The action/trigger/lookup name should consist of only alphanumeric characters and underscores.


Step 7.   Create authentication for actions/triggers/lookup. 

wmio auth

After this, you will be prompted to select the authentication type (basic / apikey / oauth / custom). When you select an authentication type, an authentication.js file will be created in your app’s directory. You can then add authentication logic to this authentication.js file.


Step 8. Once all codes are added, test the app. 

This is an optional step but we recommend that you perform it. The testing will be done against the mock data you have provided in your code. 

wmio test


Step 9. Deploy the app to webMethods.io Integration.

wmio deploy

Once you have deployed the app, refresh the browser window of webMethods.io Integration UI. The deployed app will be added in the Connectors panel under the Services tab and will be available for you to use locally. You can then download this app. If you want to make your app globally available, kindly contact our support team at support-wmio@softwareag.com

Note: Refer to the Help section to get more details about the Connector Builder commands

In the next section, we will understand how to create a Connector Builder app in detail.

Creating a Local App

Once you have installed the Connector Builder package, you can install the Connector Builder and set up your authentication to create a working app. It will be private and visible in your Connectors panel under the Services tab. Before we go through the steps to create a local app, let’s understand the important blocks that make the app. 

Triggers

Triggers read data from the external app and execute the related workflow in webMethods.io Integration. Learn more about triggers and how they work.

The basic structure for creating a trigger using the Connector Builder is given below. You can add your custom code in this structure to create your own triggers.

If you want to create a polling trigger refer the structure given below:

module.exports =
{
 name: "sample_trigger",
 label: "Sample Trigger",

 input:
 {
   type: 'object',
   title: 'Sample Trigger',
   description: "Short description",
   properties:
   {
     event:
     {
       type: 'string',
       enum: ['sample_trigger']
     },
      polling: {
              type: 'boolean',
              default: true,
              options: 
                     {
                       hidden: true
                     }
                },
   }
 },

 output:
 {
   "sample_trigger":
   {
     type: 'object',
     properties: {}      
   }
 },

 mock_data: {}, // add sample output data that will be used for testing

 execute: function(input, options, output)
 {
   // will be called every 5 minutes
   // your code here
 },

 activate: function(input, options, output)
 {
   // This function will be called whenever user activates the trigger/workflow. 
  // This function is useful in scenarios where you save cursor to figure out newly added/changed data in the
  // 3rd party services. You can update your cursor so that trigger won't fetch data of the period 
  // during which the trigger was deactivated.
 },

 validate: function(input, options, output)
 {
   // This function will be called when the trigger is created. 
   // This functions validates all inputs provided by the user and sends an error if any of the details (including auth) are incorrect. In case of an error, trigger server won't create the trigger.
 }

}

If you want to create a webhook trigger refer the structure given below:

module.exports =
{
 name: "sample_trigger",
 label: "Sample Trigger",

 input:
 {
   type: 'object',
   title: 'Sample Trigger',
   description: "Short description",
   properties:
   {
     event:
     {
       type: 'string',
       enum: ['sample_trigger']
     },
      polling: {
              type: 'boolean',
              default: false,
              options: 
                     {
                       hidden: true
                     }
                },
   }
 },

 output:
 {
   "sample_trigger":
   {
     type: 'object',
     properties: {}      
   }
 },

 mock_data: {}, // add sample output data that will be used for testing

 execute: function(input, options, output)
 {
   // will be called every 5 minutes
   // your code here
 },

 activate: function(input, options, output)
 {
   // This function will be called whenever user activates the trigger/workflow. 
  // This function is useful in scenarios where you save cursor to figure out newly added/changed data in the
  // 3rd party services. You can update your cursor so that trigger won't fetch data of the period 
  // during which the trigger was deactivated.
 },

 validate: function(input, options, output)
 {
   // This function will be called when the trigger is created. 
   // This functions validates all inputs provided by the user and sends an error if any of the details (including auth) are incorrect. In case of an error, trigger server won't create the trigger.
 }

}

Actions

Actions define the tasks to be performed. The basic structure for creating an action is given below. You can add your custom code in this structure to build your own actions.

module.exports =
{
 title: "sample_action",
 description: "",
 version: "v1",
 

 input:
 {
   title: 'sample_action',
   type: 'object',
   properties: {}
 },

 output:
 {
   title: 'output',
   type: 'object',
   properties: {}
 },

 execute: function(input, output)
 {
   // your code here
 }

}

Authentications

Most of the action/triggers need some sort of authentication from users to function. webMethods.io Integration provides some methods to help add authentication for your actions and triggers. These methods are listed below:

1. Basic

If your action/trigger only needs two pieces of information from the user, i.e., Email ID and Password, you can use the basic authentication method. Below is the structure that should be used for basic authentication. You can add your custom code in this structure to create your own basic authentication mechanism. View the template for basic authentication.

module.exports = 
{
  label : 'Connect to Demo',

  mock_input: {
    "username" : "myuser",
    "password" : "mypassword"
},

  validate : function (input, output)
  {
    // auth data will be available in input.auth
    // var username = input.auth.username
    // var password = input.auth.password
    // make call to third party api to validate user credentials
    // and return callback output(null, true) in case of successful validation
    // or return callback output(‘error message’) in case of unsuccessful validation
  }

}

2. OAuth

OAuth is a token-based authentication method that allows the user’s account information to be used by any external service and subsequently provide secure access, without exposing the password. For example, many websites support multiple login methods. One of the login methods you commonly see is Login via Gmail or Login via Facebook. This is an example of OAuth. Given below is the basic structure for the OAuth authentication.
webMethods.io Integration provides built-in OAuth authentication modules for a number of services. You can either use these built-in modules or can create custom OAuth authentication modules as per your requirements.

Built-in module

module.exports = {
  label : 'Connect to Twitter',
  mock_input: { access_token: ‘token’ }, //can be obtained from https://flowoauth.built.io
  oauth: 'twitter',
  input: {},
  validate : function (input, output){
    // auth data will be available in input.auth
  }
}


Custom OAuth module

You can also create custom OAuth modules to use own credentials for authentication. To do so, run the wmio auth command, select the OAuth authentication method, and then select OAuth 1 or OAuth 2 as per your requirements.

Here's the example code for creating Custom OAuth:

{
 "type": "oauth2",
 "title": "{{title}}",
 "clientId": "<client id="">",
 "clientSecret": "<client secret="">",
 "authURL": "<authorization url="">",
 "tokenURL": "<access token="" url="">",
 "preAuthProcessing": {
   // any processing or hashing of client_id, client_secret before authorization call
   // available processingFunctions uuid, basicAuth, base64, sha256 case-sensitive
 },
 "authQueryParams": {
   // Optional query params required to be in authorization request supports interpolation
 },
 "preTokenProcessing": {
   // any processing or hashing of client_id, client_secret before accessToken call
   // available processorApi uuid, basicAuth, base64, sha256 caseSensitive
   // eg:
   // headers: {
   //    'Authorization': 'Basic base64({client_id}{client_secret})'
   // }
 },
 "tokenParams": {
   "method": "",
   "headers": {},
   "data": {
     "client_id": "{client_id}",
     "client_secret": "{client_secret}",
     "redirect_uri": "{redirect_uri}",
     "grant_type": "authorization_code"
   }
 },
 "preRefreshProcessing": {
   // any processing or hashing of client_id, refresh_token before refreshToken call
 },
 "refreshParams": {
   // add additional keys required for refresh token process
   "client_id": "{client_id}",
   "client_secret": "{client_secret}",
   "redirect_uri": "{redirect_uri}",
   "grant_type": "refresh_token"
 },
 "requiredParams": [
   // Optional json schema for rendering form before authorizing
 ],
 "refreshURL": "<refresh token="" url,="" default="" to="" tokenurl="">", //<optional>
 "scope": {
   //<optional>
   "READABLE SCOPE TITLE": "SCOPE"
 },
 "validate": {
   "url": "ANY API URL TO VALIDATE TOKEN OF THIRD PARTY SERVICE",
   "headers": {
     //<optional>
     "Authorization": "Bearer {access_token}"
   },
   "query": { //<optional>
   }
 },
 "redirectURL": "{{redirectURL}}"
}

NOTE: Values within the curly braces will be interpolated during runtime.

Once you have created the custom OAuth, you would need to deploy it to webMethods.io Integration. To do so, run the following command:

 wmio oauth deploy 

3. API Key

If your action/trigger requires an API Key to authenticate the user, you can use the API Key authentication method. Users can pass the API Key as a query string parameter or via an HTTP header. Below is the basic structure for the API Key authentication. You can add your custom code in this structure to create your own API Key authentication mechanism. View the template for API Key authentication.

module.exports = 

{
  label:  'Connect to Demo',

  mock_input: 
              {
                "api_key" : "my api key"
              },

  input: {},

  validate: function (input, output)
  {
    // this function will be executed when running unit test cases and authData will 
    // be available in input.auth
  }

}

4. Custom

If your action/trigger requires extra information such as access token, client ID, client secret from the user along with the account credentials, you can use the custom authentication method. Given below is the basic structure for custom authentication. You can add your custom code in this structure to create your own custom authentication mechanism. View the template for custom authentication.

module.exports = 
{
  label : 'Connect to Test',  
  
  mock_input: {
     "username" : "myuser",
     "apikey" : "my api key",
     "pass" : "my password"
 },

  input: 
  { 
    type: "object", 
    properties: 
    {
      //input field definition
    } 
  },

  validate : function (input, output)
  {
     // auth data will be available in input.auth
    // var username = input.auth.username
   // var password = input.auth.pass
   // var apiKey = input.auth.apikey
  }

}

Lookups

Lookup helps you autofill fields with the data from your account. It retrieves a list of records associated with the specified property or account. It is important to define the lookup function in the action source code when creating the individual scaffoldings. The basic structure for creating lookup is given below. You can add your custom code in this structure to create your own lookups.

module.exports =
{
   'name':'sample_lookup',  
   'label': 'label',
   'search': 'false',
   

   'execute': function (input, options, output)
   {
     // your code goes here
   }

}


Example

Let’s see how this works in practice. Suppose you want to create a new action for Evernote service. Follow the steps given below to achieve this:

( Note: Make sure you have installed Node.js version 4.x.x or higher on your machine and you are currently in the Connector Builder directory before attempting to create an app)

Step 1. Install the Connector Builder globally

 npm install -g @webmethodsio/wmiocli 

Step 2. Configure deploy key and log in to webMethods.io Integration.

wmio login

You will be prompted to enter the tenant URL, email associated with your tenant, and tenant developer key. To retrieve tenant developer key, login to webMethods.io Integration UI and navigate to Profile icon > Settings.

5-login.png

Once you have entered these details, you will be logged in to your webMethods.io Integration account.

Your Connector Builder should be installed and ready to go at this point. Next up, we'll create our first app - Evernote.

Step 3. Create a directory for your app with the minimum required files

wmio init

You will be prompted to provide a name and description for your app which will be displayed in the Services tab.

Once you have entered these details, it will automatically download the required files for your app and will create an app directory inside the Connector Builder folder.

Step 4: Move into the newly created app directory

cd evernote

Step 5: Install all the libraries needed for your app

npm install

You should now have a working local app. You can start adding codes for your actions and triggers.

Step 6: Add new action

wmio create action <action_name>

or

wmio action <action_name>

  Example: wmio create action create_issue or wmio action create_issue

You will notice that the action scaffolding has been created in your Evernote directory and it contains the newly created javascript file, evernote-notebook-create-.js. This file already contains the basic structure you need to follow to create a new action. You can now write your custom code for the action you want to create in this file. Similarly, you can add scaffoldings and relevant codes for lookups and triggers using the

wmio create lookup

or

wmio lookup <lookup_name>

  and

wmio create trigger <trigger_name>

or

wmio trigger <trigger_name>

Step 7: Every action/trigger needs authentication. You can add authentication to your action/trigger using the following command:

wmio auth

You will be prompted to select the type of authentication method (Basic/OAuth/API Key/Custom) you want to use. Once you have selected an authentication method, an authentication.js file will be created in your app directory, in which you can add the authentication logic for your actions and/or triggers.

Step 8: Once all the codes are added, you can test your app:

wmio test

The testing will be done against the mock data you provided in the code. This is an optional step but, we recommend performing it to ensure that the code you have written is working as expected. At this stage, the directory structure of your app will look something like this:

EvernoteConnector
├── action
│ ├── v2
│ │ ├── evernote-notebook-create.js
│ │ ├── evernote-note-update.js
│ │ └── evernote-tag-create.js
│ └── v3
│ ├── evernote-notebook-getlist.js
│ ├── evernote-note-create.js
│ └── evernote-note-get.js
├── authentication.js
├── build
│ └── build.zip
├── icon
│ └── icon.png
├── index.json
├── lookup
│ ├── get_notebook_list_lookup.js
│ ├── get_note_list_lookup.js
│ └── get_stacks_lookup.js
└── package.json

Step 9: Deploy the app 

wmio deploy

Use this command to deploy your app to webMethods.io Integration. 

Note: For security reasons, we have disabled a few modules for app deployment. So, if you come across any 'access denied for module' error while deploying your app, please move the 'require' statement inside the function where you want to use it, in the package.json file.

For example, if your current package.json file structure looks something like this, 

var request = require('request');
 ...
 ...


execute: function (input, output) {
  // business logic
}

You need to change it to the following structure:

 ...
 ...

execute: function (input, output) {
  var request = require('request');
  // business logic
}

Once deployed, it’ll be automatically registered with webMethods.io Integration and will be available to you locally in the Connectors panel under the Services tab.

If you want to make this app globally available to all users, kindly contact our support team at support-wmio@softwareag.com.

Adding Custom Icon

You can also add a custom icon for your application. To do so, navigate to your application directory, and place the required icon inside the icon folder.

The custom icon should be a square up to 128x128 pixels that is less than 1MB.

Error Validations

webMethods.io Integration has implemented a number of test validations for Connector Builder. They are listed in the table given below:

NO_CONNECTORS

Error Response

Description

No connectors are created yet
INVALID_COMMAND_EXECUTION Entered command input is invalid

ILLEGAL_CHARS

Special characters are not allowed in connector/action/trigger/lookup name

UNAUTHORIZED

You are not logged in. Try using wmio login command

UNDEPLOYED_CONNECTOR

Connector is not yet deployed. Try using wmio deploy command

INVALID_COMMAND

Entered command doesn’t exist. Try using wmio help command to see the list of supported commands

HISTORY_EMPTY

History is not available

SWAGGER_IMPORT_FAILURE

Swagger version is not supported

INVALID_CONNECTOR_NAME

Special characters are not allowed in the connector name

USER_LOGGED_IN_ERROR

You are already logged in to webMethods.io Integration. Please use wmio logout command to logout, and then relogin with a different account

INVALID_EMAIL

Entered email address is invalid

INVALID_PASSWORD

Entered password is Invalid

LOGOUT_FAILURE

You are logged in to webMethods.io Integration

INVALID_SET_PARAMS

Entered command is invalid. Try using wmio set lookup

EMPTY_LOOKUP_LINK_FIELDS

No fields available to link lookup

LOOKUP_NOT_FOUND

No lookup found in your current application

VERSION_FAILURE

No connector is registered yet. Use wmio deploy command to deploy your connector

INVALID_AUTH

Error validating authentication

NO_AUTH_FILE

Authentication file is missing

CONNECTOR_VERSION_NOT_FOUND

Current application doesn’t have any version

CONNECTOR_VERSION_ERROR

Connector version must be greater than the currently deployed version

LOOKUP_EXIST_ERROR

Lookup module already exists

INVALID_TRIGGER

Invalid trigger entry found in the index

INVALID_OAUTH_PARAM

Invalid command parameter. Try using wmio oauth deploy   

OAUTH_MANDATORY_FIELD

Missing mandatory field in the oauth.json file

OAUTH_EMPTY_FIELD

Oauth field must have at least one property

OAUTH_FILE_ERROR

Unable to find oauth.json in your application directory

OAUTH_PARSE_ERROR

Failed to parse oauth.json

OAUTH_SCOPE_FAIL

Scope property should be an object

LOOKUP_ATTACH_ERROR

Select at least one component to attach lookup

LOOKUP_ENTRY_EXIST

Lookup entry already exists for the specified field

LOOKUP_DEPENDENCY

Lookup needs dependencies of other input fields

NO_FIELDS

No fields found

DETACH_ERROR

No lookup found to detach

DETACH_ACTION_FAIL

No actions to detach skipping

DETACH_TRIGGER_FAIL

No triggers to detach skipping

LOOKUP_ENTRY_NOT_EXIST

No entry exists for selected lookup

NAME_TOO_SHORTName for {{type}} {{name}} is too short
POSTMAN_FILE_ERRORFile {{file}} not found
INVALID_EXPORTInvalid Postman collection export file
POSTMAN_PARSE_ERRORFailed to parse JSON
POSTMAN_SCHEMA_ERRORNo schema definition found in exported json
POSTMAN_SUCCESSImported {{total}} actions successfully
POLLING_PROMPTIs your trigger polling
VERSION_PROMPTProvide version for your {{type}} {{name}}
VERSION_ERRORVersion should begin with prefix `v` eg: v1 got {{version}}
OAUTH_REQUIRED_INVALIDRequired field should be a plain js object eg: { title: 'Domain', id: 'domain', description: 'abc', default: 'mydomain'}
ENCRYPT_OAUTHEncrypting ...
INVALID_HOSTInvalid Tenant Url
OAUTH_PREPROCESS_INVALIDPre-processing hook {hook} params should be plain object

Downloading your App

Once you have deployed the app, you can download its ZIP file in your current directory. To do so, use this command:

wmio download

When you run this command, a drop down list will appear on the screen from which you can select the app you wish to download.

App Versioning

Each time you update your app, a new version is created. You can get a list of all the versions of your app using this command:

wmio versions

Deleting the Deployed Action or Trigger

If you want to delete any deployed action or trigger, you can do so by following the steps below:

Step 1: Download the app that contains the action or trigger you want to delete.
Step 2: Unzip the downloaded file.
Step 3: Delete the file associated with the action/trigger from the action/trigger folder and delete the name of the action/trigger from the index.json file.
Step 4: Deploy the app using wmio deploy command.

This will remove the specified action/trigger from your app.

Unpublishing the App

When you deploy an app, all the actions and triggers associated with it are by default published. 

In order to unpublish the published app, use the following command:

wmio unpublish

This will also unpublish any triggers and actions associated with the app.

Creating Custom Connectors using Postman Collections

Collections in the Postman tool, house a set of similar API requests as a group. These existing collections or set of APIs can be used to create custom connectors through the Connector Builder. 

To do so, follow the steps given below:

Step 1: Go to your Postman tool and navigate to the Collections section.

15-collection-list.jpg

You will see the list of existing collections. 


Step 2: Locate the collection for which you want to create custom actions. Click on the ellipsis icon (three tiny dots) given beside its name and click on Export.

16-export.jpg

Step 3: You will be prompted to specify the collection version.

17-collection-version.jpg

Step 4: Specify the location where you want to save the exported collection. 

Note: It is recommended that you save the collection inside the app directory for ease of use.

2-dir-struct.png

Step 5: Open the command prompt, navigate to your app directory and enter the following command:

wmio postman <collection_file_name.json>

3-console.png

This will create an action file for each API call included in the specified collection.

You can then redeploy your app to start using these apps like any other connector in the Connectors panel.

4-open-dir.png

Getting User Info

To get the information about the currently logged in user, use the following command:

wmio whoami

Help

To get the list of all the webMethods.io Integration-CLI commands along with their details, run the following in the command prompt:

wmio help

or

wmio
7_help-updated.png


Given below is the list of all Connector Builder commands:

1. wmio login
Configures the deploy key and logs you into webMethods.io Integration

2. wmio logout
Logs you out from webMethods.io Integration by deleting your access token from the home directory.

3. wmio connectors
Displays the list of all apps for the current user

4. wmio init
Initializes a new webMethods.io Integration app in your directory. 
Example: wmio init sample_app

5. wmio create action <action_name> or wmio action <action_name>
Creates a scaffolding for an action in app directory
Example: wmio create action create_issue or wmio action create_issue 

6. wmio create trigger <trigger_name> or wmio trigger <trigger_name>
Creates a scaffolding for a trigger in app directory
Example: wmio create trigger new_mail or wmio trigger new_mail

7. wmio create lookup <lookup_name> or wmio lookup <lookup_name>
Creates a scaffolding for a lookup in app directory
Example: wmio create lookup issue_id or wmio lookup issue_id

8. wmio auth
Creates an authentication scaffolding in the app directory

9. wmio attach lookup
Attaches lookup to action or trigger field interactively

10. wmio detach lookup
Detaches lookup from action or trigger field interactively

11. wmio deploy
Builds app and deploys it to webMethods.io Integration
Connector builder will update your existing version app unless you specifically change or increase version before re-deploying it.

12. wmio download 
Downloads the ZIP file for your app to your current directory

13. wmio versions
Displays the list of all versions for the current app

14. wmio history
Displays the complete history of the current app

15. wmio swagger <swagger_file>
Converts a Swagger to an action

16. wmio unpublish
Unpublishes the app (and its associated actions and triggers)

17. wmio whoami
Displays info of the currently logged-in user

18. wmio help or wmio
Displays the list of all Connector Builder commands along with their details

19. wmio postman <collection_file_name>
Creates an action file under the action folder of your app directory for each API call