@kumologica/sdk 3.0.0

package/src/app/lib/serverless/index.js

@@ -0,0 +1,318 @@
+const fs = require('fs-extra');
+const path = require('path');
+const AWS = require('aws-sdk');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const AWSProfile = require('../aws/aws-profile');
+const CASQS = require('../aws/ca-sqs-api');
+const { openFileOnEditor } = require('../utils/editor');
+
+/**
+ * sample events: 
+ * https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html
+ */
+class ServerlessDeployer {
+  
+  constructor(terminal) {
+    this.term = terminal;
+    this.awsProfile = new AWSProfile();
+  }
+
+  async initAWS(profile) {
+    AWS.config.credentials = new AWS.SharedIniFileCredentials({profile: profile});
+    AWS.config.profile = profile;  // this is not AWS property
+    
+    AWS.config.apiVersions = {
+      cloudformation: '2010-05-15'
+    };
+    
+    console.log('initAWS from aws...')
+    const region = await this.awsProfile.getRegion(profile);
+    
+    AWS.config.update({region: region});
+    this.sqs = new CASQS(this.log.bind(this));
+  }
+
+  log(text, calog = true) {
+    console.log(text);
+
+    var t = text;
+
+    if (calog) {
+      t = `Kumologica: ${chalk.hex('#F5DEB3')(text)}`;
+    }
+
+    if (this.term) {
+      this.term.emit('terminal-output', t);
+    }
+  }
+
+  logCloud(text) {
+    console.log(text);
+    if (this.term) {
+      this.term.emit('terminal-cloud', text);
+    }
+  }
+
+  sanitizeLambdaName(name) {
+    return name
+              .replace('.json', '')
+              .trim()
+              .replace(/^@/, '')
+              .replace(/[^a-zA-Z0-9-]/g, '-')
+              .substr(0, 140);
+  }
+
+  prepare(projectDir, flowFileName, originaLambdaName, flowDescription) {
+    const deployDir = projectDir + '/deploy';
+    const flowName = flowFileName.replace('.json', '');
+
+    const zipFileName = `${flowName}/lambda${Date.now()}.zip`;
+    const lambdaName = this.sanitizeLambdaName(originaLambdaName); 
+
+    const functionName = `${lambdaName}`;
+    const stackName = `kumologica-${lambdaName}-stack`;
+    const roleName = `kumologica-${lambdaName}-role`;
+    return {
+      deployDir,
+      flowName,
+      zipFileName,
+      functionName,
+      stackName,
+      roleName,
+      lambdaName
+    };
+  }
+
+  async generateScript(projectInfo, params, profile) {
+    if (!profile) {
+      throw new Error('AWS profile has not been provided, unable to generate serverless.yml file. Select correct profile from list.');
+    }
+
+    await this.initAWS(profile);
+
+    console.log(`AWS.config = ${JSON.stringify(AWS.config)}`);
+
+    try {
+      this.log('Generating serverless.yml file');
+      this.log(`  ${chalk.hex('#F5DEB3')('AWS profile:')}       ${chalk.whiteBright(AWS.config.profile)}`, false); 
+      this.log(`  ${chalk.hex('#F5DEB3')('AWS region:')}        ${chalk.whiteBright(AWS.config.region)}`, false);
+      
+      const settings = this.prepare(projectInfo.projectDir, projectInfo.projectFlowName, params.functionName, params.description);
+      const nodes = this.loadFlow(path.join(projectInfo.projectDir, projectInfo.projectFlowName));
+      
+      const serverlessTemplate = await this.createServerlessTemplate(params, settings, nodes, AWS.config.region);
+      this.createFile(projectInfo.projectDir, `serverless.yml`, serverlessTemplate);
+
+      const scriptFileName = path.join(projectInfo.projectDir, `serverless.yml`);
+      this.log(`serverless.yml has been created.`);
+
+      openFileOnEditor(scriptFileName);
+
+    } catch (Error) {
+      this.log(`${chalk.redBright('Script creation failed.')}`);
+      this.log(`  ${chalk.redBright(Error)}`);
+      throw Error;
+    }
+  }
+
+  async createServerlessTemplate(params, settings, nodes, region){
+    let serverlessJson = {
+        service: settings.functionName,
+
+        provider: {
+          name: "aws",
+          runtime: "nodejs12.x",
+          deploymentPrefix: "kumologica-sls"
+        },
+        functions: {},
+    
+        //custom {
+        //  kumologica: {
+        //    inferIamPolicies: true # true by default
+        
+        plugins: ["kumologica-serverless-plugin"]  
+    };
+    
+    let functionJson = {
+      events: []      
+    };
+
+    serverlessJson.functions[ `${settings.functionName}`] = functionJson;
+    if (params.xRay) {
+      serverlessJson.functions[ `${settings.functionName}`].tracing = "Active";
+    }
+    if (params.description) {
+      serverlessJson.functions[ `${settings.functionName}`].description = params.description;
+    }
+    if (params.memory) {
+      serverlessJson.functions[ `${settings.functionName}`].memorySize = params.memory;
+    }
+    if (params.timeout) {
+      serverlessJson.functions[ `${settings.functionName}`].timeout = params.timeout;
+    }
+    if (params.reservedConcurrency) {
+      serverlessJson.functions[ `${settings.functionName}`].reservedConcurrency = params.reservedConcurrency;
+    }
+    if (params.role) {
+      serverlessJson.functions[ `${settings.functionName}`].role = params.role;
+    }
+
+    if (params.environment && params.environment.length > 0) {
+      serverlessJson.functions[ `${settings.functionName}`].environment = {};
+      params.environment.forEach(function(env, index) {
+        serverlessJson.functions[ `${settings.functionName}`].environment[env.key] = env.value;
+      });
+    }
+
+    if (params.tags) {
+      params.tags.forEach(function(tag, index) {
+        serverlessJson.functions[ `${settings.functionName}`].tags[tag.key] = tag.value;
+      });
+    }
+
+      // adding api event based on settings in event listener
+    
+    if (nodes) {
+      let el = nodes.filter(n => n.type == "EventListener");
+
+      for (var i=0; i<el.length; i++) {
+        let event;
+        
+        if (el[i].eventSource && el[i].eventSource == "api") {
+          event = {
+            http: {
+              method: el[i].apiMethod? el[i].apiMethod.toUpperCase(): "",
+              path: this.formatPath(el[i].apiUrl)
+            } 
+          };
+        } 
+
+        if (event) {
+          serverlessJson.functions[ `${settings.functionName}`].events.push(event);
+        }
+      }
+    }
+    
+    // adding events based on triggers
+      if (params.events) {
+        for (var i = 0; i < params.events.length; i++) {
+          let event;
+          if (params.events[i].source === 's3') {
+
+            event = {
+              s3: {
+                bucket: params.events[i].bucket,
+                event: params.events[i].eventType,
+                rules: [
+                  {prefix: params.events[i].prefix},
+                  {suffix: params.events[i].suffix}
+                ]
+              }
+            };
+            
+          } else if (params.events[i].source === 'dynamodb') {
+            event = {
+              stream: {
+                type: "dynamodb",
+                arn: params.events[i].stream,
+                startingPosition: params.events[i].startingPosition
+              }
+            }
+          
+            if (params.events[i].batchSize) {
+              event.stream.batchSize = params.events[i].batchSize;
+            }
+               
+          } else if (params.events[i].source === 'kinesis') {
+            event = {
+              stream: {
+                type: "kinesis",
+                stream: params.events[i].stream,
+                startingPosition: params.events[i].startingPosition
+              }
+            }
+            
+            if (params.events[i].batchSize) {
+              event.stream.batchSize = params.events[i].batchSize;
+            }
+          } else if (params.events[i].source === 'sqs') {
+            const queueArn = await this.sqs.getQueueArn(params.events[i].stream);
+            event = {
+              sqs: {
+                arn: queueArn
+              }
+            }
+
+          } else if (params.events[i].source === 'sns') {
+            event = {
+              sns: {
+                topicName: params.events[i].topic
+              }
+            }
+            
+          } else if (params.events[i].source === 'cwevents') {
+            // our rule arn is incompatible with serverless definition
+            
+          } else if (params.events[i].source === 'cwlogs') {
+            
+          } else if (params.events[i].source === 'cognito') {
+            
+          } else if (params.events[i].source === 'alexa') {
+            event = {
+              alexaSkill: {
+                appId: params.events[i].skillID
+              }
+            }
+          } else if (params.events[i].source === 'codecommit') {
+          } else if (params.events[i].source === 'alb') {
+            event = {
+              alb: {
+                listenerArn: params.events[i].listener
+              }
+            }
+            if (params.events[i].path || params.events[i].host) {
+              event.alb.conditions = {};
+              if (params.events[i].host) {
+                event.alb.conditions.host = params.events[i].host;
+              }
+              if (params.events[i].path) {
+                event.alb.conditions.path = params.events[i].path;
+              }
+            }
+          } else if (params.events[i].source === 'iot') {
+            event = {
+              iot: {
+                name: params.events[i].rule,
+                sql:  params.events[i].query
+              }
+            };
+          }        
+
+          if (event) {
+            serverlessJson.functions[ `${settings.functionName}`].events.push(event);
+          }
+        }
+      }
+
+      return yaml.dump(serverlessJson);    
+  }
+  
+      
+  formatPath(path) {
+    return path
+            .split("/")
+            .map(p => p.startsWith(":")? `{${p.substr(1)}}`: p)
+            .join('/');
+  }
+
+  loadFlow(flowFileName) {
+    return JSON.parse(fs.readFileSync(flowFileName));
+  }
+
+  createFile(baseDir, fileName, content) {
+    fs.outputFileSync(path.join(baseDir, fileName), content, 'utf-8');
+  }
+}
+
+module.exports = ServerlessDeployer;

