test/add addiional way to exexute Node Js forked process with spawn

Author: TheTechsTech

README.md

@@ -62,9 +62,10 @@ installer('vim')
 
 ```js
  sudo: boolean, // run as administrator
+ fork: string, //  execute an additional module, of Node Js process `fork` IPC communication channel.
  onerror: callable, // callback for `stderr.on('data')` event.
  onprogress: callable, // callback for `stdout.on('data')` event.
- // onmessage: callable, // callback for send `on('message')` event.
+ onmessage: callable, // callback for `on('message')` for `fork` event.
  ```
 
 `Spawning` returns a promise whose result will be any output or any data return in the progress callback.
@@ -77,6 +78,9 @@ installer('vim')
 * `output:` *String* - Output from stdout.
   * Output can be altered and if returned will replace the otherwise resolved result.
 
+* `fork:` *Object* - An additional [forked](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options) Node Js process handler, IPC communication channel.
+  * Execute additional processing base off of sub child process output, with module a script.
+
 If there's an error running the child process, received data on stderr, or errors in progress callback, `spawning` rejects the returned promise.
 
 ### CLI Usage

index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 import which from 'which';
-import { spawn } from 'child_process';
+import { spawn, fork } from 'child_process';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -176,20 +176,22 @@ function isFunction(value) {
  * @param {Object} options - Any child process `spawn` options, defaults: stdio: 'pipe'.
  * - Additionally:
  *```js
- * sudo: boolean, // run as administrator
+ * sudo: boolean, // run as administrator.
+ * fork: string, //  execute an additional module, a child_process.`fork` IPC communication channel.
  * onerror: callable, // callback for `stderr.on('data')` event.
  * onprogress: callable, // callback for `stdout.on('data')` event.
- // * onmessage: callable, // callback for `on('message')` event.
+ * onmessage: callable, // callback for `on('message')` for `fork` event.
  *```
  */
 export const spawning = Sys.spawning = function (command, argument, progressOptions, options) {
   return new Promise((resolve, reject) => {
     options = options || {
       stdio: 'pipe',
       sudo: false,
+      fork: null,
       onerror: null,
       onprogress: null,
-      // onmessage: null,
+      onmessage: null,
     };
 
     let progress = progressOptions;
@@ -202,75 +204,80 @@ export const spawning = Sys.spawning = function (command, argument, progressOpti
     let error = null;
     let output = null;
     let sudo = options.sudo || false;
+    let forking = options.fork || null;
     let onerror = options.onerror || null;
-    //let onmessage = options.onmessage || null;
+    let onmessage = options.onmessage || null;
+
+    if (typeof forking == 'string')
+      var forked = fork(forking);
 
     delete options.sudo;
+    delete options.fork;
     delete options.onerror;
     delete options.onprogress;
-    //delete options.onmessage;
+    delete options.onmessage;
 
     if (sudo) {
       argument = [command].concat(argument);
       command = (process.platform == 'win32') ? join(__dirname, 'bin', 'sudo.bat') : 'sudo';
-    }
+    };
+
+    const spawned = spawn(command, argument, options);
+    spawned.on('error', (data) => {
 
-    const child = spawn(command, argument, options);
-    child.on('error', (data) => {
       return reject(data);
     });
 
-    child.on('close', (code) => {
+    spawned.on('close', (code) => {
       if (code === 0) {
         return resolve(output);
       }
 
       return reject(error, code);
     });
 
-    child.on('exit', () => {
+    spawned.on('exit', () => {
+      if (forked)
+        setTimeout(() => {
+          forked.kill();
+        }, 1000);
+
       return resolve(output);
     });
 
-    child.stdout.on('data', (data) => {
+    spawned.stdout.on('data', (data) => {
       let input = data.toString();
-      let onProgress = null
+      output += input;
       try {
         if (isFunction(progress)) {
-          onProgress = progress({ handle: child, output: input });
+          output = progress({ handle: spawned, output: input, fork: forked }) || output;
         }
       } catch (e) {
         return reject(e.toString());
       }
 
-      if (onProgress && onProgress != null) {
-        output = onProgress;
-      } else if (input != null) {
-        output += input;
-      }
-
       if (argument.includes('fake-js')) {
-        child.kill('SIGKILL');
+        spawned.kill('SIGKILL');
         return resolve('For testing only. ' + output);
       }
     });
 
-    child.stderr.on('data', (data) => {
+    spawned.stderr.on('data', (data) => {
       let err = data.toString();
-      if (isFunction(onerror))
-        /* c8 ignore next */
-        error = onerror(err) || err;
-      else
-        error += err;
+      error += err;
+      if (isFunction(onerror))/* c8 ignore next */
+        error = onerror(err) || error;
     });
-    /*
-        child.on('message', (data) => {
-          if (isFunction(onmessage))
-            onmessage(data);
-        });
-    */
+
+    if (forked) {
+      forked.on('message', (data) => {
+        if (isFunction(onmessage))
+          onmessage(data);
+      });
+    }
+
     if (argument.includes('fake-js') && Object.getOwnPropertyDescriptor(process, 'platform').value == 'darwin') {
-      child.kill('SIGKILL');
+      spawned.kill('SIGKILL');
       return resolve('For testing only. ' + output);
     }
   });

test/sub.cjs

@@ -0,0 +1,5 @@
+process.on('message', (m) => {
+  console.log('CHILD got message:', m);
+});
+
+process.send({ hello: 'world' });

test/test.js

@@ -311,7 +311,6 @@ describe('Method: `spawning`', function () {
       sudo: true,
       onerror: (err) => { return 'testing: ' + err; },
       onprogress: () => { }
-      // onmessage: (data) => { console.log('messaging: ' + data); },
     })
       .then(function () {
         done();
@@ -336,6 +335,27 @@ describe('Method: `spawning`', function () {
         done();
       });
   });
+
+  it('should receive message from `fork` process', function (done) {
+    spawning((process.platform == 'win32' ? 'dir' : 'ls'), ['..'], null, {
+      stdio: 'pipe',
+      shell: true,
+      fork: 'test/sub.cjs',
+      onprogress: (object) => {
+        expect(object.fork).to.be.instanceOf(Object);
+        object.fork.send('hello');
+        return { fork: object.fork, output: 'done' };
+      },
+      onmessage: (data) => {
+        expect(data.hello).to.equal('world');
+      },
+    })
+      .then(function (data) {
+        expect(data.output).to.equal('done');
+        expect(data.fork).to.be.instanceOf(Object);
+        done();
+      });
+  });
 });
 
 describe('Method: `where`', function () {