@kumologica/sdk 3.0.0

package/package.json

@@ -0,0 +1,158 @@
+{
+  "name": "@kumologica/sdk",
+  "productName": "Kumologica Designer",
+  "copyright": "Copyright 2020 Kumologica Pty Ltd, All Rights Reserved.",
+  "author": "Kumologica Pty Ltd <contact@kumologica.com>",
+  "version": "3.0.0",
+  "description": "Kumologica Designer, harnessing Serverless for your cloud integration needs",
+  "main": "src/app/main.js",
+  "files": [
+    "src/**/*",
+    "cli/**/*"
+  ],
+  "bin": {
+    "kl": "./bin/kl.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KumologicaHQ/kumologica-designer-releases.git",
+    "option": "private"
+  },
+  "build": {
+    "directories": {
+      "buildResources": "src/assets"
+    },
+    "afterSign": "build/scripts/notarize.js",
+    "appId": "com.kumologica.designer",
+    "artifactName": "${productName}.${ext}",
+    "dmg": {
+      "sign": false
+    },
+    "mac": {
+      "target": [
+        "dmg",
+        "zip"
+      ],
+      "icon": "./src/assets/kumologica-app.icns",
+      "category": "public.app-category.developer-tools",
+      "hardenedRuntime": true,
+      "gatekeeperAssess": false,
+      "entitlements": "build/entitlements.mac.plist",
+      "entitlementsInherit": "build/entitlements.mac.plist"
+    },
+    "linux": {
+      "icon": "./src/assets/kumologica-app.png",
+      "target": [
+        "AppImage",
+        "deb"
+      ]
+    },
+    "win": {
+      "icon": "./src/assets/kumologica-app.png"
+    }
+  },
+  "scripts": {
+    "dev": "electron .",
+    "open": "grunt && electron .",
+    "open:test": "node src/cli/index open ../@kumologica-runtime/example",
+    "open:mock": "node src/cli/index open ../cloud-red-examples/echo-aws",
+    "test": "mocha 'src/**/*.spec.js'",
+    "grunt": "grunt",
+    "del-postinstall": "electron-builder install-app-deps",
+    "license-check": "npx license-checker --summary && npx license-compatibility-checker ",
+    "license-report": "npx license-report --output=table"
+  },
+  "license": "Proprietary",
+  "dependencies": {
+    "@kumologica/builder": "3.0.0",
+    "@kumologica/runtime": "3.0.0",
+    "@kumologica/devkit": "3.0.0",
+    "adm-zip": "^0.4.13",
+    "ajv": "^8.10.0",
+    "aws-sdk": "^2.513.0",
+    "basic-auth": "2.0.1",
+    "bcryptjs": "2.4.3",
+    "body-parser": "^1.19.0",
+    "chalk": "^2.4.2",
+    "child_process": "^1.0.2",
+    "clone": "2.1.2",
+    "cookie-parser": "1.4.4",
+    "cors": "^2.8.5",
+    "dagre": "^0.8.5",
+    "debounce": "^1.2.0",
+    "electron": "11.0.1",
+    "electron-updater": "4.3.9",
+    "enquirer": "^2.3.1",
+    "express": "4.17.3",
+    "express-session": "1.16.2",
+    "extract-json-from-string": "^1.0.1",
+    "fs-extra": "8.1.0",
+    "glob": "^7.1.6",
+    "got": "11.8.2",
+    "hash-sum": "2.0.0",
+    "http-shutdown": "^1.2.1",
+    "iconv-lite": "0.5.0",
+    "ini": "^2.0.0",
+    "js-yaml": "^3.13.1",
+    "jsonata": "^1.7.0",
+    "jsonpath": "^1.0.2",
+    "memorystore": "1.6.1",
+    "mime": "2.4.4",
+    "minimist": "^1.2.3",
+    "multer": "1.4.1",
+    "mustache": "3.0.1",
+    "oauth2orize": "1.11.0",
+    "os": "^0.1.1",
+    "passport": "0.4.0",
+    "passport-http-bearer": "1.0.1",
+    "passport-oauth2-client-password": "0.1.2",
+    "request": "^2.88.0",
+    "rimraf": "^3.0.0",
+    "shell-path": "^2.1.0",
+    "simplemde": "^1.11.2",
+    "smoketail": "^0.2.2",
+    "socket.io": "^2.3.0",
+    "util": "^0.12.1",
+    "when": "3.7.8",
+    "ws": "^7.1.1",
+    "xterm": "^4.1.0",
+    "xterm-addon-fit": "^0.2.1",
+    "yargs": "^17.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^12.6.8",
+    "chai": "^4.2.0",
+    "grunt": "^1.0.4",
+    "grunt-chmod": "~1.1.1",
+    "grunt-cli": "~1.3.2",
+    "grunt-concurrent": "~2.3.1",
+    "grunt-contrib-clean": "~1.1.0",
+    "grunt-contrib-compress": "~1.4.0",
+    "grunt-contrib-concat": "~1.0.1",
+    "grunt-contrib-copy": "~1.0.0",
+    "grunt-contrib-jshint": "~1.1.0",
+    "grunt-contrib-uglify-es": "github:gruntjs/grunt-contrib-uglify#harmony",
+    "grunt-contrib-watch": "~1.1.0",
+    "grunt-jsdoc": "^2.2.1",
+    "grunt-jsdoc-to-markdown": "^4.0.0",
+    "grunt-jsonlint": "~1.1.0",
+    "grunt-mkdir": "~1.0.0",
+    "grunt-mocha-istanbul": "5.0.2",
+    "grunt-nodemon": "~0.4.2",
+    "grunt-npm-command": "~0.1.2",
+    "grunt-sass": "3.1.0",
+    "grunt-simple-mocha": "~0.4.1",
+    "grunt-webdriver": "^2.0.3",
+    "istanbul": "^0.4.5",
+    "license-checker": "^25.0.1",
+    "license-compatibility-checker": "^0.3.4",
+    "license-report": "^3.0.0",
+    "mocha": "^6.2.0",
+    "node-sass": "^6.0.0",
+    "tslint": "^5.18.0",
+    "typescript": "^3.5.3"
+  },
+  "engines": {
+    "node": ">=8"
+  }
+}