package/src/app/lib/stores/aws-cloud-config-store.js

@@ -0,0 +1,35 @@
+// properties
+const defaultKeys = {
+  awsLambda: {
+    events: [
+      {
+        source: "api",
+        api: "Create new API",
+        stage: "test",
+        security: "NONE"
+      }
+    ]
+  }
+  
+};
+
+const Store = require('./store');
+
+class CloudConfigStore extends Store {
+
+  constructor(defaults) {
+    super({ ...defaults, configName: '.kumologica/cloud-config', defaults: defaultKeys});
+  }
+
+  getCloudConfig() {
+    return super.get('awsLambda');
+  }
+
+  setCloudConfig(value) {
+    super.set('awsLambda', value);
+  }
+}
+
+module.exports = {
+  CloudConfigStore
+};

package/src/app/lib/stores/azure-config-store.js

@@ -0,0 +1,24 @@
+// properties
+const defaultKeys = {
+};
+
+const Store = require('./store');
+
+class AzureConfigStore extends Store {
+
+  constructor(defaults) {
+    super({ ...defaults, configName: '.kumologica/azure-config', defaults: defaultKeys});
+  }
+
+  getAzureConfig() {
+    return super.get('azure');
+  }
+
+  setAzureConfig(value) {
+    super.set('azure', value);
+  }
+}
+
+module.exports = {
+  AzureConfigStore
+};

