Merge branch 'main' into issues-433-and-452

.github/workflows/test.yml

@@ -55,9 +55,13 @@ jobs:
       - name: Install dependencies
         run: pnpm install && pnpm add --global concurrently
 
-      - name: Build & Test
+      - name: Build & Unit Test
         run: concurrently --prefix none --group "pnpm:build" "pnpm:test"
 
+      - name: Smoke Test
+        # Don't collect coverage here as it overrides the unit test's coverage
+        run: pnpm test:smoke --coverage=false
+
       - name: Submit coverage
         uses: coverallsapp/github-action@master
         continue-on-error: true

.gitignore

@@ -1,5 +1,5 @@
 # Outputs
-/dist
+dist
 
 # Logs
 *.log

.vscode/settings.json

@@ -8,5 +8,6 @@
   "[javascript, typescript]": {
     "editor.formatOnSave": false
   },
-  "editor.rulers": [100]
+  "editor.rulers": [100],
+  "typescript.tsdk": "node_modules/typescript/lib"
 }

bin/concurrently.ts

@@ -3,7 +3,7 @@ import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 
 import * as defaults from '../src/defaults';
-import concurrently from '../src/index';
+import { concurrently } from '../src/index';
 import { epilogue } from './epilogue';
 
 // Clean-up arguments (yargs expects only the arguments after the program name)
@@ -165,9 +165,9 @@ const args = yargs(argsBeforeSep)
             type: 'number',
         },
         'restart-after': {
-            describe: 'Delay time to respawn the process, in milliseconds.',
+            describe: 'Delay before restarting the process, in milliseconds, or "exponential".',
             default: defaults.restartDelay,
-            type: 'number',
+            type: 'string',
         },
 
         // Input
