@kumologica/sdk 3.0.0-alpha4

package/cli/commands/export-commands/terraform-commands/aws.js

@@ -0,0 +1,193 @@
+const { exp } = require('@kumologica/builder');
+
+exports.command = 'aws';
+exports.desc = `Export terraform.tf.json file to deploy kumologica flow into AWS using terraform framework"`;
+
+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",
+		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), value 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
+	},
+	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',
+		alias: 's',
+		nargs: 1
+	}
+}
+		
+function display(argv) {
+	console.log(`\nBuilding aws lambda artefacts with following parameters: \n`);
+	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.decription||'');
+	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('runtime:             %s', argv.runtime||'');
+	console.log('dead-letter-config:  %s', argv["dead-letter-config"]||'');
+	console.log('file-system-configs: %s',  argv["file-system-configs"]||'');
+}
+
+function validateNotEmpty(name, v) {
+	if (!v) {
+		throw new Error (`Validation error: parameter '${name}' can not be empty`);
+	}
+}
+
+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}'`);
+	}
+
+	console.log(`Parameter ${name} is valid`);
+}
+
+function validate(argv) {
+
+	validateNotEmpty('bucket-name', argv["bucket-name"]);
+
+  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.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|...`);
+		}
+	}
+}
+
+exports.handler = function (argv) {
+	display(argv);
+
+	try {
+		validate(argv);
+		exp('terraform', 'aws', argv);
+
+	} catch (e) {
+		console.log(`${e.message}`);
+		process.exit(1);
+	}
+}

package/cli/commands/export-commands/terraform-commands/azure.js

@@ -0,0 +1,148 @@
+const { exp } = require('@kumologica/builder');
+
+exports.command = 'azure';
+exports.desc = "Export template.tf.json file to deploy kumologica flow into Azure using terraform framework.\nThe template.tf.json file is placed in deploy subdirectory.";
+
+exports.builder = {	
+	"project-directory": {
+		describe: "The root directory where kumologica project is located.\n Default to current process directory if not provided.",
+		type: 'string',
+		nargs: 1
+	},
+	"flow-file-name": {
+		describe: "The name of kumologica flow file.\n Auto search if not provided.",
+		type: 'string',
+		alias: 'f',
+		nargs: 1
+	},
+	"azure-application-name": {
+		describe: "The name of azure application,\n default to flow name",
+		type: 'string',
+		alias: 'a',
+		nargs: 1
+	},
+	"azure-function-name": {
+		describe: "The name of azure function,\n default to flow name",
+		type: 'string',
+		nargs: 1
+	},
+	"zip-file-name": {
+		describe: "The name of zip file with built azure function",
+		demandOption: "The name of zip file is required.",
+		type: 'string',
+		alias: 'z', 
+		nargs: 1
+	},
+	"os-type": {
+		describe: "The operating system for function, either linux or windows. Value ignored if service-plan-id is provided.",
+		type: 'string',
+		alias: 's',
+		nargs: 1
+	},
+	"hosting-plan": {
+		describe: "The hosting plan for function, either consumption or premium. Value ignored if service-plan-id is provided.",
+		type: 'string',
+		alias: 'h',
+		nargs: 1
+	},
+	"location": {
+		describe: "The location (region) where function should be installed",
+		demandOption: "The location is required.",
+		type: 'string',
+		alias: 'l',
+		nargs: 1
+	},
+	"resource-group-name": {
+		describe: "The resource group name the function should be part of. New resource group: {azure-application-name}-group will be created if resource group name not provided.",
+		type: 'string',
+		alias: 'g',
+		nargs: 1
+	},
+	"service-plan-id": {
+		describe: "The service plan id used by function. New service plan: {azure-application-name}-service-plan will be created if service plan id not provided.",
+		type: 'string',
+		alias: 'p',
+		nargs: 1
+	},
+	tags: {
+		describe: `Tags, JSON format wrapped in '': '{"name": "value" ...}'`,
+		type: 'string',
+		alias: 't',
+		nargs: 1
+	},
+	environment: {
+		describe: `Environment variables, JSON format wrapped in '': '{"name": "value" ...}'`,
+		type: 'string',
+		alias: 'e',
+		nargs: 1
+	}
+}
+		
+function display(argv) {
+	console.log(`\nBuilding terraform script for azure function with following parameters: \n`);
+	console.log('project-directory:      %s', argv["project-directory"] || '');
+    console.log('azure-application-name: %s', argv["azure-application-name"]||'');
+	console.log('azure-function-name:    %s', argv["azure-function-name"] || '');
+	console.log('flow-file-name:         %s', argv["flow-file-name"]||'');
+	console.log('zip-file-name:          %s', argv["zip-file-name"]||'');
+	console.log('os-type:                %s', argv["os-type"]||'');
+	console.log('location:               %s', argv["location"]||'');
+	console.log('resource-group-name:    %s', argv["resource-group-name"]||'');
+	console.log('service-plan-id:        %s', argv["service-plan-id"]||'');
+	console.log('hosting-plan:           %s', argv["hosting-plan"]||'');
+	console.log('tags:                   %s', argv["tags"]||'');
+	console.log('environment:            %s', argv["environment"]||'');
+}
+
+
+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}'`);
+	}
+
+	console.log(`Parameter ${name} is valid`);
+}
+
+function validate(argv) {
+
+	if (argv.tags) {
+		validateJson("tags", argv.tags);
+	}
+	if (argv.environment) {
+		validateJson("environment", argv.environment);
+	}
+	if (!argv["service-plan-id"]) {
+		if (!argv["hosting-plan"]) {
+			throw new Error("hosting-plan parameter is required when service-plan-id is not provided.");
+		}
+		if (!argv["os-type"]) {
+			throw new Error("os-type parameter is required when service-plan-id is not provided.");
+		}
+	}
+}
+
+exports.handler = function (argv) {
+	display(argv);
+
+	try {
+		validate(argv);
+		exp('terraform', 'azure', argv);
+
+	} catch (e) {
+		console.log(`${e.message}`);
+		process.exit(1);
+	}
+}

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

