@kumologica/sdk 3.6.0-beta1 → 3.6.0-beta3

package/cli/cli.js

@@ -1,9 +1,31 @@
-const chalk = require('chalk');
+const { logError } = require("./utils/logger"); //("../utils/logger");
 
-require('yargs/yargs')(process.argv.slice(2))
-  .commandDir('commands')
-  .demandCommand()
-  .help('help', 'Show usage information & exit')
-  .alias('help', 'h')
- // .epilog("copyright 2021")
-  .argv
+const validCommands = [
+  "build",
+  "create-node",
+  "create",
+  "doc",
+  "export",
+  "list-templates",
+  "login",
+  "open",
+  "serve",
+  "test",
+];
+
+require("yargs/yargs")(process.argv.slice(2))
+  .commandDir("commands")
+  .demandCommand(1, "Error: Command missing.")
+  .check((argv) => {
+    if (!validCommands.includes(argv._[0].toLowerCase())) {
+      throw new Error(`Unknown command: ${argv._[0]}. `);
+    }
+    return true;
+  })
+  .help("help", "Show usage information & exit")
+  .alias("help", "h")
+  .fail((msg, err, yargs) => {
+    logError(msg);
+    yargs.showHelp();
+    process.exit(1);
+  }).argv;

package/cli/commands/serve.js