package/src/app/lib/stores/kumohub-config-store.js

@@ -0,0 +1,24 @@
+// properties
+const defaultKeys = {
+};
+
+const Store = require('./store');
+
+class KumohubConfigStore extends Store {
+
+  constructor(defaults) {
+    super({ ...defaults, configName: '.kumologica/kumohub-config', defaults: defaultKeys});
+  }
+
+  getKumohubConfig() {
+    return super.get('kumohub');
+  }
+
+  setKumohubConfig(value) {
+    super.set('kumohub', value);
+  }
+}
+
+module.exports = {
+  KumohubConfigStore
+};

package/src/app/lib/stores/project-info-config-store.js

@@ -0,0 +1,26 @@
+// properties
+const defaultKeys = {
+    projectinfo: {}
+  };
+  
+  const Store = require('./store');
+  
+  class ProjectInfoConfigStore extends Store {
+  
+    constructor(defaults) {
+      super({ ...defaults, configName: '.kumologica/project-info-config', defaults: {}});
+    }
+  
+    getProjectInfoConfig() {
+      return super.get('projectinfo');
+    }
+  
+    setProjectInfoConfig(value) {
+      super.set('projectinfo', value);
+    }
+  }
+  
+  module.exports = {
+    ProjectInfoConfigStore
+  };
+  