@@ -223,7 +223,8 @@ concurrently(
         prefix: args.prefix,
         prefixColors: args.prefixColors.split(','),
         prefixLength: args.prefixLength,
-        restartDelay: args.restartAfter,
+        restartDelay:
+            args.restartAfter === 'exponential' ? 'exponential' : Number(args.restartAfter),
         restartTries: args.restartTries,
         successCondition: args.success,
         timestampFormat: args.timestampFormat,

index.d.mts

@@ -0,0 +1,7 @@
+/*
+ * While in local development, make sure you've run `pnpm run build` first.
+ */
+import { concurrently } from './dist/src/index.js';
+
+export * from './dist/src/index.js';
+export default concurrently;

index.d.ts

@@ -0,0 +1,11 @@
+/*
+ * While in local development, make sure you've run `pnpm run build` first.
+ */
+import { concurrently } from './dist/src/index.js';
+
+export * from './dist/src/index.js';
+// @ts-expect-error ignore the usage of `export =` along with `export default`.
+// This is seemingly fine, but the file needs to be included in the TS project, which can't be done
+// due to importing from `dist`. See https://stackoverflow.com/q/42609768/2083599
+export = concurrently;
+export default concurrently;

index.js

@@ -5,5 +5,10 @@
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const concurrently = require('./dist/src/index.js');
 
-module.exports = exports = concurrently.default;
+// For require()
+module.exports = exports = concurrently.concurrently;
+
+// For TS + import syntax; mimics `export default`
+exports.default = exports;
+
 Object.assign(exports, concurrently);

index.mjs

@@ -2,9 +2,9 @@
  * While in local development, make sure you've run `pnpm run build` first.
  */
 
-import concurrently from './dist/src/index.js';
+import { concurrently } from './dist/src/index.js';
 
 // NOTE: the star reexport doesn't work in Node <12.20, <14.13 and <15.
 export * from './dist/src/index.js';
 
-export default concurrently.default;
+export default concurrently;

jest.config.js

@@ -1,11 +1,30 @@
-/** @type {import('@jest/types').Config.InitialOptions} */
-const config = {
+// Need to extend from a base config because projects don't inherit configurations as documented
+// https://github.com/jestjs/jest/issues/11411
+/** @type {import('@jest/types').Config.InitialProjectOptions} */
+const baseConfig = {
     transform: {
-        '^.+\\.(t|j)sx?$': ['@swc/jest'],
+        '.*': ['@swc/jest'],
     },
-    collectCoverage: true,
-    collectCoverageFrom: ['src/**/*.ts', '!src/index.ts'],
     testPathIgnorePatterns: ['/node_modules/', '/dist'],
 };
 
+/** @type {import('@jest/types').Config.InitialOptions} */
+const config = {
+    collectCoverage: true,
+    projects: [
+        {
+            ...baseConfig,
+            displayName: 'unit',
+            collectCoverageFrom: ['src/**/*.ts', '!src/index.ts'],
+            // (src|bin) doesn't seem to work on Windows
+            testMatch: ['src', 'bin'].map((dir) => `<rootDir>/${dir}/**/*.spec.ts`),
+        },
+        {
+            ...baseConfig,
+            displayName: 'smoke',
+            testMatch: ['<rootDir>/tests/**/*.spec.ts'],
+        },
+    ],
+};
+
 module.exports = config;

package.json

@@ -3,7 +3,7 @@
   "version": "8.2.2",
   "description": "Run commands concurrently",
   "main": "index.js",
-  "types": "dist/src/index.d.ts",
+  "types": "index.d.ts",
   "type": "commonjs",
   "bin": {
     "concurrently": "./dist/bin/concurrently.js",
@@ -14,10 +14,14 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./index.mjs",
-      "require": "./index.js",
-      "default": "./index.js"
+      "import": {
+        "types": "./index.d.mts",
+        "default": "./index.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      }
     },
     "./package.json": "./package.json"
   },
@@ -31,7 +35,8 @@
     "lint:fix": "pnpm run lint --fix",
     "prepublishOnly": "safe-publish-latest && pnpm run build",
     "report-coverage": "cat coverage/lcov.info | coveralls",
-    "test": "jest",
+    "test": "jest --selectProjects unit",
+    "test:smoke": "jest --selectProjects smoke",
     "prepare": "husky install"
   },
   "repository": {
@@ -94,7 +99,9 @@
   "files": [
     "dist",
     "index.js",
+    "index.d.ts",
     "index.mjs",
+    "index.d.mts",
     "!**/fixtures",
     "!**/*.spec.js",
     "!**/*.spec.d.ts"

src/command.spec.ts

@@ -151,6 +151,14 @@ describe('#start()', () => {
             expect(command.state).toBe('exited');
         });
 
+        it('does not change state if there was an error', () => {
+            const { command } = createCommand();
+            command.start();
+            process.emit('error', 'foo');
+            process.emit('close', 0, null);
+            expect(command.state).toBe('errored');
+        });
+
         it('shares start and close timing events to the timing stream', async () => {
             const { command, values } = createCommand();
             const startDate = new Date();

src/command.ts

@@ -169,7 +169,11 @@ export class Command implements CommandInfo {
             .pipe(Rx.map((event) => event as [number | null, NodeJS.Signals | null]))
             .subscribe(([exitCode, signal]) => {
                 this.process = undefined;
-                this.state = 'exited';
+
+                // Don't override error event
+                if (this.state !== 'errored') {
+                    this.state = 'exited';
+                }
 
                 const endDate = new Date(Date.now());
                 this.timer.next({ startDate, endDate });

src/flow-control/restart-process.spec.ts

@@ -1,5 +1,5 @@
 import { createMockInstance } from 'jest-create-mock-instance';
-import { TestScheduler } from 'rxjs/testing';
+import { VirtualTimeScheduler } from 'rxjs';
 
 import { createFakeCloseEvent, FakeCommand } from '../fixtures/fake-command';
 import { Logger } from '../logger';
@@ -8,12 +8,14 @@ import { RestartProcess } from './restart-process';
 let commands: FakeCommand[];
 let controller: RestartProcess;
 let logger: Logger;
-let scheduler: TestScheduler;
+let scheduler: VirtualTimeScheduler;
 beforeEach(() => {
     commands = [new FakeCommand(), new FakeCommand()];
-
     logger = createMockInstance(Logger);
-    scheduler = new TestScheduler(() => true);
+
+    // Don't use TestScheduler as it's hardcoded to a max number of "frames" (time),
+    // which don't work for some tests in this suite
+    scheduler = new VirtualTimeScheduler();
     controller = new RestartProcess({
         logger,
         scheduler,
@@ -34,14 +36,31 @@ it('does not restart processes that complete with success', () => {
     expect(commands[1].start).toHaveBeenCalledTimes(0);
 });
 
-it('restarts processes that fail after delay has passed', () => {
+it('restarts processes that fail immediately, if no delay was passed', () => {
+    controller = new RestartProcess({ logger, scheduler, tries: 1 });
+    controller.handle(commands);
+
+    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+    scheduler.flush();
+
+    expect(scheduler.now()).toBe(0);
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} restarted`,
+        commands[0],
+    );
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+});
+
+it('restarts processes that fail after delay ms has passed', () => {
     controller.handle(commands);
 
     commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
     commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
 
     scheduler.flush();
 
+    expect(scheduler.now()).toBe(100);
     expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
     expect(logger.logCommandEvent).toHaveBeenCalledWith(
         `${commands[0].command} restarted`,
@@ -51,6 +70,23 @@ it('restarts processes that fail after delay has passed', () => {
     expect(commands[1].start).not.toHaveBeenCalled();
 });
 
+it('restarts processes that fail with an exponential back-off', () => {
+    const tries = 4;
+    controller = new RestartProcess({ logger, scheduler, tries, delay: 'exponential' });
+    controller.handle(commands);
+
+    let time = 0;
+    for (let i = 0; i < tries; i++) {
+        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
+        scheduler.flush();
+
+        time += Math.pow(2, i) * 1000;
+        expect(scheduler.now()).toBe(time);
+        expect(logger.logCommandEvent).toHaveBeenCalledTimes(i + 1);
+        expect(commands[0].start).toHaveBeenCalledTimes(i + 1);
+    }
+});
+
 it('restarts processes up to tries', () => {
     controller.handle(commands);
 

src/flow-control/restart-process.ts

@@ -1,18 +1,20 @@
 import * as Rx from 'rxjs';
-import { defaultIfEmpty, delay, filter, map, skip, take, takeWhile } from 'rxjs/operators';
+import { defaultIfEmpty, delayWhen, filter, map, skip, take, takeWhile } from 'rxjs/operators';
 
 import { Command } from '../command';
 import * as defaults from '../defaults';
 import { Logger } from '../logger';
 import { FlowController } from './flow-controller';
 
+export type RestartDelay = number | 'exponential';
+
 /**
  * Restarts commands that fail up to a defined number of times.
  */
 export class RestartProcess implements FlowController {
     private readonly logger: Logger;
     private readonly scheduler?: Rx.SchedulerLike;
-    readonly delay: number;
+    private readonly delay: RestartDelay;
     readonly tries: number;
 
     constructor({
@@ -21,13 +23,13 @@ export class RestartProcess implements FlowController {
         logger,
         scheduler,
     }: {
-        delay?: number;
+        delay?: RestartDelay;
         tries?: number;
         logger: Logger;
         scheduler?: Rx.SchedulerLike;
     }) {
         this.logger = logger;
-        this.delay = delay != null ? +delay : defaults.restartDelay;
+        this.delay = delay ?? 0;
         this.tries = tries != null ? +tries : defaults.restartTries;
         this.tries = this.tries < 0 ? Infinity : this.tries;
         this.scheduler = scheduler;
@@ -38,6 +40,12 @@ export class RestartProcess implements FlowController {
             return { commands };
         }
 
+        const delayOperator = delayWhen((_, index) => {
+            const { delay } = this;
+            const value = delay === 'exponential' ? Math.pow(2, index) * 1000 : delay;
+            return Rx.timer(value, this.scheduler);
+        });
+
         commands
             .map((command) =>
                 command.close.pipe(
@@ -50,7 +58,7 @@ export class RestartProcess implements FlowController {
                     // Delay the emission (so that the restarts happen on time),
                     // explicitly telling the subscriber that a restart is needed
                     failure.pipe(
-                        delay(this.delay, this.scheduler),
+                        delayOperator,
                         map(() => true),
                     ),
                     // Skip the first N emissions (as these would be duplicates of the above),