noflo 1.4.2 → 1.5.0

package/src/lib/Ports.js

@@ -3,17 +3,11 @@
 //     (c) 2014-2017 Flowhub UG
 //     NoFlo may be freely distributed under the MIT license
 import { EventEmitter } from 'events';
-import InPort from './InPort';
-import OutPort from './OutPort';
+import InPort from './InPort.js';
+import OutPort from './OutPort.js';
 
 /**
- * @typedef PortOptions
- * @property {string} [description='']
- * @property {string} [datatype='all']
- * @property {string} [schema=null]
- * @property {string} [type=null]
- * @property {boolean} [required=false]
- * @property {boolean} [scoped=true]
+ * @typedef {import("./BasePort").BaseOptions} PortOptions
  */
 
 // NoFlo ports collections
@@ -83,7 +77,7 @@ class Ports extends EventEmitter {
 }
 
 /**
- * @typedef {{ [key: string]: InPort|PortOptions }} InPortsOptions
+ * @typedef {{ [key: string]: InPort|import("./InPort").PortOptions }} InPortsOptions
  */
 export class InPorts extends Ports {
   /**
@@ -91,11 +85,13 @@ export class InPorts extends Ports {
    */
   constructor(ports = {}) {
     super(ports, InPort);
+    const basePorts = this.ports;
+    this.ports = /** @type {Object<string, InPort>} */ (basePorts);
   }
 }
 
 /**
- * @typedef {{ [key: string]: OutPort|PortOptions }} OutPortsOptions
+ * @typedef {{ [key: string]: OutPort|import("./OutPort").PortOptions }} OutPortsOptions
  */
 export class OutPorts extends Ports {
   /**
@@ -103,6 +99,8 @@ export class OutPorts extends Ports {
    */
   constructor(ports = {}) {
     super(ports, OutPort);
+    const basePorts = this.ports;
+    this.ports = /** @type {Object<string, OutPort>} */ (basePorts);
   }
 
   connect(name, socketId) {

package/src/lib/ProcessInput.js

@@ -4,7 +4,7 @@
 //     NoFlo may be freely distributed under the MIT license
 /* eslint-disable no-underscore-dangle */
 import debug from 'debug';
-import IP from './IP'; // eslint-disable-line no-unused-vars
+import IP from './IP.js'; // eslint-disable-line no-unused-vars
 
 const debugComponent = debug('noflo:component');
 
@@ -71,13 +71,9 @@ export default class ProcessInput {
   // Returns true if a port (or ports joined by logical AND) has a new IP
   // Passing a validation callback as a last argument allows more selective
   // checking of packets.
-  /**
-   * @callback HasValidationCallback
-   * @param {IP} ip
-   * @returns {boolean}
-   */
   /**
    * @typedef {string|Array<string|number>} GetArgument
+   * @typedef {import("./InPort").HasValidationCallback} HasValidationCallback
    */
   /**
    * @typedef {GetArgument|HasValidationCallback} HasArgument
@@ -86,13 +82,14 @@ export default class ProcessInput {
    * @param {...HasArgument} params
    */
   has(...params) {
+    /** @type {HasValidationCallback} */
     let validate;
     let args = params.filter((p) => typeof p !== 'function');
     if (!args.length) {
       args = ['in'];
     }
     if (typeof params[params.length - 1] === 'function') {
-      validate = params[params.length - 1];
+      validate = /** @type {HasValidationCallback} */ (params[params.length - 1]);
     } else {
       validate = () => true;
     }
@@ -106,7 +103,8 @@ export default class ProcessInput {
         if (!portImpl.isAddressable()) {
           throw new Error(`Non-addressable ports, access must be with string ${port[0]}`);
         }
-        if (!portImpl.has(this.scope, port[1], validate)) { return false; }
+        const portIdx = (typeof port[1] === 'string') ? parseInt(port[1], 10) : port[1];
+        if (!portImpl.has(this.scope, portIdx, validate)) { return false; }
       } else if (typeof port === 'string') {
         const portImpl = /** @type {import("./InPort").default} */ (this.ports.ports[port]);
         if (!portImpl) {
@@ -229,7 +227,7 @@ export default class ProcessInput {
         res.push(ip);
       } else {
         const portImpl = /** @type {import("./InPort").default} */ (this.ports.ports[name]);
-        ip = portImpl.get(this.scope, idx);
+        ip = portImpl.get(this.scope, idxName);
         res.push(ip);
       }
     }

package/src/lib/ProcessOutput.js

@@ -5,7 +5,7 @@
 
 /* eslint-disable no-underscore-dangle */
 import debug from 'debug';
-import IP from './IP';
+import IP from './IP.js';
 
 const debugComponent = debug('noflo:component');
 

package/src/lib/loader/NodeJs.js

@@ -8,7 +8,11 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as manifest from 'fbp-manifest';
 import * as fbpGraph from 'fbp-graph';
-import * as utils from '../Utils';
+import { promisify } from 'util';
+import * as utils from '../Utils.js';
+
+const writeFile = promisify(fs.writeFile);
+const readFile = promisify(fs.readFile);
 
 // Type loading CoffeeScript compiler
 let CoffeeScript;
@@ -43,29 +47,27 @@ try {
  * @param {string} name
  * @param {string} source
  * @param {string} language
- * @param {TranspileCallback} callback
- * @returns {void}
+ * @returns {Promise<string>}
  */
-function transpileSource(packageId, name, source, language, callback) {
+function transpileSource(packageId, name, source, language) {
   let src;
   switch (language) {
     case 'coffeescript': {
       if (!CoffeeScript) {
-        callback(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no CoffeeScript compiler installed`));
+        return Promise.reject(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no CoffeeScript compiler installed`));
       }
       try {
         src = CoffeeScript.compile(source, {
           bare: true,
         });
       } catch (err) {
-        callback(err);
-        return;
+        return Promise.reject(err);
       }
       break;
     }
     case 'typescript': {
       if (!typescript) {
-        callback(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no TypeScript compiler installed`));
+        return Promise.reject(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no TypeScript compiler installed`));
       }
       try {
         src = typescript.transpile(source, {
@@ -73,8 +75,7 @@ function transpileSource(packageId, name, source, language, callback) {
           target: typescript.ScriptTarget.ES2015,
         });
       } catch (err) {
-        callback(err);
-        return;
+        return Promise.reject(err);
       }
       break;
     }
@@ -86,28 +87,20 @@ function transpileSource(packageId, name, source, language, callback) {
       break;
     }
     default: {
-      callback(new Error(`Unsupported component source language ${language} for ${packageId}/${name}`));
-      return;
+      return Promise.reject(new Error(`Unsupported component source language ${language} for ${packageId}/${name}`));
     }
   }
-  callback(null, src);
+  return Promise.resolve(src);
 }
 
-/**
- * @callback EvaluationCallback
- * @param {Error|null} error
- * @param {Object|Function} [module]
- * @returns {void}
- */
 /**
  * @param {string} baseDir
  * @param {string} packageId
  * @param {string} name
  * @param {string} source
- * @param {EvaluationCallback} callback
- * @returns {void}
+ * @returns {Promise<Object|Function>}
  */
-function evaluateModule(baseDir, packageId, name, source, callback) {
+function evaluateModule(baseDir, packageId, name, source) {
   const Module = require('module');
   let implementation;
   try {
@@ -121,14 +114,12 @@ function evaluateModule(baseDir, packageId, name, source, callback) {
     moduleImpl._compile(source, modulePath);
     implementation = moduleImpl.exports;
   } catch (e) {
-    callback(e);
-    return;
+    return Promise.reject(e);
   }
   if ((typeof implementation !== 'function') && (typeof implementation.getComponent !== 'function')) {
-    callback(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
-    return;
+    return Promise.reject(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
   }
-  callback(null, implementation);
+  return Promise.resolve(implementation);
 }
 
 /**
@@ -167,30 +158,31 @@ function registerSpecs(loader, packageId, name, specs) {
 
 /**
  * @param {import("../ComponentLoader").ComponentLoader} loader
- * @param {Object} module
- * @param {Object} component
+ * @param {import("fbp-manifest/dist/lib/list").FbpManifestModule} module
+ * @param {import("fbp-manifest/dist/lib/list").FbpManifestComponent} component
  * @param {string} source
  * @param {string} language
- * @param {TranspileCallback} callback
- * @returns {void}
+ * @returns {Promise<void>}
  */
-function transpileAndRegisterForModule(loader, module, component, source, language, callback) {
-  transpileSource(module.name, component.name, source, language, (transpileError, src) => {
-    if (transpileError) {
-      callback(transpileError);
-      return;
-    }
-    const moduleBase = path.resolve(loader.baseDir, module.base);
-    evaluateModule(moduleBase, module.name, component.name, src, (evalError, implementation) => {
-      if (evalError) {
-        callback(evalError);
-        return;
-      }
+function transpileAndRegisterForModule(loader, module, component, source, language) {
+  return transpileSource(module.name, component.name, source, language)
+    .then((src) => {
+      const moduleBase = path.resolve(loader.baseDir, module.base);
+      return evaluateModule(moduleBase, module.name, component.name, src);
+    })
+    .then((implementation) => {
       registerSources(loader, module.name, component.name, source, language);
-      registerSpecs(loader, module.name, component.name, component.tests);
-      loader.registerComponent(module.name, component.name, implementation, callback);
+      registerSpecs(loader, module.name, component.name, component.tests || '');
+      return new Promise((resolve, reject) => {
+        loader.registerComponent(module.name, component.name, implementation, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve();
+        });
+      });
     });
-  });
 }
 
 /**
@@ -206,9 +198,14 @@ export function setSource(loader, packageId, name, source, language, callback) {
   transpileAndRegisterForModule(loader, {
     name: packageId,
     base: '',
+    components: [],
+    runtime: 'noflo',
   }, {
     name,
-  }, source, language, callback);
+  }, source, language)
+    .then(() => {
+      callback(null);
+    }, callback);
 }
 
 /**
@@ -388,18 +385,19 @@ function registerCustomLoaders(loader, componentLoaders, callback) {
 
 /**
  * @param {import("../ComponentLoader").ComponentLoader} loader
- * @param {Array<Object>} modules
+ * @param {Array<import("fbp-manifest/dist/lib/list").FbpManifestModule>} modules
  * @param {ErrorableCallback} callback
  */
 function registerModules(loader, modules, callback) {
   const compatible = modules.filter((m) => ['noflo', 'noflo-nodejs'].includes(m.runtime));
+  /** @type {string[]} */
   const componentLoaders = [];
   Promise.all(compatible.map((m) => {
     if (m.icon) {
       loader.setLibraryIcon(m.name, m.icon);
     }
 
-    if (m.noflo != null ? m.noflo.loader : undefined) {
+    if (m.noflo && m.noflo.loader) {
       const loaderPath = path.resolve(loader.baseDir, m.base, m.noflo.loader);
       componentLoaders.push(loaderPath);
     }
@@ -408,19 +406,15 @@ function registerModules(loader, modules, callback) {
       const language = utils.guessLanguageFromFilename(c.path);
       if (language === 'typescript' || language === 'coffeescript') {
         // We can't require a module that requires transpilation, go the setSource route
-        fs.readFile(path.resolve(loader.baseDir, c.path), 'utf-8', (fsErr, source) => {
-          if (fsErr) {
-            reject(fsErr);
-            return;
-          }
-          transpileAndRegisterForModule(loader, m, c, source, language, (err) => {
-            if (err) {
-              reject(err);
-              return;
-            }
-            resolve();
-          });
-        });
+        readFile(path.resolve(loader.baseDir, c.path), 'utf-8')
+          .then((source) => transpileAndRegisterForModule(
+            loader,
+            m,
+            c,
+            source,
+            language,
+          ))
+          .then(resolve, reject);
         return;
       }
       registerSpecs(loader, m.name, c.name, c.tests);
@@ -444,63 +438,72 @@ function registerModules(loader, modules, callback) {
 const dynamicLoader = {
   /**
    * @param {import("../ComponentLoader").ComponentLoader} loader
-   * @param {Object} manifestOptions
+   * @param {import("fbp-manifest/dist/lib/list").FbpManifestOptions} manifestOptions
    * @param {Function} callback
    */
   listComponents(loader, manifestOptions, callback) {
     const opts = manifestOptions;
     opts.discover = true;
-    manifest.list.list(loader.baseDir, opts, (err, modules) => {
-      if (err) {
-        callback(err);
-        return;
-      }
-      registerModules(loader, modules, (err2) => {
-        if (err2) {
-          callback(err2);
-          return;
-        }
+    manifest.list.list(loader.baseDir, opts)
+      .then((modules) => new Promise((resolve, reject) => {
+        registerModules(loader, modules, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(modules);
+        });
+      }))
+      .then((modules) => {
         callback(null, modules);
+      }, (err) => {
+        callback(err);
       });
-    });
   },
 };
 
 const manifestLoader = {
   /**
    * @param {import("../ComponentLoader").ComponentLoader} loader
-   * @param {Object} options
+   * @param {import("fbp-manifest/dist/lib/list").FbpManifestOptions} options
    * @param {Object} manifestContents
-   * @param {ErrorableCallback} callback
+   * @param {import("fbp-manifest/src/lib/list").FbpManifestDocument} manifestContents
+   * @returns {Promise<import("fbp-manifest/dist/lib/list").FbpManifestDocument>}
    */
-  writeCache(loader, options, manifestContents, callback) {
-    const filePath = path.resolve(loader.baseDir, options.manifest);
-    fs.writeFile(filePath, JSON.stringify(manifestContents, null, 2),
-      { encoding: 'utf-8' },
-      callback);
+  writeCache(loader, options, manifestContents) {
+    const manifestName = options.manifest || 'fbp.json';
+    const filePath = path.resolve(loader.baseDir, manifestName);
+
+    return writeFile(filePath, JSON.stringify(manifestContents, null, 2), {
+      encoding: 'utf-8',
+    })
+      .then(() => manifestContents);
   },
 
   /**
    * @param {import("../ComponentLoader").ComponentLoader} loader
-   * @param {Object} options
-   * @param {Function} callback
+   * @param {import("fbp-manifest/dist/lib/list").FbpManifestOptions} options
+   * @returns {Promise<import("fbp-manifest/dist/lib/list").FbpManifestDocument>}
    */
-  readCache(loader, options, callback) {
-    const opts = options;
-    opts.discover = false;
-    manifest.load.load(loader.baseDir, opts, callback);
+  readCache(loader, options) {
+    return manifest.load.load(loader.baseDir, {
+      ...options,
+      discover: false,
+    });
   },
 
   /**
    * @param {import("../ComponentLoader").ComponentLoader} loader
-   * @returns {Object}
+   * @returns {import("fbp-manifest/dist/lib/list").FbpManifestOptions}
    */
   prepareManifestOptions(loader) {
     const l = loader;
     if (!l.options) { l.options = {}; }
     const options = {};
     options.runtimes = l.options.runtimes || [];
-    if (options.runtimes.indexOf('noflo') === -1) { options.runtimes.push('noflo'); }
+    if (options.runtimes.indexOf('noflo') === -1) {
+      options.runtimes.push('noflo');
+    }
     options.recursive = typeof l.options.recursive === 'undefined' ? true : l.options.recursive;
     options.manifest = l.options.manifest || 'fbp.json';
     return options;
@@ -512,39 +515,42 @@ const manifestLoader = {
    * @param {Function} callback
    */
   listComponents(loader, manifestOptions, callback) {
-    this.readCache(loader, manifestOptions, (err, manifestContents) => {
-      if (err) {
+    this.readCache(loader, manifestOptions)
+      .catch((err) => {
         if (!loader.options.discover) {
-          callback(err);
-          return;
+          return Promise.reject(err);
         }
-        dynamicLoader.listComponents(loader, manifestOptions, (err2, modules) => {
-          if (err2) {
-            callback(err2);
-            return;
-          }
-          this.writeCache(loader, manifestOptions, {
-            version: 1,
-            modules,
-          },
-          (err3) => {
-            if (err3) {
-              callback(err3);
+        return new Promise((resolve, reject) => {
+          dynamicLoader.listComponents(loader, manifestOptions, (err2, modules) => {
+            if (err2) {
+              reject(err2);
               return;
             }
-            callback(null, modules);
+            resolve(modules);
+          });
+        })
+          .then((modules) => {
+            const manifestContents = {
+              version: 1,
+              modules,
+            };
+            return this
+              .writeCache(loader, manifestOptions, manifestContents)
+              .then(() => manifestContents);
           });
+      })
+      .then((manifestContents) => {
+        registerModules(loader, manifestContents.modules, (err) => {
+          if (err) {
+            callback(err);
+            return;
+          }
+          callback(null, manifestContents.modules);
         });
-        return;
-      }
-      registerModules(loader, manifestContents.modules, (err2) => {
-        if (err2) {
-          callback(err2);
-          return;
-        }
-        callback(null, manifestContents.modules);
+      })
+      .catch((err) => {
+        callback(err);
       });
-    });
   },
 };
 
@@ -553,7 +559,7 @@ const manifestLoader = {
  */
 function registerSubgraph(loader) {
   // Inject subgraph component
-  const graphPath = path.resolve(__dirname, '../../components/Graph.js');
+  const graphPath = path.resolve(import.meta.dirname, '../../components/Graph.js');
   loader.registerComponent(null, 'Graph', graphPath);
 }
 

package/src/lib/loader/register.js

@@ -1,10 +1,10 @@
 /* eslint-disable
     global-require,
 */
-import { isBrowser } from '../Platform';
+import { isBrowser } from '../Platform.js';
 
 if (isBrowser()) {
   throw new Error('Generate NoFlo component loader for browsers with noflo-component-loader');
 }
 
-export * from './NodeJs';
+export * from './NodeJs.js';