package/src/app/lib/aws/aws-profile.js

@@ -0,0 +1,43 @@
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+const util = require('util');
+const exec = util.promisify(require('child_process').exec);
+
+class AWSProfile {
+  constructor() {
+    this.homedir = os.homedir();
+  }
+
+  getEnvProfile() {
+    return process.env.AWS_PROFILE;
+  }
+
+  listProfiles() {
+    const file = fs.readFileSync(path.join(this.homedir, '.aws/credentials'));
+
+    var profiles = [];
+    var lines = file.toString().split(/\r?\n/);
+
+    lines.forEach(function(line) {
+      const s = line.indexOf('[');
+      const e = line.indexOf(']');
+      if (s != -1 && e != -1) {
+        profiles.push(line.substr(s + 1, e - 1));
+      }
+    });
+
+    return profiles;
+  }
+ 
+  async getRegion(profile) {
+    const cmd = `aws configure get region --profile ${profile}`;
+    const { stdout, stderr } = await exec(cmd);
+    if (stderr) {
+      console.log('stderr:', stderr);
+    }
+    return stdout.trim();
+  }
+}
+
+module.exports = AWSProfile;

package/src/app/lib/aws/ca-alexa-api.js

@@ -0,0 +1,29 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html
+ */
+class CAAlexa {
+  
+  constructor(log) {
+    this.log = log; 
+    this.alexa = new AWS.AlexaForBusiness({region: 'us-east-1'});
+  }
+
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/AlexaForBusiness.html#listSkills-property
+   */
+  async listSkills() {
+   
+    const response = await this.alexa.listSkills({}).promise();
+
+   // {"SkillSummaries":[{"SkillId":"amzn1.ask.skill.8ac93c7f-22ec-48c7-a19d-de22baffc503","SkillName":"Writing Tips","SupportsLinking":false,"EnablementType":"ENABLED","SkillType":"PUBLIC"}]}
+
+    return response.SkillSummaries.map(function(v) {
+      return {id: v.SkillId, name: v.SkillName, arn: v.SkillName};
+    });
+  }
+}
+
+module.exports = CAAlexa;

package/src/app/lib/aws/ca-apigw-api.js

