@kumologica/sdk 3.0.0

package/README.md

@@ -0,0 +1 @@
+# kumologica-designer

package/bin/kl.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../cli/cli.js');

package/cli/cli.js

@@ -0,0 +1,6 @@
+require('yargs/yargs')(process.argv.slice(2))
+  .commandDir('commands')
+  .demandCommand()
+  .help()
+ // .epilog("copyright 2021")
+  .argv

package/cli/commands/build-commands/aws.js

@@ -0,0 +1,49 @@
+exports.command = 'aws';
+exports.desc = `Builds aws lambda binaries: 
+* generates aws lambda artefacts
+* runs npm install
+* creates zip file
+
+Documentation: 
+  https://docs.kumologica.com/docs/references/cli/BuildAws.html`;
+
+exports.builder = {
+	"flow-file-name": {
+		describe: "The name of kumologica flow file.\n Auto search if not provided.\n ",
+		type: 'string',
+		alias: 'f',
+		nargs: 1
+	},
+	"project-directory": {
+		describe: "The root directory of project.\n Current working directory if not provided.\n",
+		type: 'string',
+		alias: 'd',
+		nargs: 1
+	},
+	"zip-file-name": {
+		describe: "The name of zip file to be created",
+		type: 'string',
+		default: 'lambda.zip',
+		alias: 'z',
+		nargs: 1
+	}
+}
+		
+function display(argv) {
+	console.log(`\nBuilding aws lambda artefacts with following parameters: \n`);
+	console.log('project-directory: %s', argv["project-directory"]||'');
+	console.log('flow-file-name:    %s', argv["flow-file-name"]||'');
+    console.log('zip-file-name:     %s', argv["zip-file-name"]||'');
+}
+
+exports.handler = function (argv) {
+	display(argv);
+
+	try {
+		const { build } = require('@kumologica/builder');
+		build('aws', argv);
+	} catch (e) {
+		console.log(`${e.message}`);
+		process.exit(1);
+	}
+}

package/cli/commands/build-commands/azure.js

@@ -0,0 +1,43 @@
+exports.command = 'azure';
+exports.desc = `Generate azure function artefacts and build zip file`;
+
+exports.builder = {
+	"flow-file-name": {
+		describe: "The name of kumologica flow file.\n Auto search if not provided.",
+		type: 'string',
+		alias: 'f',
+		nargs: 1
+	},
+	"project-directory": {
+		describe: "The root directory of project.\n Process directory if not provided.",
+		type: 'string',
+		alias: 'd',
+		nargs: 1
+	},
+	"zip-file-name": {
+		describe: "The name of zip file name",
+		type: 'string',
+		default: 'azure.zip',
+		alias: 'z',
+		nargs: 1
+	}
+}
+
+function display(argv) {
+	console.log(`\nBuilding azure function artefacts with following parameters: \n`);
+	console.log('project-directory: %s', argv["project-directory"] || '');
+	console.log('flow-file-name:    %s', argv["flow-file-name"] || '');
+	console.log('zip-file-name:     %s', argv["zip-file-name"] || '');
+}
+
+exports.handler = function (argv) {
+	display(argv);
+
+	try {
+		const { build } = require('@kumologica/builder');
+		build('azure', argv);
+	} catch (e) {
+		console.log(`${e.message}`);
+		process.exit(1);
+	}
+}

package/cli/commands/build-commands/kumohub.js

@@ -0,0 +1,7 @@
+exports.command = 'kumohub '
+exports.desc = 'Build kumohub artefacrs remote named <name> for repo at url <url>'
+exports.builder = {}
+
+exports.handler = function (argv) {
+  console.log('adding remote %s at url %s', argv.name, argv.url)
+}

package/cli/commands/build.js

@@ -0,0 +1,6 @@
+exports.command = 'build <provider>'
+exports.desc = 'Build kumologica flow binaries'
+exports.builder = function (yargs) {
+  return yargs.commandDir('build-commands')
+}
+exports.handler = function (argv) {}

package/cli/commands/create.js

