@universal-packages/sub-process - npm Package Compare versions

Comparing version 1.1.0 to 1.2.0

BaseChildProcessEngine.js

@@ -34,2 +34,4 @@ "use strict";
         });
+        // Ignore stdin errors they occur when the process is killed
+        childProcess.stdin?.on('error', () => { });
         if (childProcess.stdin)
@@ -36,0 +38,0 @@ input.pipe(childProcess.stdin);

package.json

 {
   "name": "@universal-packages/sub-process",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Process encapsulation for different exec technics",
@@ -22,3 +22,4 @@ "author": "David De Anda <[e-mail]> (https://github.com/universal-packages)",
     "@universal-packages/fs-utils": "^1.0.3",
-    "@universal-packages/time-measurer": "^1.4.9"
+    "@universal-packages/time-measurer": "^1.4.9",
+    "ms": "^2.1.3"
   },
@@ -28,2 +29,3 @@ "devDependencies": {
     "@types/jest": "^29.5.5",
+    "@types/ms": "^0.7.34",
     "@types/node": "^18.11.9",
@@ -30,0 +32,0 @@ "@universal-packages/maintenance": "^1.2.4",

README.md

@@ -22,7 +22,7 @@ # Sub SubProcess
 
-const sub_process = new SubProcess({ command: 'echo', args: ['$VARIABLE'], env: { VARIABLE: 'value' } })
+const subProcess = new SubProcess({ command: 'echo', args: ['$VARIABLE'], env: { VARIABLE: 'value' } })
 
-await sub_process.run()
+await subProcess.run()
 
-console.log(sub_process.stdout.toString())
+console.log(subProcess.stdout.toString())
 ```
@@ -89,3 +89,3 @@
 
-#### **`status`** **`idle | running | success | error | failure | killed`**
+#### **`status`** **`idle | running | success | error | failure | killed | stopped | killing | stopping`**
 
@@ -99,14 +99,16 @@ Status of the process.
 ```js
-sub_process.on('*', (event) => console.log(event))
-sub_process.on('running', (event) => console.log(event))
-sub_process.on('stdout', (event) => console.log(event))
-sub_process.on('stderr', (event) => console.log(event))
-sub_process.on('success', (event) => console.log(event))
-sub_process.on('failure', (event) => console.log(event))
-sub_process.on('killing', (event) => console.log(event))
-sub_process.on('killed', (event) => console.log(event))
-sub_process.on('end', (event) => console.log(event))
-sub_process.on('timeout', (event) => console.log(event))
-sub_process.on('error', (event) => console.log(event))
-sub_process.on('warning', (event) => console.log(event))
+subProcess.on('*', (event) => console.log(event))
+subProcess.on('running', (event) => console.log(event))
+subProcess.on('stdout', (event) => console.log(event))
+subProcess.on('stderr', (event) => console.log(event))
+subProcess.on('success', (event) => console.log(event))
+subProcess.on('failure', (event) => console.log(event))
+subProcess.on('killing', (event) => console.log(event))
+subProcess.on('killed', (event) => console.log(event))
+subProcess.on('stopping', (event) => console.log(event))
+subProcess.on('stopped', (event) => console.log(event))
+subProcess.on('end', (event) => console.log(event))
+subProcess.on('timeout', (event) => console.log(event))
+subProcess.on('error', (event) => console.log(event))
+subProcess.on('warning', (event) => console.log(event))
 ```
@@ -121,3 +123,3 @@
 
-const sub_process = new SubProcess({ engine: new MyEngine() })
+const subProcess = new SubProcess({ engine: new MyEngine() })
 ```
@@ -124,0 +126,0 @@

SubProcess.d.ts

 /// <reference types="node" />
 /// <reference types="node" />
-import { EventEmitter } from '@universal-packages/event-emitter';
-import { ProcessStatus, SubProcessOptions } from './SubProcess.types';
-export default class Process extends EventEmitter {
-    readonly options: SubProcessOptions;
-    readonly command: string;
-    readonly args: string[];
-    readonly env: Record<string, string>;
-    get status(): ProcessStatus;
+import BaseRunner from './BaseRunner';
+import { SubProcessOptions } from './SubProcess.types';
+export default class SubProcess extends BaseRunner<SubProcessOptions> {
     get stdout(): Buffer;
@@ -16,5 +11,7 @@ get stderr(): Buffer;
     get processId(): number;
-    private processStatus;
     private readonly engine;
     private readonly input;
+    private readonly command;
+    private readonly args;
+    private readonly env;
     private readonly stdoutChunks;
@@ -25,8 +22,10 @@ private readonly stderrChunks;
     private internalSignal;
-    private timeout?;
+    private killWithSignal?;
     constructor(options: SubProcessOptions);
-    prepare(): Promise<void>;
-    release(): Promise<void>;
-    run(): Promise<void>;
     kill(signal?: NodeJS.Signals | number): Promise<void>;
+    protected internalRun(onRunning: () => void): Promise<void>;
+    protected internalKill(): Promise<void>;
+    protected internalStop(): Promise<void>;
+    protected prepare(): Promise<void>;
+    protected release(): Promise<void>;
     private extractCommand;
@@ -33,0 +32,0 @@ private extractArgs;

SubProcess.js

@@ -7,15 +7,11 @@ "use strict";
 const adapter_resolver_1 = require("@universal-packages/adapter-resolver");
-const event_emitter_1 = require("@universal-packages/event-emitter");
 const fs_utils_1 = require("@universal-packages/fs-utils");
-const time_measurer_1 = require("@universal-packages/time-measurer");
 const stream_1 = require("stream");
+const BaseRunner_1 = __importDefault(require("./BaseRunner"));
+const BaseRunner_types_1 = require("./BaseRunner.types");
 const ExecEngine_1 = __importDefault(require("./ExecEngine"));
 const ForkEngine_1 = __importDefault(require("./ForkEngine"));
 const SpawnEngine_1 = __importDefault(require("./SpawnEngine"));
-const SubProcess_types_1 = require("./SubProcess.types");
 const TestEngine_1 = __importDefault(require("./TestEngine"));
-class Process extends event_emitter_1.EventEmitter {
-    get status() {
-        return this.processStatus;
-    }
+class SubProcess extends BaseRunner_1.default {
     get stdout() {
@@ -37,7 +33,5 @@ return Buffer.concat(this.stdoutChunks);
     constructor(options) {
-        super();
-        this.processStatus = SubProcess_types_1.ProcessStatus.IDLE;
+        super({ engine: process.env.NODE_ENV === 'test' ? 'test' : 'spawn', ...options });
         this.stdoutChunks = [];
         this.stderrChunks = [];
-        this.options = { engine: process.env.NODE_ENV === 'test' ? 'test' : 'spawn', throwIfNotSuccessful: false, ...options };
         this.command = this.extractCommand(options.command);
@@ -49,87 +43,52 @@ this.args = this.extractArgs(options.command, options.args);
     }
-    async prepare() {
-        if (this.engine.prepare)
-            await this.engine.prepare();
+    async kill(signal) {
+        if (this.killWithSignal === undefined)
+            this.killWithSignal = signal || null;
+        await super.kill();
     }
-    async release() {
-        if (this.engine.release)
-            await this.engine.release();
-    }
-    async run() {
-        switch (this.processStatus) {
-            case SubProcess_types_1.ProcessStatus.RUNNING:
-                this.emit('warning', { message: 'Process is already running', payload: { process: this } });
-                return;
-            case SubProcess_types_1.ProcessStatus.IDLE:
-                break;
-            default:
-                this.emit('warning', { message: 'Process has already ended', payload: { process: this } });
-                return;
-        }
-        return new Promise(async (resolve, reject) => {
-            const measurer = (0, time_measurer_1.startMeasurement)();
-            this.processStatus = SubProcess_types_1.ProcessStatus.RUNNING;
-            try {
-                const finalWorkingDirectory = this.options.workingDirectory ? (0, fs_utils_1.checkDirectory)(this.options.workingDirectory) : undefined;
-                this.engineProcess = await this.engine.run(this.command, this.args, this.input, this.env, finalWorkingDirectory);
-            }
-            catch (error) {
-                this.processStatus = SubProcess_types_1.ProcessStatus.ERROR;
-                this.emit('error', { error, payload: { process: this } });
-                this.options.throwIfNotSuccessful ? reject(error) : resolve();
-                return;
-            }
-            if (this.options.timeout) {
-                this.timeout = setTimeout(() => {
-                    this.emit('timeout', { payload: { process: this } });
-                    this.kill();
-                }, this.options.timeout);
-            }
-            this.emit('running', { payload: { process: this } });
+    async internalRun(onRunning) {
+        const finalWorkingDirectory = this.options.workingDirectory ? (0, fs_utils_1.checkDirectory)(this.options.workingDirectory) : undefined;
+        this.engineProcess = await this.engine.run(this.command, this.args, this.input, this.env, finalWorkingDirectory);
+        onRunning();
+        return new Promise(async (resolve) => {
             this.engineProcess.on('stdout', (data) => {
                 this.stdoutChunks.push(data);
-                this.emit('stdout', { payload: { data, process: this } });
+                this.emit('stdout', { payload: { data } });
             });
             this.engineProcess.on('stderr', (data) => {
                 this.stderrChunks.push(data);
-                this.emit('stderr', { payload: { data, process: this } });
+                this.emit('stderr', { payload: { data } });
             });
             this.engineProcess.on('success', () => {
-                clearTimeout(this.timeout);
+                this.internalStatus = BaseRunner_types_1.Status.SUCCESS;
                 this.internalExitCode = 0;
-                this.processStatus = SubProcess_types_1.ProcessStatus.SUCCESS;
-                const measurement = measurer.finish();
-                this.emit('success', { measurement, payload: { process: this } });
-                this.emit('end', { measurement, payload: { process: this } });
                 resolve();
             });
             this.engineProcess.on('failure', (exitCode) => {
-                clearTimeout(this.timeout);
+                this.internalStatus = BaseRunner_types_1.Status.FAILURE;
                 this.internalExitCode = exitCode;
-                this.processStatus = SubProcess_types_1.ProcessStatus.FAILURE;
-                const measurement = measurer.finish();
-                this.emit('failure', { measurement, payload: { process: this } });
-                this.emit('end', { measurement, payload: { process: this } });
-                this.options.throwIfNotSuccessful ? reject(new Error(`Process exited with code ${exitCode}\n\n${this.stderr.toString()}`)) : resolve();
+                this.failureMessage = `Process exited with code ${exitCode}\n\n${this.stderr.toString()}`;
+                resolve();
             });
             this.engineProcess.on('killed', (signal) => {
-                clearTimeout(this.timeout);
+                this.internalStatus = BaseRunner_types_1.Status.KILLED;
                 this.internalSignal = signal;
-                this.processStatus = SubProcess_types_1.ProcessStatus.KILLED;
-                const measurement = measurer.finish();
-                this.emit('killed', { measurement, payload: { process: this } });
-                this.emit('end', { measurement, payload: { process: this } });
-                this.options.throwIfNotSuccessful ? reject(new Error(`Process was killed with signal ${signal}`)) : resolve();
+                resolve();
             });
         });
     }
-    async kill(signal) {
-        if (this.processStatus === SubProcess_types_1.ProcessStatus.RUNNING) {
-            this.emit('killing', { payload: { process: this } });
-            return new Promise(async (resolve) => {
-                this.once('end', () => resolve());
-                this.engineProcess.kill(signal);
-            });
-        }
+    async internalKill() {
+        this.engineProcess?.kill(this.killWithSignal || undefined);
     }
+    async internalStop() {
+        await this.internalKill();
+    }
+    async prepare() {
+        if (this.engine.prepare)
+            await this.engine.prepare();
+    }
+    async release() {
+        if (this.engine.release)
+            await this.engine.release();
+    }
     extractCommand(command) {
@@ -186,3 +145,3 @@ return command.split(' ')[0];
 }
-exports.default = Process;
+exports.default = SubProcess;
 //# sourceMappingURL=SubProcess.js.map

SubProcess.types.d.ts

@@ -5,10 +5,2 @@ /// <reference types="node" />
 import EngineProcess from './EngineProcess';
-export declare enum ProcessStatus {
-    IDLE = "idle",
-    RUNNING = "running",
-    SUCCESS = "success",
-    ERROR = "error",
-    FAILURE = "failure",
-    KILLED = "killed"
-}
 export interface SubProcessOptions {
@@ -21,3 +13,2 @@ args?: string[];
     input?: string | Buffer | string[] | Buffer[] | Readable;
-    throwIfNotSuccessful?: boolean;
     timeout?: number;
@@ -24,0 +15,0 @@ workingDirectory?: string;

SubProcess.types.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessStatus = void 0;
-var ProcessStatus;
-(function (ProcessStatus) {
-    ProcessStatus["IDLE"] = "idle";
-    ProcessStatus["RUNNING"] = "running";
-    ProcessStatus["SUCCESS"] = "success";
-    ProcessStatus["ERROR"] = "error";
-    ProcessStatus["FAILURE"] = "failure";
-    ProcessStatus["KILLED"] = "killed";
-})(ProcessStatus || (exports.ProcessStatus = ProcessStatus = {}));
 //# sourceMappingURL=SubProcess.types.js.map

TestEngine.js

@@ -66,3 +66,3 @@ "use strict";
                 else {
-                    testProcess.emit('success', 0);
+                    testProcess.emit('success');
                 }
@@ -75,3 +75,3 @@ }
                 else {
-                    testProcess.emit('success', 0);
+                    testProcess.emit('success');
                 }
@@ -78,0 +78,0 @@ }

No alert changes

Improved metrics

Total package byte prevSize

63028

19.43%

Number of package files

51

13.33%

Lines of code

834

28.31%

Number of lines in readme file

185

1.09%

Worsened metrics

Dependency count

5

25%

Dev dependency count

9

12.5%

Dependency changes

• + Added

  ms@^2.1.3

• + Added

  ms@2.1.3
  (transitive)