package/src/app/lib/stores/settings-cloud-store.js

@@ -0,0 +1,117 @@
+// properties: ~/.kumologica/credentials
+
+const defaultContent = `// This file contains all your sensitive credential information
+// about your cloud connections used by Kumologica Designer.
+// For more information visit  https://docs.kumologica.com/settings
+//
+// Azure with terraform:
+// using a Service Principal with a Client Secret follow:
+// https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/guides/service_principal_client_secret
+
+// Examples:
+//
+// [kumohub.default]
+// username = your-username
+// password = your-password
+// subscription = kumohub-subscription-id
+
+// [aws.development]
+// profile = your-defined-aws-profile
+
+// 
+// [azure.default]
+// subscription_id = 00000000-0000-0000-0000-000000000000
+// client_id = 00000000-0000-0000-0000-000000000000
+// client_secret = 0000000000000000000000000000000
+// tenant_id = 00000000-0000-0000-0000-000000000000
+//
+`
+
+const os = require('os');
+const fs = require('fs');
+const fsx = require('fs-extra')
+const ini = require('ini');
+const path = require('path');
+
+class CloudConfigStore {
+    // cloudConfigFileFullPath: a string representing the full path of the cloud config file
+
+    constructor() {
+        let homedir = os.homedir();
+        const credsDir = '.kumologica';
+        const credsFile = `credentials`;
+        this.cloudConfigFileFullPath = path.join(homedir, credsDir, credsFile);
+
+        // check whether the config file exist or not: ~/.kumologica/credentials
+        if (!fs.existsSync(this.cloudConfigFileFullPath)){
+            // create file and write default content on it
+            console.log(`Creating cloud config file on: ${this.cloudConfigFileFullPath}...`)
+            fsx.ensureDirSync(path.join(homedir, credsDir));
+            fs.writeFileSync(this.cloudConfigFileFullPath, defaultContent);
+        } 
+        
+    }
+
+    parseCloudConfigFile() {
+        return ini.parse(this.readCloudConfigFile());
+    }
+
+    getAliases(section){
+        let configFile = this.parseCloudConfigFile();
+        if (configFile && configFile[section]){
+            return Object.keys(configFile[section]);
+        }else{
+            return null;
+        }
+    }
+
+    getAliasInfo(section, alias){
+        let configFile = this.parseCloudConfigFile();
+        if (configFile && configFile[section]){
+            return configFile[section][alias];
+        }else{
+            return null;
+        }
+    }
+
+    getKumohubAliases() {
+        return this.getAliases('kumohub') || [];
+    }
+
+    getAWSAliases() {
+        return this.getAliases('aws') || [];
+     }
+
+     getAzureAliases() {
+        return this.getAliases('azure') || [];
+     }
+  
+    getKumohubAliasInfo(alias){
+        return this.getAliasInfo('kumohub', alias);
+    }
+
+    getAWSAliasInfo(alias){
+        return this.getAliasInfo('aws', alias);
+    }
+    getAzureAliasInfo(alias){
+        return this.getAliasInfo('azure', alias);
+    }
+
+    getCloudConfigFileFullPath() {
+        return this.cloudConfigFileFullPath;
+    }
+
+    writeCloudConfigFile(content){
+        fs.writeFileSync(this.cloudConfigFileFullPath, content);
+    }
+    readCloudConfigFile(){
+        const data = fs.readFileSync(this.cloudConfigFileFullPath, "utf-8");
+        const lines = data.split(/\r\n|\n/);
+
+        return lines.map(l => l.trim()).join('\n');
+    }
+}
+
+module.exports = {
+    CloudConfigStore
+};

package/src/app/lib/stores/settings-cloud-store.spec.js