@@ -0,0 +1,216 @@
+const AWS = require('aws-sdk');
+const jp = require('jsonpath');
+
+/*
+ * Follow link:
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
+ *
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/APIGateway.html
+ */
+class CAAWSApiGateway {
+
+  constructor(log) {
+    this.log = log; 
+    this.triggerStage = "";
+    this.apigateway = new AWS.APIGateway();
+  }
+  
+  /**
+   * 
+   * @param  {} event
+   * @param  {} lambdaName
+   * @param  {} lambdaArn
+   */
+  async addTrigger(event, lambdaName, lambdaArn) {
+    try {
+      this.log(`Adding trigger to the api gateway: ${event.api} ...`);
+      
+      var api;
+      if (event.api == "Create new API") {
+        api = await this.createApi(lambdaName, lambdaName);
+        event.api = api.id;
+      }
+      const proxyId = await this.defineResource(event);
+
+      await this.defineMethod(event.api, proxyId, event.security || 'NONE', 'ANY');
+      await this.putIntegration(event.api, proxyId, 'ANY', lambdaArn);
+      await this.createDeployment(event.api, event.stage);
+
+    } catch (Error) {
+      this.log(` `, false);
+      this.log(` API Gateway Error:`, false);
+      this.log(` Unable to create trigger for api gateway: ${event.api}`, false);                
+      this.log(`    Stage:   ${this.triggerStage}`, false);
+      this.log(`    Code:    ${Error.code}`, false);
+      this.log(`    Message: ${Error.message}`, false);
+      this.log(` `, false);
+      throw Error;
+    }
+
+    if (api) {
+      return api.id;
+    }
+    return null;
+  }
+
+  async defineResource(event) {
+    const resources = await this.getResources(event);
+    const root = jp.query(resources, `items[?(@.path=='/')]`);
+    if (!root || !root.length) {
+      this.log(`Error: Unable to find root: '/' resource.`);
+      return;
+    }
+    
+    var proxyId;
+    const proxy = jp.query(resources, `items[?(@.pathPart=='{proxy+}')]`);
+    
+    if (!proxy || !proxy.length) {
+      proxyId = await this.createResource(root[0].id, '{proxy+}', event.api);
+      proxyId = proxyId.id;
+    } else {
+      proxyId = proxy[0].id;
+    }
+
+    return proxyId;
+  }
+
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/APIGateway.html#getResources-property
+   * 
+   * @param  {} event
+   */
+  async getResources(event) {
+    this.triggerStage = "Getting information about api gateway.";
+    return this.apigateway.getResources({ restApiId: event.api }).promise();
+  }
+
+  /**
+   * AWS API:
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/APIGateway.html#createResource-property
+   * 
+   * @param  {} path
+   */
+  async createResource(parentId, path, restApiId) {
+
+    this.triggerStage = `Creating api gateway resource: ${path}`;
+    var request = {
+      parentId: parentId, 
+      pathPart: path, 
+      restApiId: restApiId 
+    };
+
+    return this.apigateway.createResource(request).promise();
+  }
+  /**
+   * API Doc:
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/APIGateway.html#getMethod-property
+   * 
+   * @param  {} restApiId
+   * @param  {} resourceId
+   * @param  {} httpMethod
+   */
+  async getMethod(restApiId, resourceId, httpMethod) {
+    var request = {
+      httpMethod: httpMethod, 
+      resourceId: resourceId,
+      restApiId: restApiId
+    };
+
+    this.triggerStage = `Searching for http method: ${httpMethod} for resource: ${resourceId}`;
+
+    try {
+      const res = await this.apigateway.getMethod(request).promise();
+      return res;
+    } catch (NotFoundException) {
+      return null; 
+    }
+  }
+
+
+  /**
+   * API Doc:
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/APIGateway.html#putMethod-property
+   * 
+   * @param  {} method='ANY'
+   */
+  async defineMethod(restApiId, resourceId, authorizationType, httpMethod) {
+
+   // const method e
+    if (!await this.getMethod(restApiId, resourceId, httpMethod)) {
+      
+      var request = {
+        authorizationType: authorizationType,
+        httpMethod: httpMethod, 
+        resourceId: resourceId,
+        restApiId: restApiId
+      };
+ 
+      this.triggerStage = `Defining http method: ${httpMethod} ${resourceId}`;
+      return this.apigateway.putMethod(request).promise();
+    }
+  }
+  /**
+   * API Doc:
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/APIGateway.html#putIntegration-property
+   * 
+   * @param  {} restApiId
+   * @param  {} resourceId
+   * @param  {} authorizationType
+   * @param  {} method
+   * @param  {} lambdaArn
+   */
+  async putIntegration(restApiId, resourceId, httpMethod, lambdaArn) {
+    //arn:aws:lambda:ap-southeast-2:640233474616:function:kumologica-aws-inbound-test-flow-lambda
+    const region = lambdaArn.split(':')[3];
+
+    var request = {
+      httpMethod: httpMethod,
+      resourceId: resourceId,
+      restApiId: restApiId,
+      type: 'AWS_PROXY',       //HTTP | AWS | MOCK | HTTP_PROXY | AWS_PROXY    
+      integrationHttpMethod: 'POST',
+      uri: `arn:aws:apigateway:${region}:lambda:path/2015-03-31/functions/${lambdaArn}/invocations`
+    };
+    
+    this.triggerStage = `Creating aws proxy integration`;
+    return this.apigateway.putIntegration(request).promise();
+  }
+
+  async createDeployment(restApiId, stage) {
+    // aws apigateway create-deployment --rest-api-id te6si5ach7 --stage-name test
+
+    this.triggerStage = "Creating api gateway deployment";
+
+    var request = {
+      restApiId: restApiId,
+      stageName: stage
+    };
+  
+    return this.apigateway.createDeployment(request).promise(); 
+  }
+
+  async getApiGateways() {
+    const api = await this.apigateway.getRestApis({}).promise();
+    
+    return api.items.map(function(v) {
+      return {id: v.id, name: v.name, arn: `arn-ccc`}
+    });
+  }
+
+  async createApi(name, description) {
+    var params = {
+      name: name,
+      apiKeySource: "HEADER",
+      description: description,
+      endpointConfiguration: {
+        types: [
+          "REGIONAL"
+        ]
+      }
+    };
+    return this.apigateway.createRestApi(params).promise();  
+  }
+}
+
+module.exports = CAAWSApiGateway;