@@ -0,0 +1,6 @@
+exports.command = 'terraform <platform>'
+exports.desc = 'Export terraform scripts for kumologica flow'
+exports.builder = function (yargs) {
+  return yargs.commandDir('terraform-commands')
+}
+exports.handler = function (argv) {}

package/cli/commands/export-commands/utils/validator.js

@@ -0,0 +1,195 @@
+const triggersSchema = {
+	"definitions": {},
+	"$schema": "http://json-schema.org/draft-07/schema#", 
+	"$id": "https://example.com/object1616988234.json", 
+	"title": "Root", 
+	"type": "array",
+	"default": [],
+	"items":{
+		"$id": "#root/items", 
+		"title": "Items", 
+		"type": "object",
+		"properties": {
+			"event": {
+				"$id": "#root/items/event", 
+				"title": "Event", 
+				"type": "object",
+				"required": [
+					"expression"
+				],
+				additionalProperties: false,
+				"properties": {
+					"expression": {
+						"$id": "#root/items/event/expression", 
+						"title": "Cron/Schedule Expression", 
+						"type": "string"
+					},
+					"name": {
+						"$id": "#root/items/event/name", 
+						"title": "Event name", 
+						"type": "string"
+					},
+					"reference": {
+						"$id": "#root/items/event/reference", 
+						"title": "Event Listener reference", 
+						"type": "string"
+					}
+				}
+			},
+			"partnerEvent": {
+				"$id": "#root/items/partnerEvent", 
+				"title": "Partner Event", 
+				"type": "object",
+				"required": [
+					"partnerEventBusName"
+				],
+				additionalProperties: false,
+				"properties": {
+					"partnerEventBusName": {
+						"$id": "#root/items/partnerEvent/partnerEventBusName", 
+						"title": "Partner Event Bus Name", 
+						"type": "string"
+					},
+					"detailType": {
+						"$id": "#root/items/partnerEvent/detailType", 
+						"title": "detail-type of the partner event", 
+						"type": "string"
+					},
+					"name": {
+						"$id": "#root/items/partnerEvent/name", 
+						"title": "Name of the Rule for the event", 
+						"type": "string"
+					}
+				}
+			},
+			"sqs": {
+				"$id": "#root/items/sqs", 
+				"title": "Sqs", 
+				"type": "object",
+				"required": [
+					"queueArn"
+				],
+				additionalProperties: false,
+				"properties": {
+					"queueArn": {
+						"$id": "#root/items/sqs/queueArn", 
+						"title": "Queuearn", 
+						"type": "string",
+						"pattern": "^.*$"
+					},
+					"batchSize": {
+						"$id": "#root/items/sqs/batchSize", 
+						"title": "Batchsize", 
+						"type": "integer"
+					}
+				}
+			},
+			"sns": {
+				"$id": "#root/items/sns", 
+				"title": "Sns", 
+				"type": "object",
+				"required": [
+					"topicArn"
+				],
+				additionalProperties: false,
+				"properties": {
+					"topicArn": {
+						"$id": "#root/items/sns/topicArn", 
+						"title": "Topicarn", 
+						"type": "string",
+						"pattern": "^.*$"
+					}
+				}
+			},
+			"api": {
+				"$id": "#root/items/api", 
+				"title": "Api", 
+				"type": "object",
+				required: [],
+				additionalProperties: false,
+				required: ["apiId"],
+				"properties": {
+					"apiId": {
+						"$id": "#root/items/api/apiId", 
+						"title": "ApiId", 
+						"type": "string",			
+						"pattern": "^.*$"
+					},
+					"apiName": {
+						"$id": "#root/items/api/apiName", 
+						"title": "ApiName", 
+						"type": "string",
+						"pattern": "^.*$"
+					},
+					"stage": {
+						"$id": "#root/items/api/stage", 
+						"title": "Stage", 
+						"type": "string",
+						"pattern": "^.*$"
+					},
+					"parentId": {
+						"$id": "#root/items/api/parentId", 
+						"title": "Parentid", 
+						"type": "string",
+						"pattern": "^.*$"
+					},
+					"resource": {
+						"$id": "#root/items/api/resource", 
+						"title": "Resource", 
+						"type": "string",	
+						"pattern": "^.*$"
+					},
+					"authorizerId": {
+						"$id": "#root/items/api/authorizerId", 
+						"title": "Authorizerid", 
+						"type": "string",	
+						"pattern": "^.*$"
+					},
+					"authorizerType": {
+						"$id": "#root/items/api/authorizerType", 
+						"title": "AuthorizerType", 
+						"type": "string",	
+						"pattern": "^.*$"
+					},
+					"apiKeyRequired": {
+						"$id": "#root/items/api/apiKeyRequired", 
+						"title": "ApiKeyRequired", 
+						"type": "boolean"
+					},
+					"scopes": {
+						"$id": "#root/items/api/scopes", 
+						"title": "Scopes", 
+						"type": "array",		
+						"items":{
+							"$id": "#root/items/api/scopes/items", 
+							"title": "Items", 
+							"type": "string",			
+							"pattern": "^.*$"
+						}
+					}
+				}
+			}
+
+		}
+	}
+};
+
+function validate(type, obj) {
+	var Ajv = require('ajv');
+	var ajv = new Ajv({allErrors: true});
+	let valid = false;
+
+	switch(type) {
+		case 'triggers': 
+				valid = ajv.validate(triggersSchema, obj);
+				break;
+	}		
+		
+	if (!valid) {
+		throw new Error(`JSON schema validation errors: ${JSON.stringify(ajv.errors)}`);
+	}
+}
+
+module.exports = {
+    validate
+}