@@ -0,0 +1,26 @@
+
+const chai = require('chai');
+const { CloudConfigStore } = require('./settings-cloud-store');
+let expect = chai.expect;
+let assert = chai.assert;
+
+describe('parse correctly a cloud config file', () => {
+    it('happy path', () => {
+      let store = new CloudConfigStore();
+      
+      console.log(store.getKumohubAliases());
+      console.log(store.getAWSAliases())
+      console.log(store.getAzureAliases())
+    //   let defaultObj = store.getKumohubAliasInfo('default');
+
+    //   assert.equal(defaultObj.username, 'your-username');
+    //   assert.equal(defaultObj.password, 'your-password');
+    //   assert.equal(defaultObj.subscription, 'kumohub-subscription-id');
+
+
+    //   store.writeCloudConfigFile(`[{{{}asdjf;lj }}} [[[]]another-example\nusername = javier`)
+
+    //   expect(props.queryParams).to.eql({ name: 'me' });
+
+    });
+  });

package/src/app/lib/stores/settings-network-store.js

@@ -0,0 +1,119 @@
+// properties: ~/.kumologica/settings
+
+// if section is undefined, global os proxy settings will be used
+// [proxy]
+// host =
+// port =
+// username =
+// password = 
+
+const defaultContent = `// This file contains all user settings used by Kumologica Designer.
+// DO NOT EDIT this file manually. It will be overriden by Kumologica Designer.
+
+[proxy]
+custom = false
+host =
+port =
+authentication = false
+username =
+password =
+`
+
+const os = require('os');
+const fs = require('fs');
+const fsx = require('fs-extra')
+const ini = require('ini');
+const path = require('path');
+
+class NetworkConfigStore {
+    // networkConfigFileFullPath: a string representing the full path of the cloud config file
+
+    constructor() {
+        let homedir = os.homedir();
+        const kumoDir = '.kumologica';
+        const proxyFile = `settings`;
+        this.networkConfigFileFullPath = path.join(homedir, kumoDir, proxyFile);
+
+        // check whether the config file exist or not: ~/.kumologica/credentials
+        if (!fs.existsSync(this.networkConfigFileFullPath)){
+            // create file and write default content on it
+            console.log(`Creating network config file on: ${this.networkConfigFileFullPath}...`)
+            fsx.ensureDirSync(path.join(homedir, kumoDir));
+            fs.writeFileSync(this.networkConfigFileFullPath, defaultContent);
+        } 
+        
+    }
+
+    parseConfigFile() {
+        return ini.parse(fs.readFileSync(this.networkConfigFileFullPath, 'utf-8'));
+    }
+
+    getSection(section){
+        let configFile = this.parseConfigFile();
+        if (configFile && configFile[section]){
+            return Object.keys(configFile[section]);
+        }else{
+            return null;
+        }
+    }
+
+    getSectionEntry(section, alias){
+        let configFile = this.parseConfigFile();
+        if (configFile && configFile[section]){
+            return configFile[section][alias];
+        }else{
+            return null;
+        }
+    }
+
+
+    getNetworkConfigFileFullPath() {
+        return this.networkConfigFileFullPath;
+    }
+
+    writeNetworkConfigFile(content){
+        fs.writeFileSync(this.networkConfigFileFullPath, content);
+    }
+
+    readNetworkConfigFile(){
+        return fs.readFileSync(this.networkConfigFileFullPath, "utf-8");
+    }
+
+    // Public methods
+    saveProxyDetails(custom, host, port, authentication, username, password){
+        let config = {};
+        config.custom = custom || false;
+        config.host = host || '';
+        config.port = port || '';
+        config.authentication = authentication || false;
+        config.username = username || '';
+        config.password = password || '';
+
+        this.writeNetworkConfigFile(ini.stringify(config, {section: 'proxy'}));
+    }
+
+    getProxyDetails() {
+        let config = this.parseConfigFile();
+        console.log('[settings-network-store] config=', config);
+
+        // Make sure the section is present
+        if (!config.proxy){
+            config['proxy'] = {};
+        }
+        
+        let proxy = config.proxy;
+
+        return {
+            custom: proxy.custom || false,
+            host: proxy.host || '',
+            port: proxy.port || '',
+            authentication: proxy.authentication || false,
+            username: proxy.username || '',
+            password: proxy.password,
+        }
+    }
+}
+
+module.exports = {
+    NetworkConfigStore
+};