noflo 1.4.3 → 1.5.1

package/spec/Scoping.js

@@ -346,31 +346,26 @@ describe('Scope isolation', () => {
     let in1 = null;
     let in2 = null;
     let out = null;
-    before((done) => {
+    before(() => {
       const fbpData = 'INPORT=Pc1.IN:IN1\n'
                     + 'INPORT=Pc2.IN:IN2\n'
                     + 'OUTPORT=PcMerge.OUT:OUT\n'
                     + 'Pc1(process/Async) -> IN1 PcMerge(process/MergeUnscoped)\n'
                     + 'Pc2(process/Async) -> IN2 PcMerge(process/MergeUnscoped)';
-      noflo.graph.loadFBP(fbpData, (err, g) => {
-        if (err) {
-          done(err);
-          return;
-        }
-        loader.registerComponent('scope', 'MergeUnscoped', g);
-        loader.load('scope/MergeUnscoped', (err, instance) => {
-          if (err) {
-            done(err);
-            return;
-          }
+      return noflo.graph
+        .loadFBP(fbpData)
+        .then((g) => {
+          loader.registerComponent('scope', 'MergeUnscoped', g);
+          return loader.load('scope/MergeUnscoped');
+        })
+        .then((instance) => {
           c = instance;
           in1 = noflo.internalSocket.createSocket();
           c.inPorts.in1.attach(in1);
           in2 = noflo.internalSocket.createSocket();
           c.inPorts.in2.attach(in2);
-          c.setUp(done);
+          return c.setUp();
         });
-      });
     });
     beforeEach(() => {
       out = noflo.internalSocket.createSocket();
@@ -489,31 +484,26 @@ describe('Scope isolation', () => {
     let in1 = null;
     let in2 = null;
     let out = null;
-    before((done) => {
+    before(() => {
       const fbpData = 'INPORT=Pc1.IN:IN1\n'
                     + 'INPORT=Pc2.IN:IN2\n'
                     + 'OUTPORT=PcMerge.OUT:OUT\n'
                     + 'Pc1(process/Unscope) -> IN1 PcMerge(process/Merge)\n'
                     + 'Pc2(process/Unscope) -> IN2 PcMerge';
-      noflo.graph.loadFBP(fbpData, (err, g) => {
-        if (err) {
-          done(err);
-          return;
-        }
-        loader.registerComponent('scope', 'MergeUnscopedOut', g);
-        loader.load('scope/MergeUnscopedOut', (err, instance) => {
-          if (err) {
-            done(err);
-            return;
-          }
+      return noflo.graph
+        .loadFBP(fbpData)
+        .then((g) => {
+          loader.registerComponent('scope', 'MergeUnscopedOut', g);
+          return loader.load('scope/MergeUnscopedOut');
+        })
+        .then((instance) => {
           c = instance;
           in1 = noflo.internalSocket.createSocket();
           c.inPorts.in1.attach(in1);
           in2 = noflo.internalSocket.createSocket();
           c.inPorts.in2.attach(in2);
-          c.setUp(done);
+          return c.setUp();
         });
-      });
     });
     beforeEach(() => {
       out = noflo.internalSocket.createSocket();
@@ -631,29 +621,24 @@ describe('Scope isolation', () => {
     let c = null;
     let in1 = null;
     let out = null;
-    before((done) => {
+    before(() => {
       const fbpData = 'INPORT=Pc1.IN:IN1\n'
                     + 'OUTPORT=PcMergeA.OUT:OUT\n'
                     + 'Pc1(process/Async) -> IN1 PcMergeA(process/MergeA)\n'
                     + '\'twoIIP0\' -> IN2[0] PcMergeA\n'
                     + '\'twoIIP1\' -> IN2[1] PcMergeA';
-      noflo.graph.loadFBP(fbpData, (err, g) => {
-        if (err) {
-          done(err);
-          return;
-        }
-        loader.registerComponent('scope', 'MergeIIPA', g);
-        loader.load('scope/MergeIIPA', (err, instance) => {
-          if (err) {
-            done(err);
-            return;
-          }
+      return noflo.graph
+        .loadFBP(fbpData)
+        .then((g) => {
+          loader.registerComponent('scope', 'MergeIIPA', g);
+          return loader.load('scope/MergeIIPA');
+        })
+        .then((instance) => {
           c = instance;
           in1 = noflo.internalSocket.createSocket();
           c.inPorts.in1.attach(in1);
-          c.setUp(done);
+          return c.setUp();
         });
-      });
     });
     beforeEach(() => {
       out = noflo.internalSocket.createSocket();

package/spec/Subgraph.js

@@ -8,22 +8,17 @@ describe('NoFlo Graph component', () => {
   let c = null;
   let g = null;
   let loader = null;
-  before((done) => {
+  before(() => {
     loader = new noflo.ComponentLoader(baseDir);
-    loader.listComponents(done);
+    return loader.listComponents();
   });
-  beforeEach((done) => {
-    loader.load('Graph', (err, instance) => {
-      if (err) {
-        done(err);
-        return;
-      }
+  beforeEach(() => loader
+    .load('Graph')
+    .then((instance) => {
       c = instance;
       g = noflo.internalSocket.createSocket();
       c.inPorts.graph.attach(g);
-      done();
-    });
-  });
+    }));
 
   const Split = function () {
     const inst = new noflo.Component();

package/spec/fixtures/componentloader/components/Output.js

@@ -1,4 +1,4 @@
-const noflo = require('../../../../lib/NoFlo');
+const noflo = require('../../../../lib/NoFlo.js');
 
 exports.getComponent = function () {
   const c = new noflo.Component();

package/spec/fixtures/componentloader/components/Repeat.ts

@@ -1,4 +1,4 @@
-import { Component } from '../../../../lib/NoFlo';
+import { Component } from '../../../../lib/NoFlo.js';
 
 exports.getComponent = (): Component => {
   const c = new Component();

package/spec/fixtures/componentloader/components/RepeatAsync.coffee

@@ -1,4 +1,4 @@
-noflo = require '../../../../lib/NoFlo'
+noflo = require '../../../../lib/NoFlo.js'
 
 exports.getComponent = () ->
   c = new noflo.Component()

package/spec/fixtures/componentloader/node_modules/example/components/Forward.js

@@ -1,4 +1,4 @@
-const noflo = require('../../../../../../lib/NoFlo');
+const noflo = require('../../../../../../lib/NoFlo.js');
 
 exports.getComponent = function () {
   const c = new noflo.Component();

package/spec/fixtures/componentloader/node_modules/example/package.json

@@ -7,4 +7,4 @@
       "Forward": "components/Forward.js"
     }
   }
-}
+}

package/spec/fixtures/componentloader/package.json

@@ -1,5 +1,6 @@
 {
   "name": "componentloader",
+  "type": "commonjs",
   "noflo": {
     "icon": "cloud",
     "components": {
@@ -9,4 +10,4 @@
   "dependencies": {
     "example": ""
   }
-}
+}

package/spec/fixtures/componentloader/spec/Repeat.yaml

@@ -7,4 +7,4 @@ cases:
     in: true
   expect:
     out:
-     equals: true
+      equals: true

package/spec/utils/inject.js

@@ -3,7 +3,7 @@ if (typeof global !== 'undefined') {
   // Node.js injections for Mocha tests
   global.chai = require('chai');
   global.path = require('path');
-  global.noflo = require('../../lib/NoFlo');
+  global.noflo = require('../../src/lib/NoFlo');
   global.flowtrace = require('flowtrace');
   global.baseDir = process.cwd();
 } else {

package/src/.eslintrc

@@ -1,3 +1,10 @@
 {
-    "extends": "airbnb-base"
-}
+    "extends": "airbnb-base",
+    "rules": {
+      "import/extensions": [
+        "error", {
+          "js": "always"
+        }
+      ]
+    }
+}

package/src/components/Graph.js

@@ -9,14 +9,16 @@
     import/prefer-default-export,
 */
 
-import * as noflo from '../lib/NoFlo';
-import { deprecated } from '../lib/Platform';
+import { graph as fbpGraph } from 'fbp-graph';
+import { Component } from '../lib/Component.js';
+import { InPorts, OutPorts } from '../lib/Ports.js';
+import { Network } from '../lib/Network.js';
 
 // The Graph component is used to wrap NoFlo Networks into components inside
 // another network.
-export class Graph extends noflo.Component {
+export class Graph extends Component {
   /**
-   * @param {Object} metadata
+   * @param {import("fbp-graph/lib/Types").GraphNodeMetadata} [metadata]
    */
   constructor(metadata) {
     super();
@@ -28,18 +30,18 @@ export class Graph extends noflo.Component {
     this.starting = false;
     /** @type {string|null} */
     this.baseDir = null;
-    /** @type {noflo.ComponentLoader|null} */
+    /** @type {import("../lib/ComponentLoader").ComponentLoader|null} */
     this.loader = null;
     this.load = 0;
 
-    this.inPorts = new noflo.InPorts({
+    this.inPorts = new InPorts({
       graph: {
         datatype: 'all',
         description: 'NoFlo graph definition to be used with the subgraph component',
         required: true,
       },
     });
-    this.outPorts = new noflo.OutPorts();
+    this.outPorts = new OutPorts();
 
     this.inPorts.ports.graph.on('ip', (packet) => {
       if (packet.type !== 'data') { return; }
@@ -48,75 +50,81 @@ export class Graph extends noflo.Component {
     });
   }
 
-  setGraph(graph, callback) {
+  /**
+   * @param {import("fbp-graph").Graph|string} graph
+   * @returns {Promise<void>}
+   */
+  setGraph(graph) {
     this.ready = false;
-    let promise;
     if (typeof graph === 'object') {
       if (typeof graph.addNode === 'function') {
         // Existing Graph object
-        promise = this.createNetwork(graph);
-      } else {
-        // JSON definition of a graph
-        promise = noflo.graph.loadJSON(graph)
-          .then((instance) => this.createNetwork(instance));
-      }
-    } else {
-      let graphName = graph;
-      if ((graphName.substr(0, 1) !== '/') && (graphName.substr(1, 1) !== ':') && process && process.cwd) {
-        graphName = `${process.cwd()}/${graphName}`;
+        return this.createNetwork(graph);
       }
-      promise = noflo.graph.loadFile(graphName)
+      // JSON definition of a graph
+      return fbpGraph.loadJSON(graph)
         .then((instance) => this.createNetwork(instance));
     }
-    if (callback) {
-      deprecated('Providing a callback to Graph.setGraph is deprecated, use Promises');
-      promise.then(() => {
-        callback(null);
-      }, callback);
+    let graphName = graph;
+    if ((graphName.substr(0, 1) !== '/') && (graphName.substr(1, 1) !== ':') && process && process.cwd) {
+      graphName = `${process.cwd()}/${graphName}`;
     }
-    return promise;
+    return fbpGraph.loadFile(graphName)
+      .then((instance) => this.createNetwork(instance));
   }
 
-  createNetwork(graph, callback) {
+  /**
+   * @param {import("fbp-graph").Graph} graph
+   * @returns {Promise<void>}
+   */
+  createNetwork(graph) {
     this.description = graph.properties.description || '';
     this.icon = graph.properties.icon || this.icon;
 
     const graphObj = graph;
-    if (!graphObj.name) { graphObj.name = this.nodeId; }
+    if (!graphObj.name && this.nodeId) {
+      graphObj.name = this.nodeId;
+    }
+
+    const network = new Network(graphObj, {
+      componentLoader: this.loader || undefined,
+      baseDir: this.baseDir || undefined,
+    });
 
-    const promise = noflo.createNetwork(graphObj, {
-      delay: true,
-      subscribeGraph: false,
-      componentLoader: this.loader,
-      baseDir: this.baseDir,
-    })
-      .then((network) => {
+    return network
+      .loader.listComponents()
+      .then(() => {
         this.network = network;
-        this.emit('network', this.network);
+        this.emit('network', network);
         // Subscribe to network lifecycle
-        this.subscribeNetwork(this.network);
+        this.subscribeNetwork(network);
         // Wire the network up
         return network.connect();
       })
       .then(() => {
-        Object.keys(this.network.processes).forEach((name) => {
+        Object.keys(network.processes).forEach((name) => {
           // Map exported ports to local component
-          const node = this.network.processes[name];
+          const node = network.processes[name];
           this.findEdgePorts(name, node);
         });
         // Finally set ourselves as "ready"
         this.setToReady();
       });
-    if (callback) {
-      deprecated('Providing a callback to Graph.createNetwork is deprecated, use Promises');
-      promise.then(() => {
-        callback(null);
-      }, callback);
-    }
-    return promise;
   }
 
+  /**
+   * @typedef SubgraphContext
+   * @property {boolean} activated
+   * @property {boolean} deactivated
+   */
+
+  /**
+   * @param {import("../lib/Network").Network} network
+   */
   subscribeNetwork(network) {
+    /**
+     * @type {Array<SubgraphContext>}
+     */
     const contexts = [];
     network.on('start', () => {
       const ctx = {
@@ -134,7 +142,16 @@ export class Graph extends noflo.Component {
     });
   }
 
+  /**
+   * @param {import("../lib/InPort").default} port
+   * @param {string} nodeName
+   * @param {string} portName
+   * @returns {boolean|string}
+   */
   isExportedInport(port, nodeName, portName) {
+    if (!this.network) {
+      return false;
+    }
     // First we check disambiguated exported ports
     const keys = Object.keys(this.network.graph.inports);
     for (let i = 0; i < keys.length; i += 1) {
@@ -149,7 +166,16 @@ export class Graph extends noflo.Component {
     return false;
   }
 
+  /**
+   * @param {import("../lib/OutPort").default} port
+   * @param {string} nodeName
+   * @param {string} portName
+   * @returns {boolean|string}
+   */
   isExportedOutport(port, nodeName, portName) {
+    if (!this.network) {
+      return false;
+    }
     // First we check disambiguated exported ports
     const keys = Object.keys(this.network.graph.outports);
     for (let i = 0; i < keys.length; i += 1) {
@@ -171,26 +197,36 @@ export class Graph extends noflo.Component {
         return this.emit('ready');
       });
     } else {
-      setTimeout(() => {
-        this.ready = true;
-        return this.emit('ready');
-      },
-      0);
+      setTimeout(
+        () => {
+          this.ready = true;
+          return this.emit('ready');
+        },
+        0,
+      );
     }
   }
 
+  /**
+   * @param {string} name
+   * @param {import("../lib/BaseNetwork").NetworkProcess} process
+   * @returns {boolean}
+   */
   findEdgePorts(name, process) {
+    if (!process.component) {
+      return false;
+    }
     const inPorts = process.component.inPorts.ports;
     const outPorts = process.component.outPorts.ports;
 
     Object.keys(inPorts).forEach((portName) => {
       const port = inPorts[portName];
       const targetPortName = this.isExportedInport(port, name, portName);
-      if (targetPortName === false) { return; }
+      if (typeof targetPortName !== 'string') { return; }
       this.inPorts.add(targetPortName, port);
-      this.inPorts[targetPortName].on('connect', () => {
+      this.inPorts.ports[targetPortName].on('connect', () => {
         // Start the network implicitly if we're starting to get data
-        if (this.starting) { return; }
+        if (this.starting || !this.network) { return; }
         if (this.network.isStarted()) { return; }
         if (this.network.startupDate) {
           // Network was started, but did finish. Re-start simply
@@ -198,14 +234,14 @@ export class Graph extends noflo.Component {
           return;
         }
         // Network was never started, start properly
-        this.setUp(() => {});
+        this.setUp();
       });
     });
 
     Object.keys(outPorts).forEach((portName) => {
       const port = outPorts[portName];
       const targetPortName = this.isExportedOutport(port, name, portName);
-      if (targetPortName === false) { return; }
+      if (typeof targetPortName !== 'string') { return; }
       this.outPorts.add(targetPortName, port);
     });
 
@@ -224,38 +260,36 @@ export class Graph extends noflo.Component {
     return false;
   }
 
-  setUp(callback) {
+  setUp() {
     this.starting = true;
     if (!this.isReady()) {
-      this.once('ready', () => {
-        this.setUp(callback);
+      return new Promise((resolve, reject) => {
+        this.once('ready', () => {
+          this.setUp().then(resolve, reject);
+        });
       });
-      return;
     }
     if (!this.network) {
-      callback(null);
-      return;
+      return Promise.resolve();
     }
-    this.network.start()
+    return this.network.start()
       .then(() => {
         this.starting = false;
-        callback(null);
-      }, callback);
+      });
   }
 
-  tearDown(callback) {
+  tearDown() {
     this.starting = false;
     if (!this.network) {
-      callback(null);
-      return;
+      return Promise.resolve();
     }
-    this.network.stop()
-      .then(() => callback(), callback);
+    return this.network.stop()
+      .then(() => {});
   }
 }
 
 /**
- * @params {Object} metadata
+ * @param {import("fbp-graph/lib/Types").GraphNodeMetadata} [metadata]
  */
 export function getComponent(metadata) {
   return new Graph(metadata);