@@ -0,0 +1,32 @@
+const pathlib = require('path');
+const { logNotice, logError } = require('./utils');
+const { codegen } = require('@kumologica/builder');
+
+exports.command = "create"
+exports.builder = (yargs) => {
+    yargs.option(`path`, {
+        describe: "The path where project will be created.",
+        demandOption: "The path is required.",
+		type: 'string',
+		alias: 'p',
+		nargs: 1
+	});
+}
+
+exports.desc = 'Create a kumologica project'
+exports.handler = ({ path }) => {
+    const { version } = require('../../package.json');
+    try{
+        codegen.generateBoilerplateProject({ 
+            basePath :process.cwd(), 
+            projectName: path,
+            runtimeVersion: version });
+       
+        logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), path)}`);
+    } catch(e) {
+        logError(e.toString());
+        process.exit(1);
+    }
+   
+    
+}

package/cli/commands/deploy-commands/kumohub.js

@@ -0,0 +1,114 @@
+exports.command = 'kumohub';
+exports.desc = `Deploy kumologica flow to kumohub.io account`;
+
+exports.builder = {
+	"flow-file-name": {
+		describe: "The name of kumologica flow file.\n Auto search if not provided.\n",
+		type: 'string',
+		alias: 'f',
+		nargs: 1
+	},
+	"service-name": {
+		describe: "The name of service.\n flow file name without extension if not provided.\n Service name will be sanitized to be compatible with aws lambda name restrictions.\n",
+		type: 'string',
+		nargs: 1
+	},
+	"project-directory": {
+		describe: "The root directory of project.\n Process working directory if not provided.\n",
+		type: 'string',
+		alias: 'd',
+		nargs: 1
+	},
+	"environment": {
+		describe: `Environment variables, JSON Syntax: '{"Variables": {"key": "value", ...}}'\n`,
+		type: 'string',
+		nargs: 1
+	},
+	"account": {
+		describe: "The name of kumohub.io account\n",
+		type: 'string',
+		required: true,
+		alias: 'a',
+		nargs: 1
+	},
+	"username": {
+		describe: "The username to login to kumohub.io account\n",
+		type: 'string',
+		required: true,
+		alias: 'u',
+		nargs: 1
+	},
+	"password": {
+		describe: "The username password to login to kumohub.io account\n",
+		type: 'string',
+		required: true,
+		alias: 'p',
+		nargs: 1
+	},
+	"workspace": {
+		describe: "The name of the workspace where flow to be deployed.\n",
+		type: 'string',
+		required: true,
+		alias: 'w',
+		nargs: 1
+	},
+	"stage": {
+		describe: "The name of the stage where flow to be deployed\n",
+		type: 'string',
+		required: true,
+		alias: 's',
+		nargs: 1
+	},
+	"policy": {
+		describe: "The name of security policy to assign to the flow.\n",
+		type: 'string',
+		required: true,
+		default: "Public",
+		nargs: 1
+	},
+	"memory": {
+		describe: "The amount of memory (MB) to be allocated to the flow. 128 MB to 10240 MB\n",
+		type: 'string',
+		nargs: 1,
+		default: "512"
+    },
+	"timeout": {
+		describe: "The amount of seconds flow should be run before timing out. Up to 900 seconds\n",
+		type: 'string',
+		nargs: 1,
+		default: "30" 
+	},
+	"description": {
+		describe: "The description of function.\n",
+		type: 'string',
+		nargs: 1
+	}
+}
+
+function display(argv) {
+	console.log(`\nDeploying flow to kumohub.io with following parameters: \n`);
+	console.log('project-directory: %s', argv["project-directory"] || '');
+	console.log('flow-file-name:    %s', argv["flow-file-name"] || '');
+	console.log('service-name:      %s', argv["service-name"] || '');
+	console.log('environment vars:  %s', argv["environment"] || '');
+	console.log('username:          %s', argv["username"] || '');
+	console.log('password:          %s', argv["password"]? "provided": "missing");
+	console.log('workspace:         %s', argv["workspace"] || '');
+	console.log('stage:             %s', argv["stage"] || '');
+	console.log('policy:            %s', argv["policy"] || '');
+	console.log('memory:            %s', argv["memory"] || '');
+	console.log('timeout:           %s', argv["timeout"] || '');
+	console.log('description:       %s', argv["description"] || '');
+}
+
+exports.handler = function (argv) {
+	display(argv);
+
+	try {
+		const { deploy } = require('@kumologica/builder');
+		deploy('kumohub', argv);
+	} catch (e) {
+		console.log(`${e.message}`);
+		process.exit(1);
+	}
+}

package/cli/commands/deploy.js

@@ -0,0 +1,6 @@
+exports.command = 'deploy <provider>'
+exports.desc = 'Deploy kumologica flow binaries'
+exports.builder = function (yargs) {
+  return yargs.commandDir('deploy-commands')
+}
+exports.handler = function (argv) {}

package/cli/commands/doc-commands/html.js

@@ -0,0 +1,61 @@
+exports.command = 'html';
+exports.desc = `Generates html documentation of kumologica flow.`;
+
+exports.builder = {			
+	"documentation-directory": {
+        describe: "The directory where documentation will be created.",
+        demandOption: "The documentation directory is required.",
+		type: 'string',
+		alias: 'd',
+		nargs: 1
+	},
+	"kumologica-project-directory": {
+        describe: "The directory where kumologica project to be created",
+        demandOption: "The kumologica project directory is required.",
+		type: 'string',
+		alias: 'k',
+		nargs: 1
+	},
+	"kumologica-flow-file-name": {
+        describe: "The name of kumologica flow file to be created, must end with .json extension",
+        demandOption: "The kumologica flow file name is required.",
+		type: 'string',
+		alias: 'f',
+		nargs: 1
+	}
+}
+		
+function validate(argv) {
+	const chalk = require('chalk');
+
+	if (!argv["kumologica-flow-file-name"].endsWith('.json')) {
+		console.log(`${chalk.redBright("Validation Error: kumologica-flow-file-name must end with .json extension.")}`);
+		process.exit(1);
+	}
+}
+function display(argv) {
+	console.log('Parameters:');
+	console.log('  documentation-directory:    %s', argv["documentation-directory"]||'');
+	console.log('  kumologica-project-directory:  %s', argv["kumologica-project-directory"]||'');
+	console.log('  kumologica-flow-file-name:     %s', argv["kumologica-flow-file-name"]||'');
+}
+
+exports.handler = async function (argv) {
+	console.log('\nGenerating documentation\n');
+	display(argv);
+	validate(argv);
+
+	const chalk = require('chalk');
+
+	try {
+		const { doc } = require('@kumologica/builder');
+		doc("html", argv);
+		console.log(chalk.greenBright('Documentation generated succesfully.'));
+	
+		process.exit(0);
+	} catch (e) {
+
+		console.log(`${chalk.redBright(e.message)}`);
+		process.exit(1);
+	}
+}

package/cli/commands/doc.js

@@ -0,0 +1,6 @@
+exports.command = 'doc'
+exports.desc = 'Generate documentation for kumologica flow'
+exports.builder = function (yargs) {
+  return yargs.commandDir('doc-commands')
+}
+exports.handler = function (argv) {}

package/cli/commands/export-commands/cloudformation.js

@@ -0,0 +1,338 @@
+const { boolean } = require('yargs');
+
+exports.command = 'cloudformation';
+exports.desc = `Build aws cloud formation script. \n Parameters are equivalent of command: "aws lambda create-function"`;
+
+exports.builder = {			
+	"flow-file-name": {
+		describe: "The name of kumologica flow file.\n Auto search if not provided.",
+		type: 'string',
+		alias: 'f',
+		nargs: 1
+	},
+	"lambda-name": {
+		describe: "The name of lambda function,\n default to flow name",
+		type: 'string',
+		alias: 'l',
+		nargs: 1
+	},
+	"zip-file-name": {
+		describe: "The name of zip file of built lambda",
+		demandOption: "The name of zip file is required.",
+		type: 'string',
+		alias: 'z',
+		nargs: 1
+	},
+	"role-name": {
+		describe: "The name of lambda role, default to {lambda-name}-role",
+		type: 'string',
+		alias: 'o',
+		nargs: 1
+	},
+    "bucket-name": {
+		describe: "The name of bucket where zipped lambda is loaded from",
+		demandOption: "The name of s3 bucket is required.",
+		type: 'string',
+		alias: 'b',
+		nargs: 1
+	},
+	timeout: {
+		describe: "The time in seconds flow lambda is allowed to run, default: 3, max: 900",
+		type: 'number',
+		alias: 't',
+		nargs: 1
+	},
+	"memory-size": {
+		describe: "The amount of memory allocated to function, default 128 (MB), must be multiple of 64 (MB)",
+		type: 'number',
+		alias: 'm',
+		nargs: 1
+	},
+	description: {
+		describe: "The description of a function",
+		type: 'string',
+		alias: 'd',
+		nargs: 1
+	},
+	environment: {
+		describe: `Environment variables, JSON Syntax: '{"Variables": {"string": "string" ...}'}`,
+		type: 'string',
+		alias: 'e',
+		nargs: 1
+	},
+	tags: {
+		describe: `Tags, JSON Syntax: '{"string": "string" ...}'`,
+		type: 'string',
+		alias: 'g',
+		nargs: 1
+	},
+	"tracing-config": {
+		describe: `X-Ray config, JSON Syntax: '{"Mode": "Active"|"PassThrough"}' `,
+		type: 'string',
+		alias: 'x',
+		nargs: 1
+	},
+	"kms-key-arn": {
+		describe: "The ARN of KMS key to encrypt env variables",
+		type: 'string',
+		alias: 'k',
+		nargs: 1
+	},
+	"vpc-config": {
+		describe: `The list of security groups and subnets of VPC, JSON syntax: '{ "SubnetIds": ["string", ...],"SecurityGroupIds": ["string", ...]}'`,
+		type: 'string',
+		alias: 'v',
+		nargs: 1
+	},
+	architectures: {
+		describe: "The instruction set architecture that the function supports, a string array with one of x86_64, arm64. The default value is [x86_64]",
+		type: 'string',
+		nargs: 1
+	},
+	runtime: {
+		describe: "The runtime, only nodejs runtimes allowed: nodejs|nodejs4.3|nodejs6.10|nodejs8.10|nodejs10.x|nodejs12.x|...",
+		type: 'string',
+		alias: 'r',
+		nargs: 1
+	},
+	"dead-letter-config": {
+		describe: `The arn of the dead letter queue or topic JSON Syntax: '{"TargetArn": "string"}'`,
+		type: 'string',
+		alias: 'q',
+		nargs: 1
+	},
+	"file-system-configs": {
+		describe: `AWS EFS config details, JSON Syntax: '[{"Arn": "string","LocalMountPath": "string"} ...]'`,
+		type: 'string',
+		nargs: 1
+	},
+	"log-retention-days": {
+		describe: 'Number of days logs to be retained',
+		type: 'number',
+		nargs: 1
+	},
+	"role-arn": {
+		describe: `The ARM of IAM role to assign to lambda, otherwise this command will generate role. \n Important!\n This parameter should only be used if this command is not able to generate sufficient role based on flow details.`,
+		type: 'string',
+		nargs: 1
+	},
+	"policy": {
+		describe: `Additional iam policy to add to the role. It must be valid aws policy format, for example: '{"Effect": "Allow", "Resource": ["*"],"Action": ["sns:Publish"]}'. if policy is invalid, cloudformation stack will fail. The value can be single policy statement or array of statements if required. This parameter is ignored if role-arn is provided.`,
+		type: 'string',
+		nargs: 1
+	},
+	"strict-mode": {
+		describe: 'Fails script creation if insufficient resource definition is provided (string values or environment reference). If false, then resource will be substituted with "*" if missing.',
+		type: boolean,
+		nargs: 1,
+		default: true
+	},
+	triggers: {
+		describe: `Array of lambda triggers, JSON Syntax: '[{"api": {"apiId": "..",..}]'}
+
+		Supported triggers:
+
+Cloudwatch Event:\n-----------------
+			* schedule - cron expression (minutes hours days-of-month month days-of-week year) or fixed rate expression, required.\n See more: https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html
+			* name - the name of event, optional, default value: Event+timestamp if not provided
+			* nodeId - the id of event listener node that should handle event. Optional
+
+Examples:
+1. Creates event trigger using cron expression that runs at 10am UTC every day:\n
+			{"event": {"expression": "cron(0 10 * * ? *)"}}
+			
+2. Creates event trigger using rate expression that runs every minute:\n
+			{"event": {"expression": "rate(1 minute)"}}\n
+
+3. Creates event trigger using rate expression that runs every minute for event listener id "53bdf34.df2dfa42":\n
+			{"event": {"expression": "rate(1 minute)", "nodeId": "53bdf34.df2dfa42"}}\n
+
+SQS:\n----
+			* queueArn - the ARN of sqs queue, required
+			* batchSize - the size of batch, optional
+
+Example:
+			{"sqs": {"queueArn": "arn:aws: ..."}}
+
+DynamoDB Stream:\n----
+			* streamArn - the ARN of dynamodb stream, required
+			* batchSize - the size of batch, optional
+			* batchWindow - maximum batching window in seconds, optional
+			* startingPosition - either LATEST or TRIM_HORIZON, optional
+Example: 
+			{"dynamodb": {"streamArn": "arn:aws: ...", "startingPosition": "LATEST"}}
+
+Kinesis Stream:\n---------------
+			* streamArn - the ARN of kinesis stream, required
+			* batchSize - the size of batch, optional
+			* batchWindow - maximum batching window in seconds, optional
+			* startingPosition - either LATEST or TRIM_HORIZON, optional
+Example: 
+			{"kinesis": {"streamArn": "arn:aws: ...", "startingPosition": "LATEST"}}
+
+S3:\n---
+			* bucket - the name of the bucket, required
+			* sourceAccount - the account id
+			* eventType - the size of batch, optional
+			* prefix - maximum batching window in seconds, optional
+			* suffix - either LATEST or TRIM_HORIZON, optional
+Example: 
+			{"s3": {"bucket": "testBucket", "eventType": "ObjectCreated.*"}}
+
+Rest api gateway:\n-----------------
+			* apiId:    the id of rest api, required
+			* stage:    the stage name of api gateway, required
+			* parentId: the id of parent resource where lambda {proxy+} should be added, required
+			* resource: the name of resource linked to lambda, required if parentId is not root or lambda linked to non root in api gw
+			* authorizerType: the type of authorizer: TOKEN, COGNITO_USER_POOLS, REQUEST
+			* authorizerId: the if of authorizer, optional
+			* apiKeyRequired: true if api key is required. default false
+			* scopes:   array of scopes, optional
+
+Examples:
+
+1. Creates new api gateway, default: 'test' stage and root proxy resource:
+
+		{"api": {
+			"apiId": "create new",
+			"apiName": "booking api"\n}
+
+2. Creates new api gateway, default: 'test' stage and proxy resource under /users resource:
+			
+		{"api": {
+			"apiId": "create new",
+			"apiName": "users api",
+			"resource": "users"\n}\n}
+	
+3. Uses existing api gateway, 'test' stage, creates proxy resource under /users resource, attaches request authorizer to proxy and required OAuth scopes:
+			{"api": {
+			   "apiId": "fg4wsf",
+				"stage": "test",
+				"parentId": "vfgd24d",
+				"resource": "users",
+				"authorizerId": "3dgfd42",
+				"authorizerType": "REQUEST",
+				"scopes": ["users", "admins"]\n}
+
+4. Uses existing api gateway, 'test' stage, creates proxy resource under specified parent id:
+				{"api": {
+				\t"apiId": "fg4wsf",
+				\t"stage": "test",	
+				\t"parentId": "vfgd24d"\n}
+
+5. Creates new api gateway, default: 'test' stage, proxy resource under /users resource with required api key:
+			
+				{"api": {
+					"apiId": "create new",
+					"apiName": "users api",
+					"resource": "users",
+					"apiKeyRequired: true\n}\n}
+					`,
+		type: 'string',
+		nargs: 1
+	},
+
+}
+		
+function display(argv) {
+	console.log('Parameters:');
+	console.log('  flow-file-name:      %s', argv["flow-file-name"]||'');
+	console.log('  zip-file-name:       %s', argv["zip-file-name"]||'');
+	console.log('  lambda-name:         %s', argv["lambda-name"]||'');
+	console.log('  role-name:           %s', argv["role-name"]||'');
+	console.log('  bucket-name:         %s', argv["bucket-name"]);
+	console.log('  timeout:             %s', argv.timeout||'');
+	console.log('  memory-size:         %s', argv["memory-size"]||'');
+	console.log('  description:         %s', argv.description||'');
+	console.log('  environment:         %s', argv.environment||'');
+	console.log('  tags:                %s', argv["tags"]||'');
+	console.log('  tracing-config:      %s', argv["tracing-config"]||'');
+	console.log('  kms-key-arn:         %s', argv["kms-key-arn"]||'');
+	console.log('  vpc-config:          %s', argv["vpc-config"]||'');
+	console.log('  architectures:       %s', argv.architectures || '');
+	console.log('  runtime:             %s', argv.runtime||'');
+	console.log('  dead-letter-config:  %s', argv["dead-letter-config"]||'');
+	console.log('  file-system-configs: %s', argv["file-system-configs"]||'');
+	console.log('  log-retention-days:  %s', argv["log-retention-days"]||'');
+	console.log('  role-arn:            %s', argv["role-arn"]||'');
+	console.log('  policy               %s', argv["policy"] || '');
+	console.log('  strict-mode          %s', argv["strict-mode"] || '');
+	console.log('  triggers:            %s', argv.triggers||'');	
+}
+
+function validateJson(name, s) {
+	if (typeof s !== 'string') {
+		throw new Error (`Validation error: parameter '${name}' value is not string: '${s}'`);
+	}
+	
+	let type;
+	try {
+		const result = JSON.parse(s);
+		type = Object.prototype.toString.call(result);
+	} catch (e) {
+		throw new Error (`Validation error: parameter '${name}': ${e.message}`);
+	}
+
+	if (!(type === '[object Object]' || type === '[object Array]')) {
+		throw new Error (`Validation error: parameter '${name}' value is not in JSON format: '${s}'`);
+	}
+}
+
+function validate(argv) {
+
+	const validator = require('./utils/validator');
+
+  if (argv.environment) {
+		validateJson("environment", argv.environment);
+	}
+	if (argv.tags) {
+		validateJson("tags", argv.tags);
+	}
+	if (argv["tracing-config"]) {
+		validateJson("tracing-config", argv["tracing-config"]);
+	}
+	if (argv["vpc-config"]) {
+		validateJson("vpc-config", argv["vpc-config"]);
+	}
+	if (argv["dead-letter-config"]) {
+		validateJson("dead-letter-config", argv["dead-letter-config"]);
+	}
+	if (argv["file-system-configs"]) {
+		validateJson("file-system-configs", argv["file-system-configs"]);
+	}
+	if (argv.triggers) {
+		validateJson("triggers", argv.triggers);
+		validator.validate("triggers", JSON.parse(argv.triggers));
+	}
+	if (argv.runtime) {
+		if (!argv.runtime.startsWith("nodejs")) {
+			throw new Error (`Validation error: parameter 'runtime' must be one of supported nodejs values: nodejs|nodejs4.3|nodejs6.10|nodejs8.10|nodejs10.x|nodejs12.x|...`);
+		}
+	}
+	if (argv.architectures ) {
+		if (!argv.architectures.length || argv.architectures.length != 1 || !["x86_64","arm64"].includes(argv.architectures[0])) {
+			throw new Error (`Validation error: parameter 'architectures' must be an array with one element, either x86_64 or arm64`);
+		}
+	}
+}
+
+exports.handler = function (argv) {
+	console.log('\nGenerating AWS Cloud Formation script\n');
+	display(argv);
+	const chalk = require('chalk');
+
+	try {
+		validate(argv);
+
+		const { exp } = require('@kumologica/builder');
+		
+		exp('cloudformation', 'aws', argv);
+		console.log(chalk.greenBright('AWS Cloud Formation script created successfully.'));
+	
+		process.exit(0);
+	} catch (e) {
+
+		console.log(`${chalk.redBright(e.message)}`);
+		process.exit(1);
+	}
+}