package/src/app/lib/aws/ca-cloudwatch-api.js

@@ -0,0 +1,78 @@
+const AWS = require('aws-sdk');
+
+class AWSCloudWatch {
+
+  constructor(log) {
+    this.cwLogs = new AWS.CloudWatchLogs();
+    this.logger = log; 
+  }
+
+  startCWLogs(lambdaName, region) {
+    var CWLogFilterEventStream = require('smoketail').CWLogFilterEventStream;
+    var filterOpts = {
+        logGroupName : `/aws/lambda/${lambdaName}`,
+        //logStreamNames: ['2019/10/25/[$LATEST]e78c61b4ad7e4921ad5b6e820814669d', '2019/10/25/[$LATEST]465ece1dff2d473087ec167dd6235b0d'],
+        startTime: Date.now(),
+        follow: true // The follow parameter is specific to smoketail.  If set, once 
+                    // all events are returned, the stream will be kept open an poll
+                    // CloudWatchLogs for follow-on events using the current filter
+                    // parameters.  Otherwise the 'end' event fill fire when all events
+                    // are retuned.
+    };
+
+    var awsOpts = {
+      region: region // Note this is the default if the awsOpts param is ommitted.
+    };
+
+    let log = this.logger;
+    //let term = terminal;
+  
+   /* const log = function(text) {
+      // if (term != null && term != undefined && text) {
+        console.log(`emit to term cloud: ${text}`);
+        //this.logger.log(`text: ${text}`);
+        //term.emit('terminal-cloud', text);
+    //  }
+    }*/
+
+    log(`Polling cloudwatch logs from region: ${region} and log group: /aws/lambda/${lambdaName} ...`);
+
+    var eventStream = new CWLogFilterEventStream(filterOpts, awsOpts);
+    eventStream.on('error', function(err) {
+      log(err);
+    });
+
+    eventStream.on('end', function(err) {
+      log(err);
+    });
+
+    eventStream.on('data', function(eventObject) {
+      const msg = eventObject.message.split('\n');
+      
+      for (var i=0; i<msg.length; i++) {
+        const lines = msg[i].split('\t');
+        log(`${lines[lines.length-1]}`); // only last tab since aws logs long datetime and requestid for each line
+      }
+
+      //log(`${(new Date(eventObject.timestamp)).toISOString()} ${eventObject.message}` );
+      //log(`->${eventObject.message.replace('\t', 'AAAAA')}<-` );
+      //log(`${JSON.stringify(eventObject)}` );
+    });
+
+    setTimeout(function() {
+        console.log('Closing cloud watch logs stream.');
+        log('Closing cloud watch logs stream, due to inactivity for 15 minutes.');
+        eventStream.close();  // Close method will close stream, end app if nothing else is open
+    }, 900000);
+  }
+
+  async listLogGroups() {
+    var logs = await this.cwLogs.describeLogGroups({}).promise();
+    
+    return logs.logGroups.map(function(v) { 
+      return {id: v.arn, name: v.logGroupName, arn: v.arn};
+    });
+  }
+}
+
+module.exports = AWSCloudWatch;

