@kumologica/sdk 3.2.0-beta8 → 4.0.0-alpha1

package/bin/kl.js

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

package/cli/cli.js

@@ -1,5 +1,3 @@
-const chalk = require('chalk');
-
 require('yargs/yargs')(process.argv.slice(2))
   .commandDir('commands')
   .demandCommand()

package/cli/commands/create-commands/create-project-iteratively.js

@@ -3,8 +3,14 @@ const { prompt, Select } = require('enquirer');
 const { logNotice, logError } = require('../../utils/logger');
 const { downloadTemplateFromRepo, listAvailableTemplates } = require('../../utils/download-template-from-repo');
 
-async function createProjectIteratively(){
-    const availableTemplates = await listAvailableTemplates();
+async function createProjectIteratively() {
+    let availableTemplates;
+    try {
+        availableTemplates = await listAvailableTemplates();
+    } catch (err) {
+        logError('Error found while retrieving the list of available templates. Please ensure that your internet connection is active and try again');
+        process.exit(1);
+    }
     // Project name
     const projectNameResponse = await prompt({
         type: 'input',
@@ -26,17 +32,18 @@ async function createProjectIteratively(){
         name: 'template',
         message: 'Pick one of the available templates',
         choices: availableTemplates
-      });
+    });
 
     let aTemplateName = await promptTemplate.run();
 
-    try{
+    try {
         await downloadTemplateFromRepo(undefined, aTemplateName, aProjectPath, aProjectName);
         logNotice(`Successfully created project: ${pathlib.join(aProjectPath, aProjectName)}`)
-    } catch (err){
-        logError(`Error found while creating project due to: ${err.message}`)
+    } catch (err) {
+        logError(`Error found while creating project due to: ${err.message}`);
+        process.exit(1);
     }
 }
-    
+
 
 module.exports = createProjectIteratively;

package/cli/commands/create.js

@@ -25,41 +25,42 @@ exports.builder = (yargs) => {
 
 exports.desc = 'Create a kumologica project. Do not pass any options to create iteratively.'
 exports.handler = async ({ path, template }) => {
-    const { version } = require('../../package.json');
+    const { version } = require('../../../sdk/package.json');
 
     if (!path && !template) {
         await createProjectIteratively();
     } else if (!path && template) {
-        try{
+        try {
             await downloadTemplateFromRepo(undefined, template, process.cwd(), template);
-            logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), template)}`);
-        }catch(e){
+            logNotice(`Successfully created project: ${pathlib.join(process.cwd(), template)}`);
+        } catch (e) {
             logError(e.message);
         }
-    } else if (path && !template){
-        try{
-            codegen.generateBoilerplateProject({ 
-                basePath :process.cwd(), 
+    } else if (path && !template) {
+        try {
+            codegen.generateBoilerplateProject({
+                basePath: process.cwd(),
                 projectName: path,
-                runtimeVersion: version });
-            logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), path)}`);
-        }catch(e){
+                runtimeVersion: version
+            });
+            logNotice(`Successfully created project: ${pathlib.join(process.cwd(), path)}`);
+        } catch (e) {
             logError(e.message);
         }
     } else if (path && template) {
         path = pathlib.resolve(path);
         let projectPath = pathlib.dirname(path);
         let projectName = pathlib.basename(path);
-        try{
-            if (isPlainGitURL(template)){
+        try {
+            if (isPlainGitURL(template)) {
                 await downloadTemplateFromRepo(template, undefined, projectPath, projectName);
             } else {
                 await downloadTemplateFromRepo(undefined, template, projectPath, projectName);
             }
             logNotice(`Successfully created project: ${path}`);
-        }catch(e){
+        } catch (e) {
             logError(e.message);
         }
     }
-        
+
 }

package/cli/commands/open.js

@@ -6,13 +6,20 @@ 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");
-    // TODO remove  '..', '..' if not working from npm
-//    const e = spawn(path.join(rootPath,  '..', '..', "node_modules", ".bin", "electron"), 
-    const e = spawn(path.join(rootPath, "node_modules", ".bin", "electron"), 
+    const e = spawn(electronPath, 
                     ['.', projectDir],
-                    { cwd: rootPath, shell: true });
+                    { 
+                        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());

package/cli/commands/start.js

@@ -0,0 +1,165 @@
+/**
+ * This command should be used to start the kumologica runtime in local mode. And it will
+ * be assisting the UI on all aspects of the project development.
+ *
+ * Example:
+ * kl start ./myproject
+ * kl start ./myproject/flow.json
+ * kl start (this will look for a flow.json in the current directory)
+ *
+ * If not flow is found, the process will be exited (with code 1) for the time being.
+ * Ideally, we want to start the server and serve the Runtime API to allow the user to
+ * open/create new projects fromt he UI.
+ *
+ * The Runtime API can be found in: packages/runtime/src/runtime/lib/api/rest/index.js
+ * The actual runtime is in: packages/runtime/src/runtime/lib/index.js
+ *
+ * Naming convention used during the code:
+ * - AdminApp (express app) is the server that serves the Runtime API
+ * - NodeApp (express app) is the server that runs the flow
+ *
+ * WARNING:
+ * Current implementation seems to be mounting the runtime api in the NodeApp (see runtime/lib/index.js:534)
+ * Ideally we wouldl like to separate the two apps and have the AdminApp running on a different port.
+ *
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { codegen } = require('@kumologica/builder');
+const { DesignerServer } = require('../../src/server/DesignerServer');
+const { logError, logNotice, logInfo, logFatal } = require('../utils/logger');
+// const opn = require('better-opn');
+
+exports.command = 'start [project_directory]';
+exports.desc = `Run kumologica runtime in local mode`;
+
+exports.builder = (yargs) => {
+  yargs.positional(`project_directory`, {
+    type: 'string',
+    describe:
+      'Path to a valid kumologica project directory or flow file. (Optional)',
+  });
+  yargs.option(`loglevel`, {
+    describe: 'Logging level: [error, warn, info, debug, trace]',
+    type: 'string',
+    nargs: 1,
+  });
+  yargs.option(`port`, {
+    describe: 'Specifies the listening port utilized by the application',
+    type: 'number',
+    nargs: 1,
+  });
+  yargs.option(`adminport`, {
+    describe: 'Specifies the listening port utilized by the admin API',
+    type: 'number',
+    nargs: 1,
+  });
+  yargs.option(`secured`, {
+    describe: 'Enable security control to the admin API',
+    type: 'boolean',
+    nargs: 1,
+  });
+  yargs.option(`noadmin`, {
+    describe: 'Start the runtime with admin API disabled',
+    type: 'boolean',
+    nargs: 0,
+  });
+};
+
+exports.desc = 'Starting Kumologica Runtime for Development';
+
+exports.handler = ({
+  project_directory,
+  loglevel,
+  port,
+  adminport,
+  secured,
+  noadmin,
+  env
+}) => {
+  logNotice(`Launching Kumologica Runtime...`);
+  let absProjectDirectory;
+
+  try {
+    absProjectDirectory = fs.realpathSync(project_directory);
+  } catch (err) {
+    logFatal(`Project directory not found: ${project_directory}`);
+  }
+
+  try {
+    // Resolve the path to the flow path
+    const [projectFlowDirname, projectFlowFullPath] = resolveProjectFlowPath(absProjectDirectory);
+    logInfo(`> Flow file found: ${projectFlowFullPath}`);
+
+    // Gather all cli params
+    const cliParams = {
+      env,
+      loglevel,
+      port,
+      adminport,
+      secured,
+      noadmin
+    }
+
+    // Start a server 
+    let server = new DesignerServer(projectFlowFullPath, true, cliParams);
+    server.listen();
+    if (!noadmin) {
+      server.listenAdminServer();
+    }
+
+    // opn("http://localhost:1880/hello");
+  } catch (e) {
+    console.log(e);
+    logFatal(e.message);
+
+  }
+};
+
+/**
+ * Resolve a given path to a new path that points to the project flow json file.
+ * Scenarios:
+ *  - If path undefined will resolve using current directory
+ *  - If path directory, it should look up for a valid flow.json file, if it does not exist create it
+ *  - If path is pointing to an actual flowFile, just return it.
+ *
+ * @param {string} projectDir
+ */
+function resolveProjectFlowPath(projectDir) {
+  // output
+  let projectFlowFullPath;
+  let projectFlowDirname;
+
+  let projectDirOrFile = projectDir || process.cwd();
+
+  let isDir = isDirectory(projectDirOrFile);
+  if (isDir) {
+    let flowFileName = codegen.findFlowFile(projectDirOrFile); // returns only the flowname
+
+    if (!flowFileName) {
+      logError(`No flow found in directory: ${projectDirOrFile}`);
+      process.exit(1);
+    } else {
+      projectFlowDirname = projectDirOrFile;
+      projectFlowFullPath = path.join(projectDirOrFile, flowFileName);
+    }
+  } else if (isDir === false) {
+    projectFlowDirname = path.dirname(projectDirOrFile);
+    projectFlowFullPath = projectDirOrFile;
+  } else {
+    logError(`Directory does not exist: ${project_directory}`);
+    process.exit(1);
+  }
+
+  return [projectFlowDirname, projectFlowFullPath];
+}
+
+function isDirectory(dir) {
+  try {
+    let stats = fs.statSync(dir);
+    return stats.isDirectory();
+  } catch (err) {
+    return undefined;
+  }
+}

package/cli/commands/test/TestSuiteRunner.js

@@ -0,0 +1,76 @@
+const { performance } = require('perf_hooks');
+const { InMemoryReporter, TerminalReporter } = require("../../../src/api/tools/test/lib/reporters");
+const { TestCaseRunner } = require('../../../src/api/tools/test/lib/TestCaseRunner');
+const { logError, logNotice, logInfo, logFatal } = require('../../utils/logger');
+
+
+class TestSuiteRunner {
+    constructor(designerServer) {
+        this.designerServer = designerServer;
+        this.flowServer = this.designerServer.getFlowServer();
+    }
+    /**
+     * 
+     * @param {*} testcases 
+     * return an array containing found errors during execution, or undefined if successful
+     */
+    async runAll(testcases) {
+        logInfo(`TestCases - Executing\n`);
+        let testSuiteTimeStart = performance.now();
+
+        let totalPassedTestCases = 0;
+        let totalFailedCases = 0;
+        const totalTestCases = testcases.length;
+        for (let i = 0; i <= totalTestCases - 1; i++) {
+            let success = await this.runTestCase(testcases[i]);
+            if (success) {
+                totalPassedTestCases = totalPassedTestCases + 1;
+            } else {
+                totalFailedCases = totalFailedCases + 1;
+            }
+        }
+        let testSuiteTimeEnd = performance.now();
+        let testSuiteExecutionTimeInMs = testSuiteTimeEnd - testSuiteTimeStart;
+        this.printSummary(testSuiteExecutionTimeInMs, totalTestCases, totalFailedCases, totalPassedTestCases);
+        return 0;
+    }
+
+    /**
+     * 
+     * @param {*} testcase 
+     * @returns true if success, otherwise false
+     */
+    async runTestCase(testcase) {
+        let testcaseid = testcase.id;
+
+        const inMemReporter = new InMemoryReporter;
+        const terminalReporter = new TerminalReporter;
+
+        const testcaseRunner = new TestCaseRunner(this.flowServer, testcaseid, [inMemReporter, terminalReporter]);
+        try {
+            await testcaseRunner.runAsync();
+            return !inMemReporter.isFailedStatus()
+        } catch (err) {
+            console.log(err);
+            logFatal(`Unexpected error occurred while running testcase: "${testcase.name}" due to: ${err.message}.`)
+        }
+    }
+
+    printSummary(totalExecutionTimeInMs, totalTestCases, totalFailedCases, totalPassedTestCases) {
+        logInfo(`TestCases - Completed
+    
+Final Execution Statistics
+-------------------------------
+ Execution Time: ${Math.floor(totalExecutionTimeInMs)} ms
+ Total Test Cases: ${totalTestCases}
+ Failed: ${totalFailedCases}
+ Passed: ${totalPassedTestCases}
+-------------------------------
+        `);
+    }
+
+}
+
+module.exports = {
+    TestSuiteRunner
+}

package/cli/commands/test.js

@@ -1,151 +1,123 @@
-const chalk = require('chalk');
-const { Select } = require('enquirer');
-const fs = require('fs');
 const path = require('path');
+const { Select } = require('enquirer');
 const wcmatch = require('wildcard-match');
-
-const { AppServer } = require('@kumologica/runtime');
+const { util } = require('@kumologica/runtime');
 const { codegen } = require('@kumologica/builder');
 
-const { TestSuiteController } = require('./test-utils/TestSuiteController');
-const { logError } = require('../utils/logger');
-
-const log = console.log;
-const APP_SERVER_PORT = 1990;
-		
-async function runTest(flowFilePath, testcaseSelected, iterative) {
-    log(`\n> Starting runtime on port ${APP_SERVER_PORT}...`);
-  
-    let appServer = new AppServer({
-      projectDir: path.dirname(flowFilePath),
-      flowFilePath: flowFilePath,
-      port: APP_SERVER_PORT,
-      serverMode: AppServer.mode.HEADLESS_KUMOLOGICA,
-      logLevel: AppServer.logLevel.ERROR,
-      editorApi: undefined,
-      startupEmitter: undefined
-    });
-
-    try {
-      await appServer.start();
-      log(`> FlowFile to be tested: ${chalk.bold(path.resolve(flowFilePath))} \n`);
-      let testSuiteController = new TestSuiteController(appServer);
-      
-      // If testcase is null, default to universal wildcard
-      testcaseSelected  = testcaseSelected || "**";
-
-      // Find out all testcases available on the flow
-      let testcasesAvailable = testSuiteController.findTestCasesFromFlow(flowFilePath);
-      if (!testcasesAvailable || (testcasesAvailable && testcasesAvailable.length === 0)) {
-        logError(`No testcases found on flow file: ${flowFileAbsPath}`);
-        process.exit(1);
-      };
-      let testcaseAvailableNames = testcasesAvailable.map(tc=>tc.name);
-
-      // Capture the testcase from user on iterative mode
-      if (iterative) {
-        const prompt = new Select({
-          name: 'testcase',
-          message: 'What testcase do you want to run?',
-          choices: [...testcaseAvailableNames, 'Run all TestCases...']
-        });
-        await prompt.run()
-          .then(tc => {
-            if (tc === 'Run all TestCases...'){
-              testcaseSelected = "**";
-            }else {
-              testcaseSelected = tc;
-            }
-          })
-          .catch(err => {
-            logError(`Error found while running tests on iterative mode due to: `, err.message);
-            process.exit(1);
-          });
-      }
+const { TestSuiteRunner } = require('./test/TestSuiteRunner');
+const { DesignerServer } = require('../../src/server/DesignerServer');
+const { logError, logNotice, logInfo, logFatal } = require('../utils/logger');
 
-      // Filter all testcases to be part of the test suite
-      const isMatch = wcmatch(testcaseSelected);
-      let testCasesSelected = [];
-      testcasesAvailable.forEach(async tc => {
-        if (isMatch(tc.name)){
-          testCasesSelected.push({ name: tc.name, id: tc.id });
-        }
-      });
+const isDirectory = util.isDirectorySync;
 
-      // Execute the testcasesIds if any, otherwise throw an error
-      if (testCasesSelected.length === 0){
-        logError(`No matched testcases found`);
-        process.exit(1);
-      } else {
-        const errors = await testSuiteController.runTestSuite(testCasesSelected); 
-        process.exit(errors > 0);
-      }
-      
-    } catch (err) {
-      log(
-        chalk.red(
-          `Unexpected error occurred while starting server due to <${err.message}>`
-        )
-      );
-      console.log(err);
-      process.exit(1);
-    }
-  }
-  
-function isDirectory(dir) {
-  try{
-    let stats = fs.statSync(dir);
-    return stats.isDirectory();
-  } catch (err) {
-    return undefined;
-  }
- 
- 
-}
 
 exports.command = 'test [project_directory]';
 exports.desc = `Run test suite`;
 exports.builder = (yargs) => {
   yargs.positional(`project_directory`, {
-      type: 'string',
-      describe: 'Path to a valid kumologica project directory or flow file. (Optional)'
+    type: 'string',
+    describe: 'Path to a valid kumologica project directory or flow file. (Optional)'
   })
   yargs.option(`testcase`, {
     describe: "Testcase name to run",
     type: 'string',
     alias: 't',
     nargs: 1
-    });
-    yargs.option(`iterative`, {
-      describe: "Manually select the testcase to run from all available testcases",
-      type: 'boolean',
-      alias: 'i'
-      });
+  });
+  yargs.option(`iterative`, {
+    describe: "Manually select the testcase to run from all available testcases",
+    type: 'boolean',
+    alias: 'i'
+  });
 }
 exports.handler = ({ project_directory, testcase, iterative }) => {
   let projectDirOrFile = project_directory || process.cwd();
   let projectFlowPath = projectDirOrFile;
 
   let isDir = isDirectory(projectDirOrFile);
-  if (isDir){
+  if (isDir) {
     let flowFileName = codegen.findFlowFile(projectDirOrFile); // returns only the flowname
-    if (!flowFileName){
-      logError(`No flow found in directory: ${projectDirOrFile}`);
-      process.exit(1);
-    }else {
+    if (!flowFileName) {
+      logFatal(`No flow found in directory: ${projectDirOrFile}`);
+    } else {
       projectFlowPath = path.join(projectDirOrFile, flowFileName);
     }
-  } else if (isDir === false){
+  } else if (isDir === false) {
     // do nothing as it was assumed to be a file
   } else {
-    logError(`Directory does not exist: ${project_directory}`);
-    process.exit(1);
+    logFatal(`Directory does not exist: ${project_directory}`);
   }
 
-	try {
-		runTest(projectFlowPath, testcase, iterative);
-	} catch (e) {
-		logError(e.message);
-		process.exit(1);
-	}
+  try {
+    runTestOnNewServer(projectFlowPath, testcase, iterative);
+  } catch (e) {
+    logFatal(e.message);
+  }
+}
+
+async function runTestOnNewServer(flowFilePath, testcaseSelected, iterative) {
+  let designerServer = new DesignerServer(
+    flowFilePath,
+    false,
+    {
+      loglevel: "error",
+      noadmin: true
+    });
+
+  try {
+    await designerServer.listen();
+    logInfo(`> Flow file: ${path.resolve(flowFilePath)} \n`);
+    let testSuiteRunner = new TestSuiteRunner(designerServer);
+
+    // If testcase is null, default to universal wildcard
+    testcaseSelected = testcaseSelected || "**";
+
+    // Find out all testcases available on the flow
+    let testcasesAvailable = codegen.findTestCasesFromFlow(flowFilePath);
+    if (!testcasesAvailable || (testcasesAvailable && testcasesAvailable.length === 0)) {
+      logFatal(`No testcases found on flow file: ${flowFileAbsPath}`);
+    };
+    let testcaseAvailableNames = testcasesAvailable.map(tc => tc.name);
+
+    // Capture the testcase from user on iterative mode
+    if (iterative) {
+      const prompt = new Select({
+        name: 'testcase',
+        message: 'What testcase do you want to run?',
+        choices: [...testcaseAvailableNames, 'Run all TestCases...']
+      });
+      await prompt.run()
+        .then(tc => {
+          if (tc === 'Run all TestCases...') {
+            testcaseSelected = "**";
+          } else {
+            testcaseSelected = tc;
+          }
+        })
+        .catch(err => {
+          logFatal(`Error found while running tests on iterative mode due to: `, err.message);
+        });
+    }
+
+    // Filter all testcases to be part of the test suite
+    const isMatch = wcmatch(testcaseSelected);
+    let testCasesSelected = [];
+    testcasesAvailable.forEach(async tc => {
+      if (isMatch(tc.name)) {
+        testCasesSelected.push({ name: tc.name, id: tc.id });
+      }
+    });
+
+    // Execute the testcasesIds if any, otherwise throw an error
+    if (testCasesSelected.length === 0) {
+      logFatal(`No matched testcases found`);
+    } else {
+      const errors = await testSuiteRunner.runAll(testCasesSelected);
+      process.exit(errors > 0);
+    }
+
+  } catch (err) {
+    console.log(err);
+    logFatal(`Unexpected error occurred while starting server due to <${err.message}>`);
+  }
 }

package/cli/utils/fs/parse.js

@@ -2,7 +2,7 @@
 
 const jc = require('json-cycle');
 const yaml = require('js-yaml');
-const _ = require('lodash');
+
 // const cloudformationSchema = require('@serverless/utils/cloudformation-schema');
 
 const loadYaml = (contents, options) => {

package/cli/utils/logger.js

@@ -2,7 +2,7 @@ const chalk = require('chalk');
 
 /* Loggers */
 function logError(message) {
-    console.log(chalk.red(message));
+    console.log(chalk.red(`ERROR: ${message}`));
 }
 
 function logNotice(message) {
@@ -13,8 +13,14 @@ function logInfo(message) {
     console.log(message);
 }
 
+function logFatal(message) {
+    console.log(chalk.red(`FATAL: ${message}`));
+    process.exit(1);
+}
+
 module.exports = {
-    logError,
+    logInfo,
     logNotice,
-    logInfo
+    logError,
+    logFatal
 }