@@ -0,0 +1,139 @@
+/**
+ * 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)
+ *
+ * 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
+ *
+ * DEVELOPER NOTE:
+ * 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 = "serve [project_directory]";
+exports.desc = `Start a local HTTP server to serve a project`;
+
+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,
+  });
+};
+
+exports.handler = async ({ project_directory, loglevel, port, secured }) => {
+  logNotice(`Starting HTTP Server...`);
+  let projectDirectory = project_directory || process.cwd();
+  // project_directory can point to a directory or a flow, so lets make sure that first the directory exists
+  let absProjectDirectory;
+
+  try {
+    absProjectDirectory = fs.realpathSync(projectDirectory);
+  } catch (err) {
+    logFatal(`Project not found: ${projectDirectory}`);
+    process.exit(1);
+  }
+
+  try {
+    // Resolve the path to the flow path
+    const [projectFlowDirname, projectFlowFullPath] =
+      resolveProjectFlowPath(absProjectDirectory);
+    logInfo(`> Flow file found: ${projectFlowFullPath}`);
+
+    // Gather all cli params
+    const cliParams = {
+      loglevel,
+      port,
+      noadmin: true,
+    };
+
+    // Start a server
+    let server = new DesignerServer({
+      flowPath: projectFlowFullPath,
+      cliParams,
+    });
+
+    await server.start();
+
+    // open("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: ${projectDirOrFile}`);
+    process.exit(1);
+  }
+
+  return [projectFlowDirname, projectFlowFullPath];
+}
+
+function isDirectory(dir) {
+  try {
+    let stats = fs.statSync(dir);
+    return stats.isDirectory();
+  } catch (err) {
+    return undefined;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumologica/sdk",
-  "version": "3.6.0-beta1",
+  "version": "3.6.0-beta3",
   "productName": "Kumologica Designer",
   "copyright": "Copyright 2020 Kumologica Pty Ltd, All Rights Reserved.",
   "author": "Kumologica Pty Ltd <contact@kumologica.com>",
@@ -82,9 +82,9 @@
     "@aws-sdk/credential-providers": "^3.556.0",
     "@aws-sdk/lib-dynamodb": "^3.549.0",
     "@electron/remote": "^2.0.8",
-    "@kumologica/builder": "3.6.0-beta1",
-    "@kumologica/devkit": "3.6.0-beta1",
-    "@kumologica/runtime": "3.6.0-beta1",
+    "@kumologica/builder": "3.6.0-beta3",
+    "@kumologica/devkit": "3.6.0-beta3",
+    "@kumologica/runtime": "3.6.0-beta3",
     "adm-zip": "0.4.13",
     "ajv": "8.10.0",
     "archive-type": "^4.0.0",

package/src/server/DesignerServer.js

@@ -1,10 +1,11 @@
 const {
-    AbstractServerfulServer,
-    ConfigBuilder,
-    PLATFORMS
-} = require('@kumologica/runtime');
-const tcpPortUsed = require('tcp-port-used');
+  AbstractServerfulServer,
+  ConfigBuilder,
+  PLATFORMS,
+} = require("@kumologica/runtime");
+const tcpPortUsed = require("tcp-port-used");
 
+const os = require("os");
 /**
  * This class will encapsulate the adminApp and FlowApp into two servers.
  * It will be the one running on the development box of the user (either local or remote),
@@ -12,155 +13,153 @@ const tcpPortUsed = require('tcp-port-used');
  */
 
 class DesignerServer {
-    
-    /**
-    * @param {Object} options - Configuration options.
-    * @param {string} options.flowPath - The path of the flow.
-    * @param {boolean} options.safe - A boolean indicating safety.
-    * @param {Object} options.cliParams - Command line parameters as an object.
-    * @param {Object} options.editorApi - API object for the editor.
-    * @param {Object} options.startupEmitter - EventEmitter object for handling events.
-    * @param {string} options.platform - The platform to run on. Default LOCAL.
-    */
-    constructor(options) {
-
-        if (!options.flowPath) {
-            console.log(
-                '[ERROR] Flow is not defined. Make sure you pass the flow file to the constructor of FlowBuilder'
-            );
-            os.exit(1);
-        }
-
-        this.editorApi = options.editorApi;
-        this.startupEmitter = options.startupEmitter;
-
-        this.config = ConfigBuilder.getInstance().buildConfig(
-            options.flowPath,
-            options.platform || PLATFORMS.LOCAL,
-            options.cliParams
-        );
-    }
-
-    async start() {
-        // Check if port passed by parameter is available otherwise allocate a new one
-        this.config.port = await this.allocatePort(this.config.port);
-        this.flowServer = new AbstractServerfulServer(this.config, this.editorApi, this.startupEmitter);
-
-        await this.flowServer.start();
-        this.flowServer.log.debug(`Runtime Configuration:${JSON.stringify(this.config, null, 2)}`);
-    }
-
-    async allocatePort(port) {
-        let inUse = await tcpPortUsed.check(port);
-        if (inUse){
-            let newPort = port + 1;
-            console.log(`> Port: ${port} in use. Trying with port: ${newPort}...`);
-            return await this.allocatePort(newPort);
-        } else{
-            return port;
-        }
-    }
-
-    getFlowServer() {
-        return this.flowServer;
-    }
-
-    getListeningPort() {
-        return this.flowServer.serverSettings.port;
-    }
-
-    async stop() {
-        await this.flowServer.stop();
-    }
-
-    /**
-     * The express application for HTTP Nodes
-     */
-     get httpNode() {
-        return this.flowServer.httpNode.expressApp;
-    }
-
-
-
-    /**
-     * Pointer to the internal HTTP Server upon which all the express applications (Nodes and Admin) are deployed upon
-     *
-     * @readonly
-     */
-    get server() {
-        return this.flowServer.server;
-    }
-
-    /**
-     * Access to internal runtime api
-     */
-    get runtime() {
-        return this.flowServer.runtime;
-    }
-
-
-
-    /**
-     *
-     * Returns the version of the runtime lib used internally
-     * @readonly
-     * @static
-     */
-    static get version() {
-        return AbstractServerfulServer.version;
-    }
-
-    /**
-     * This provides access to the internal settings module of the
-     * runtime.
-     * This is the object derived from the server settings.
-     */
-    get settings() {
-        return this.flowServer._.settings;
-    }
-
-    /**
-     * EventEmitter use to publish and subscribe to internal runtime events
-     * For example:
-     *  runtime.events.on(
-     *     'runtime-event',
-     *     (flowStarted = async data => {
-     *       if (data.id === 'flow-started') {
-     *         runtime.events.removeListener('runtime-event', flowStarted);
-     *
-     * @readonly
-     */
-    get events() {
-        return this.flowServer.events;
-    }
-
-    get eventTypes() {
-        return this.flowServer.runtimeEventTypes;
-    }
-
-    /**
-     * This provides access to the internal nodes module of the
-     * runtime. The details of this API remain undocumented as they should not
-     * be used directly.
-     *
-     * Most administrative actions should be performed use the runtime api
-     * under [node.runtime]
-     */
-    get nodes() {
-        return this.flowServer._.nodes;
-    }
-
-    get log() {
-        return this.flowServer.log;
-    }
-
-    get util() {
-        return this.flowServer.util;
-    }
-
-
+  /**
+   * @param {Object} options - Configuration options.
+   * @param {string} options.flowPath - The path of the flow.
+   * @param {boolean} options.safe - A boolean indicating safety.
+   * @param {Object} options.cliParams - Command line parameters as an object.
+   * @param {Object} options.editorApi - API object for the editor.
+   * @param {Object} options.startupEmitter - EventEmitter object for handling events.
+   * @param {string} options.platform - The platform to run on. Default LOCAL.
+   */
+  constructor(options) {
+    if (!options.flowPath) {
+      console.log(
+        "[ERROR] Flow is not defined. Make sure you pass the flow file to the constructor of FlowBuilder"
+      );
+      os.exit(1);
+    }
+
+    this.editorApi = options.editorApi;
+    this.startupEmitter = options.startupEmitter;
+
+    this.config = ConfigBuilder.getInstance().buildConfig(
+      options.flowPath,
+      options.platform || PLATFORMS.LOCAL,
+      options.cliParams
+    );
+  }
+
+  async start() {
+    // Check if port passed by parameter is available otherwise allocate a new one
+    this.config.port = await this.allocatePort(this.config.port);
+    this.flowServer = new AbstractServerfulServer(
+      this.config,
+      this.editorApi,
+      this.startupEmitter
+    );
+
+    await this.flowServer.start();
+    this.flowServer.log.debug(
+      `Runtime Configuration:${JSON.stringify(this.config, null, 2)}`
+    );
+  }
+
+  async allocatePort(port) {
+    let inUse = await tcpPortUsed.check(port);
+    if (inUse) {
+      let newPort = port + 1;
+      console.log(`> Port: ${port} in use. Trying with port: ${newPort}...`);
+      return await this.allocatePort(newPort);
+    } else {
+      return port;
+    }
+  }
+
+  getFlowServer() {
+    return this.flowServer;
+  }
+
+  getListeningPort() {
+    return this.flowServer.serverSettings.port;
+  }
+
+  async stop() {
+    await this.flowServer.stop();
+  }
+
+  /**
+   * The express application for HTTP Nodes
+   */
+  get httpNode() {
+    return this.flowServer.httpNode.expressApp;
+  }
+
+  /**
+   * Pointer to the internal HTTP Server upon which all the express applications (Nodes and Admin) are deployed upon
+   *
+   * @readonly
+   */
+  get server() {
+    return this.flowServer.server;
+  }
+
+  /**
+   * Access to internal runtime api
+   */
+  get runtime() {
+    return this.flowServer.runtime;
+  }
+
+  /**
+   *
+   * Returns the version of the runtime lib used internally
+   * @readonly
+   * @static
+   */
+  static get version() {
+    return AbstractServerfulServer.version;
+  }
+
+  /**
+   * This provides access to the internal settings module of the
+   * runtime.
+   * This is the object derived from the server settings.
+   */
+  get settings() {
+    return this.flowServer._.settings;
+  }
+
+  /**
+   * EventEmitter use to publish and subscribe to internal runtime events
+   * For example:
+   *  runtime.events.on(
+   *     'runtime-event',
+   *     (flowStarted = async data => {
+   *       if (data.id === 'flow-started') {
+   *         runtime.events.removeListener('runtime-event', flowStarted);
+   *
+   * @readonly
+   */
+  get events() {
+    return this.flowServer.events;
+  }
+
+  get eventTypes() {
+    return this.flowServer.runtimeEventTypes;
+  }
+
+  /**
+   * This provides access to the internal nodes module of the
+   * runtime. The details of this API remain undocumented as they should not
+   * be used directly.
+   *
+   * Most administrative actions should be performed use the runtime api
+   * under [node.runtime]
+   */
+  get nodes() {
+    return this.flowServer._.nodes;
+  }
+
+  get log() {
+    return this.flowServer.log;
+  }
+
+  get util() {
+    return this.flowServer.util;
+  }
 }
 
 module.exports = {
-    DesignerServer,
+  DesignerServer,
 };