noflo 1.4.3 → 1.5.1

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,25 +8,34 @@ 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;
-try {
-  // eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
-  CoffeeScript = require('coffeescript');
-} catch (e) {
-  // If there is no CoffeeScript compiler installed, we simply don't support compiling
-}
+// eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
+import('coffeescript')
+  .then((compiler) => {
+    CoffeeScript = compiler;
+  })
+  .catch((e) => {
+    // If there is no CoffeeScript compiler installed, we simply don't support compiling
+  });
 
 // Try loading TypeScript compiler
 let typescript;
-try {
-  // eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
-  typescript = require('typescript');
-} catch (e) {
-  // If there is no TypeScript compiler installed, we simply don't support compiling
-}
+// eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
+import('typescript')
+  .then((compiler) => {
+    // @ts-ignore
+    typescript = compiler.default;
+    })
+  .catch((e) => {
+    // If there is no TypeScript compiler installed, we simply don't support compiling
+  });
 
 /**
  * @callback ErrorableCallback
@@ -43,38 +52,35 @@ 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, {
           module: typescript.ModuleKind.CommonJS,
-          target: typescript.ScriptTarget.ES2015,
+          target: typescript.ScriptTarget.ES2020,
         });
       } catch (err) {
-        callback(err);
-        return;
+        return Promise.reject(err);
       }
       break;
     }
@@ -86,49 +92,42 @@ 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) {
-  const Module = require('module');
-  let implementation;
-  try {
-    // Use the Node.js module API to evaluate in the correct directory context
-    const modulePath = path.resolve(baseDir, `./components/${name}.js`);
-    const moduleImpl = new Module(modulePath, module);
-    // @ts-ignore
-    moduleImpl.paths = Module._nodeModulePaths(path.dirname(modulePath));
-    moduleImpl.filename = modulePath;
-    // @ts-ignore
-    moduleImpl._compile(source, modulePath);
-    implementation = moduleImpl.exports;
-  } catch (e) {
-    callback(e);
-    return;
-  }
-  if ((typeof implementation !== 'function') && (typeof implementation.getComponent !== 'function')) {
-    callback(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
-    return;
-  }
-  callback(null, implementation);
+function evaluateModule(baseDir, packageId, name, source) {
+  return import('module')
+    .then(({ Module }) => {
+      let implementation;
+      // Use the Node.js module API to evaluate in the correct directory context
+      let extension = '.js';
+      if (source.indexOf('require(') !== -1) {
+        // CommonJS
+        extension = '.cjs';
+      }
+      const modulePath = path.resolve(baseDir, `./components/${name}${extension}`);
+      const moduleImpl = new Module(modulePath);
+      // @ts-ignore
+      moduleImpl.paths = Module._nodeModulePaths(path.dirname(modulePath));
+      moduleImpl.filename = modulePath;
+      // @ts-ignore
+      moduleImpl._compile(source, modulePath);
+      implementation = moduleImpl.exports;
+      if ((typeof implementation !== 'function') && (typeof implementation.getComponent !== 'function')) {
+        return Promise.reject(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
+      }
+      return Promise.resolve(implementation);
+    });
 }
 
 /**
@@ -167,30 +166,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 +206,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);
 }
 
 /**
@@ -371,9 +376,14 @@ export function getLanguages() {
  */
 function registerCustomLoaders(loader, componentLoaders, callback) {
   componentLoaders.reduce((chain, componentLoader) => chain
-    .then(() => new Promise((resolve, reject) => {
-      const customLoader = require(componentLoader);
-      loader.registerLoader(customLoader, (err) => {
+    .then(() => import(componentLoader))
+    .then((customLoader) => new Promise((resolve, reject) => {
+      let loaderFunc = customLoader;
+      if (typeof customLoader === 'object' && customLoader.default) {
+        // CommonJS loader
+        loaderFunc = customLoader.default;
+      }
+      loader.registerLoader(loaderFunc, (err) => {
         if (err) {
           reject(err);
           return;
@@ -388,18 +398,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 +419,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 +451,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 +528,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 +572,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);
 }
 
@@ -605,34 +624,22 @@ export function register(loader, callback) {
  * @param {ModuleLoadingCallback} callback
  */
 export function dynamicLoad(name, cPath, metadata, callback) {
-  let implementation; let instance;
-  try {
-    implementation = require(cPath);
-  } catch (err) {
-    callback(err);
-    return;
-  }
-
-  if (typeof implementation.getComponent === 'function') {
-    try {
-      instance = implementation.getComponent(metadata);
-    } catch (err) {
-      callback(err);
-      return;
-    }
-  } else if (typeof implementation === 'function') {
-    try {
-      instance = implementation(metadata);
-    } catch (err) {
-      callback(err);
-      return;
-    }
-  } else {
-    callback(new Error(`Unable to instantiate ${cPath}`));
-    return;
-  }
-  if (typeof name === 'string') {
-    instance.componentName = name;
-  }
-  callback(null, instance);
+  import(cPath)
+    .then((implementation) => {
+      let instance;
+      if (typeof implementation.getComponent === 'function') {
+        instance = implementation.getComponent(metadata);
+      } else if (typeof implementation === 'function') {
+        instance = implementation(metadata);
+      } else {
+        throw new Error(`Unable to instantiate ${cPath}`);
+      }
+      if (typeof name === 'string') {
+        instance.componentName = name;
+      }
+      callback(null, instance);
+    })
+    .catch((e) => {
+      callback(e)
+    });
 }

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';