package/cli/commands/export.js

@@ -0,0 +1,6 @@
+exports.command = 'export <language>'
+exports.desc = 'Export deployment scripts for kumologica flow'
+exports.builder = function (yargs) {
+  return yargs.commandDir('export-commands')
+}
+exports.handler = function (argv) {}

package/cli/commands/list-templates.js

@@ -0,0 +1,24 @@
+const { listAvailableTemplates } = require('../utils/download-template-from-repo');
+const { logNotice, logError, logInfo } = require('../utils/logger');
+
+exports.command = 'list-templates'
+exports.desc = 'List of available templates'
+exports.handler = async function (argv) {
+    try {
+        logInfo('List of available templates:');
+        let templates = await readerFriendly(listAvailableTemplates())
+        logNotice(templates);
+    }catch(e){
+        logError(e.message);
+    }
+}
+
+// Utils
+async function readerFriendly(templates) {
+    let result = [];
+    templates = await templates;
+    templates.forEach(t => {
+        result.push(`"${t}"`);
+    });
+    return result.join(',')
+}

package/cli/commands/open.js

@@ -0,0 +1,53 @@
+const path = require('path');
+const { logError } = require('../utils/logger');
+
+const rootPath = path.join(__dirname, '..', '..',);
+
+function startElectron(projectDir) {
+    console.debug(`Project directory: ${projectDir}`);
+    console.debug(`Root directory: ${rootPath}`);
+    let electronPath = process.env["KUMOLOGICA_ELECTRON_PATH"] || path.join(rootPath, "node_modules", ".bin", "electron");
+    console.debug(`Electron path: ${electronPath}`);
+
+    const { spawn } = require("child_process");
+    const e = spawn(electronPath, 
+                    ['.', projectDir],
+                    { 
+                        cwd: rootPath, 
+                        shell: true,
+                        env: {
+                            ELECTRON_RUN_AS_NODE: 1,
+                            NODE_VERSION: "18.16.0"
+                        }
+                    });
+    
+    e.stdout.on("data", data => {
+        console.log(data.toString().trim());
+    });
+    
+    e.stderr.on("data", data => {
+        logError(data.toString().trim());
+    });
+    
+    e.on('error', (error) => {
+        console.log(`==> ${error.message}`);
+    });
+    
+    e.on("close", code => {
+        console.log(`exited with code ${code}`);
+    });
+}
+
+exports.command = "open [project_directory]"
+exports.builder = (yargs) => {
+    yargs.positional(`project_directory`, {
+        type: 'string',
+        describe: 'Path to a valid kumologica project. (Optional)'
+    })
+}
+
+exports.desc = 'Open Kumologica Designer'
+exports.handler = ({ project_directory }) => {
+    let projectDir = project_directory? path.resolve(project_directory): undefined ;
+    startElectron(projectDir);
+}