package/src/app/lib/aws/ca-codecommit-api.js

@@ -0,0 +1,63 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html
+ */
+class CACodeCommit {
+
+  constructor(log) {
+    this.log = log; 
+    this.codecommit = new AWS.CodeCommit();
+  }
+
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CodeCommit.html#getRepository-property
+   * 
+   * @param {*} repositoryName 
+   */
+  async getRepository(repositoryName) {
+    var params = {
+        repositoryName: `${repositoryName}`
+      };
+    const response = await this.codecommit.getRepository(params).promise();
+    return response.repositoryMetadata;
+  }
+
+  /**
+   * 
+   */
+  async listRepositories() {
+   
+    const response = await this.codecommit.listRepositories({}).promise();
+    
+    return response.repositories.map(function(v) {
+      return {id: v.repositoryName, name: v.repositoryId, arn: v.repositoryId};
+    });
+  }
+
+  async addLambdaPermissions(event, lambdaArn) {
+    var getTriggersRequest = {
+        repositoryName: `${event.repository}`
+      };
+
+    const response = await this.codecommit.getRepositoryTriggers(getTriggersRequest).promise();
+
+    var params = {
+        repositoryName:  `${event.repository}`,
+        triggers: response.triggers
+    }
+    
+    params.triggers.push({
+        destinationArn: `${lambdaArn}`,
+        events: event.events,
+        name: event.trigger,
+        branches: event.branchNames,
+        customData: event.customData
+    });
+      
+    return this.codecommit.putRepositoryTriggers(params).promise();
+  }
+}
+
+module.exports = CACodeCommit;

package/src/app/lib/aws/ca-dynamodb-api.js

@@ -0,0 +1,27 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html
+ */
+class CADynamoDb {
+  
+  constructor(log) {
+    this.log = log; 
+    this.dynamodbstreams = new AWS.DynamoDBStreams();
+  }
+
+  /**
+   * 
+   */
+  async listStreams() {
+   
+    const streams = await this.dynamodbstreams.listStreams({}).promise();
+    
+    return streams.Streams.map(function(v) {   
+      return {id: v.StreamArn, name: v.TableName, arn: v.StreamArn};
+    });
+  }
+}
+
+module.exports = CADynamoDb;

package/src/app/lib/aws/ca-elb-api.js

@@ -0,0 +1,44 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/ELB.html
+ */
+class CAElb {
+  
+  constructor(log) {
+    this.log = log; 
+    this.elbv2 = new AWS.ELBv2();
+  }
+  
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/ELBv2.html#describeLoadBalancers-property
+   */
+  async listElbs() {
+   
+    const response = await this.elbv2.describeLoadBalancers({}).promise();
+    
+    return response.LoadBalancers.map(function(v) {   
+      return {id: v.LoadBalancerName, name: v.DNSName, arn: v.DNSName};
+    });
+  }
+
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/ELBv2.html#describeListeners-property
+   * 
+   * @param {string} albName 
+   */
+  async listListeners(albName) {
+    var params = {
+        LoadBalancerArn: `'${albName}'`
+    };
+
+    const response = await this.elbv2.describeListeners(params).promise();
+    
+    return response.Listeners.map(function(v) {   
+      return {id: v.ListenerArn, name: v.Protocol + ':' + v.Port, arn: v.ListenerArn};
+    });   
+  }
+}
+
+module.exports = CAElb;

package/src/app/lib/aws/ca-events-api.js

@@ -0,0 +1,27 @@
+const AWS = require('aws-sdk');
+
+/*
+ * AWS JS API:
+ * 
+ */
+class CAEvents {
+  
+  constructor(log) {
+    this.log = log; 
+    this.cloudwatchevents = new AWS.CloudWatchEvents();
+  }
+  
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CloudWatchEvents.html#listRules-property
+   */
+  async listRules() {
+   
+    const response = await this.cloudwatchevents.listRules({}).promise();
+    
+    return response.Rules.map(function(v) {   
+      return {id: v.Arn, name: v.Name, arn: v.Arn};
+    });
+  }
+}
+
+module.exports = CAEvents;