noflo 1.4.3 → 1.5.1

package/README.md

@@ -62,7 +62,7 @@ NoFlo is available from [GitHub](https://github.com/noflo/noflo) under the MIT l
 
 ## Changes
 
-Please refer to the [Release Notes](https://github.com/noflo/noflo/releases) and the [CHANGES.md document](https://github.com/noflo/noflo/blob/master/CHANGES.md).
+Please refer to the [CHANGELOG.md](CHANGELOG.md)
 
 ## Usage
 

package/bin/noflo-cache-preheat

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 // vim: set filetype=javascript:
-const path = require('path');
-const fs = require('fs');
-const { ComponentLoader } = require('../lib/NoFlo');
+import path from 'node:path';
+import fs from 'node:fs';
+import * as noflo from '../src/lib/NoFlo.js';
 
 // Base setup
 const baseDir = process.cwd();
@@ -10,7 +10,7 @@ const cacheFile = path.resolve(baseDir, 'fbp.json');
 
 function preheat() {
   console.log(`Pre-heating NoFlo cache with manifest for ${baseDir}`);
-  const loader = new ComponentLoader(baseDir, {
+  const loader = new noflo.ComponentLoader(baseDir, {
     cache: true,
     discover: true,
   });

package/components/Graph.d.ts

@@ -1,25 +1,60 @@
 /**
- * @params {Object} metadata
+ * @param {import("fbp-graph/lib/Types").GraphNodeMetadata} [metadata]
  */
-export function getComponent(metadata: any): Graph;
-export class Graph extends noflo.Component {
+export function getComponent(metadata?: import("fbp-graph/lib/Types").GraphNodeMetadata): Graph;
+export class Graph extends Component {
     /**
-     * @param {Object} metadata
+     * @param {import("fbp-graph/lib/Types").GraphNodeMetadata} [metadata]
      */
-    constructor(metadata: any);
-    metadata: any;
+    constructor(metadata?: import("fbp-graph/lib/Types").GraphNodeMetadata);
+    metadata: import("fbp-graph/lib/Types").PropertyMap;
     /** @type {import("../lib/Network").Network|null} */
     network: import("../lib/Network").Network | null;
     ready: boolean;
     starting: boolean;
-    /** @type {noflo.ComponentLoader|null} */
-    loader: noflo.ComponentLoader | null;
-    setGraph(graph: any, callback: any): Promise<void>;
-    createNetwork(graph: any, callback: any): Promise<void>;
-    subscribeNetwork(network: any): void;
-    isExportedInport(port: any, nodeName: any, portName: any): string | false;
-    isExportedOutport(port: any, nodeName: any, portName: any): string | false;
+    /** @type {import("../lib/ComponentLoader").ComponentLoader|null} */
+    loader: import("../lib/ComponentLoader").ComponentLoader | null;
+    /**
+     * @param {import("fbp-graph").Graph|string} graph
+     * @returns {Promise<void>}
+     */
+    setGraph(graph: import("fbp-graph").Graph | string): Promise<void>;
+    /**
+     * @param {import("fbp-graph").Graph} graph
+     * @returns {Promise<void>}
+     */
+    createNetwork(graph: import("fbp-graph").Graph): Promise<void>;
+    /**
+     * @typedef SubgraphContext
+     * @property {boolean} activated
+     * @property {boolean} deactivated
+     */
+    /**
+     * @param {import("../lib/Network").Network} network
+     */
+    subscribeNetwork(network: import("../lib/Network").Network): void;
+    /**
+     * @param {import("../lib/InPort").default} port
+     * @param {string} nodeName
+     * @param {string} portName
+     * @returns {boolean|string}
+     */
+    isExportedInport(port: import("../lib/InPort").default, nodeName: string, portName: string): boolean | string;
+    /**
+     * @param {import("../lib/OutPort").default} port
+     * @param {string} nodeName
+     * @param {string} portName
+     * @returns {boolean|string}
+     */
+    isExportedOutport(port: import("../lib/OutPort").default, nodeName: string, portName: string): boolean | string;
     setToReady(): void;
-    findEdgePorts(name: any, process: any): boolean;
+    /**
+     * @param {string} name
+     * @param {import("../lib/BaseNetwork").NetworkProcess} process
+     * @returns {boolean}
+     */
+    findEdgePorts(name: string, process: import("../lib/BaseNetwork").NetworkProcess): boolean;
+    setUp(): Promise<any>;
+    tearDown(): Promise<void>;
 }
-import * as noflo from "../lib/NoFlo";
+import { Component } from "../lib/Component.js";

package/components/Graph.js

@@ -10,13 +10,15 @@ exports.getComponent = exports.Graph = void 0;
     import/no-unresolved,
     import/prefer-default-export,
 */
-const noflo = require("../lib/NoFlo");
-const Platform_1 = require("../lib/Platform");
+const fbp_graph_1 = require("fbp-graph");
+const Component_js_1 = require("../lib/Component.js");
+const Ports_js_1 = require("../lib/Ports.js");
+const Network_js_1 = require("../lib/Network.js");
 // The Graph component is used to wrap NoFlo Networks into components inside
 // another network.
-class Graph extends noflo.Component {
+class Graph extends Component_js_1.Component {
     /**
-     * @param {Object} metadata
+     * @param {import("fbp-graph/lib/Types").GraphNodeMetadata} [metadata]
      */
     constructor(metadata) {
         super();
@@ -28,17 +30,17 @@ 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 Ports_js_1.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 Ports_js_1.OutPorts();
         this.inPorts.ports.graph.on('ip', (packet) => {
             if (packet.type !== 'data') {
                 return;
@@ -47,75 +49,75 @@ class Graph extends noflo.Component {
             this.setGraph(packet.data).catch(this.error);
         });
     }
-    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);
+                return 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}`;
-            }
-            promise = noflo.graph.loadFile(graphName)
+            // JSON definition of a graph
+            return fbp_graph_1.graph.loadJSON(graph)
                 .then((instance) => this.createNetwork(instance));
         }
-        if (callback) {
-            Platform_1.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 fbp_graph_1.graph.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) {
+        if (!graphObj.name && this.nodeId) {
             graphObj.name = this.nodeId;
         }
-        const promise = noflo.createNetwork(graphObj, {
-            delay: true,
-            subscribeGraph: false,
-            componentLoader: this.loader,
-            baseDir: this.baseDir,
-        })
-            .then((network) => {
+        const network = new Network_js_1.Network(graphObj, {
+            componentLoader: this.loader || undefined,
+            baseDir: this.baseDir || undefined,
+        });
+        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) {
-            Platform_1.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 +136,16 @@ class Graph extends noflo.Component {
             this.deactivate(ctx);
         });
     }
+    /**
+     * @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) {
@@ -147,7 +158,16 @@ class Graph extends noflo.Component {
         // Component has exported ports and this isn't one of them
         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) {
@@ -174,19 +194,27 @@ class Graph extends noflo.Component {
             }, 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) {
+            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) {
+                if (this.starting || !this.network) {
                     return;
                 }
                 if (this.network.isStarted()) {
@@ -198,13 +226,13 @@ 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) {
+            if (typeof targetPortName !== 'string') {
                 return;
             }
             this.outPorts.add(targetPortName, port);
@@ -220,37 +248,35 @@ class Graph extends noflo.Component {
     isLegacy() {
         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(() => { });
     }
 }
 exports.Graph = Graph;
 /**
- * @params {Object} metadata
+ * @param {import("fbp-graph/lib/Types").GraphNodeMetadata} [metadata]
  */
 function getComponent(metadata) {
     return new Graph(metadata);

package/examples/http/HelloController.js

@@ -4,12 +4,15 @@ const noflo = require('noflo');
 exports.getComponent = () => {
   const c = new noflo.Component();
   c.description = 'Simple controller that says hello, user';
-  c.inPorts.add('in',
-    { datatype: 'object' });
-  c.outPorts.add('out',
-    { datatype: 'object' });
-  c.outPorts.add('data',
-    { datatype: 'object' });
+  c.inPorts.add('in', {
+    datatype: 'object',
+  });
+  c.outPorts.add('out', {
+    datatype: 'object',
+  });
+  c.outPorts.add('data', {
+    datatype: 'object',
+  });
   c.process((input, output) => {
     if (!input.hasData('in')) { return; }
     const request = input.getData('in');

package/examples/spreadsheet/parse.fbp

@@ -13,7 +13,7 @@
 #
 # In the end the output will be provided through the ENTITIZE.OUT port.
 #
-# This network uses Apache Tika for parsing the spreadsheet into 
+# This network uses Apache Tika for parsing the spreadsheet into
 # XHTML. Ensure that Tika can be found in the location set below:
 'tika-app-0.9.jar' -> TIKA Read(ReadDocument)
 
@@ -21,7 +21,7 @@
 Read() ERROR -> IN Display(Output)
 
 # Parse the file to JSON, get all spreadsheets from it
-Read() OUT -> IN Parse(ParseXml) 
+Read() OUT -> IN Parse(ParseXml)
 
 # We're only interested in DIVs inside the BODY
 'body' -> KEY GetBody(GetObjectKey)
@@ -39,7 +39,7 @@ GetDiv() OUT -> IN GetSheet(GetObjectKey) OUT -> IN GroupByTableId()
 'table' -> KEY GetTable(GetObjectKey)
 'tbody' -> KEY GetTBody(GetObjectKey)
 'tr' -> KEY GetTR(GetObjectKey)
-GroupByTableId() OUT -> IN GetTable() OUT -> IN GetTBody() OUT -> IN GetTR() 
+GroupByTableId() OUT -> IN GetTable() OUT -> IN GetTBody() OUT -> IN GetTR()
 
 # Process each row individually and get the cells
 'td' -> KEY GetTD(GetObjectKey)

package/lib/AsCallback.d.ts

@@ -32,12 +32,12 @@
  * @returns {NetworkAsPromise}
  */
 export function asPromise(component: Graph | string, options: {
-    name: string;
-    loader: ComponentLoader;
-    baseDir: string;
-    flowtrace: any;
-    networkCallback: NetworkCallback;
-    raw: boolean;
+    name?: string;
+    loader?: ComponentLoader;
+    baseDir?: string;
+    flowtrace?: any;
+    networkCallback?: NetworkCallback;
+    raw?: boolean;
 }): NetworkAsPromise;
 /**
  * @param {AsCallbackComponent} component - Graph or component to load
@@ -45,7 +45,7 @@ export function asPromise(component: Graph | string, options: {
  * @returns {NetworkAsCallback}
  */
 export function asCallback(component: AsCallbackComponent, options: AsCallbackOptions): NetworkAsCallback;
-export type AsCallbackComponent = string | Graph;
+export type AsCallbackComponent = Graph | string;
 export type AsCallbackOptions = {
     /**
      * - Name for the wrapped network
@@ -71,11 +71,24 @@ export type AsCallbackOptions = {
      * - Whether the callback should operate on raw noflo.IP objects
      */
     raw?: boolean;
+    /**
+     * - Make Information Packet delivery asynchronous
+     */
+    asyncDelivery?: boolean;
 };
+export type OutputMap = Array<{
+    [x: string]: IP;
+}>;
+export type InputMap = {
+    [x: string]: Array<IP | any>;
+} | Array<{
+    [x: string]: IP | any;
+}>;
 export type ResultCallback = (err: Error | null, output?: any) => void;
 export type NetworkAsCallback = (input: any, callback: ResultCallback) => any;
 export type NetworkAsPromise = (input: any) => Promise<any>;
 export type NetworkCallback = (network: Network) => any;
 import { Graph } from "fbp-graph";
-import { ComponentLoader } from "./ComponentLoader";
-import { Network } from "./Network";
+import { ComponentLoader } from "./ComponentLoader.js";
+import IP from "./IP.js";
+import { Network } from "./Network.js";