refactor: wip

Author: BioPhoton

packages/utils/eslint.config.js

@@ -18,6 +18,13 @@ export default tseslint.config(
       'n/no-sync': 'off',
     },
   },
+  {
+    files: ['packages/utils/src/lib/profiler/trace-file-utils.ts'],
+    rules: {
+      // os.availableParallelism() is checked for existence before use, with fallback to os.cpus().length
+      'n/no-unsupported-features/node-builtins': 'off',
+    },
+  },
   {
     files: ['**/*.json'],
     rules: {

packages/utils/src/lib/execute-process.int.test.ts

@@ -129,7 +129,7 @@ process:complete
           throwError: true,
         }),
       ),
-    ).rejects.toThrow('Process failed with exit code 1');
+    ).rejects.toThrowError('Process failed with exit code 1');
     expect(logger.debug).toHaveBeenCalledWith(
       expect.stringMatching(/process:start.*Error: dummy-error/s),
       { force: true },

packages/utils/src/lib/exit-process.int.test.ts

@@ -25,7 +25,7 @@ describe('subscribeProcessExit', () => {
   });
 
   it('should install event listeners for all expected events', () => {
-    expect(() => subscribeProcessExit({ onError, onExit })).not.toThrow();
+    expect(() => subscribeProcessExit({ onError, onExit })).not.toThrowError();
 
     expect(processOnSpy).toHaveBeenCalledWith(
       'uncaughtException',
@@ -42,86 +42,91 @@ describe('subscribeProcessExit', () => {
   });
 
   it('should call onError with error and kind for uncaughtException', () => {
-    expect(() => subscribeProcessExit({ onError })).not.toThrow();
+    expect(() => subscribeProcessExit({ onError })).not.toThrowError();
 
     const testError = new Error('Test uncaught exception');
 
     (process as any).emit('uncaughtException', testError);
 
-    expect(onError).toHaveBeenCalledWith(testError, 'uncaughtException');
-    expect(onError).toHaveBeenCalledOnce();
+    expect(onError).toHaveBeenCalledExactlyOnceWith(
+      testError,
+      'uncaughtException',
+    );
     expect(onExit).not.toHaveBeenCalled();
   });
 
   it('should call onError with reason and kind for unhandledRejection', () => {
-    expect(() => subscribeProcessExit({ onError })).not.toThrow();
+    expect(() => subscribeProcessExit({ onError })).not.toThrowError();
 
     const testReason = 'Test unhandled rejection';
 
     (process as any).emit('unhandledRejection', testReason);
 
-    expect(onError).toHaveBeenCalledWith(testReason, 'unhandledRejection');
-    expect(onError).toHaveBeenCalledOnce();
+    expect(onError).toHaveBeenCalledExactlyOnceWith(
+      testReason,
+      'unhandledRejection',
+    );
     expect(onExit).not.toHaveBeenCalled();
   });
 
   it('should call onExit and exit with code 0 for SIGINT', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
 
     (process as any).emit('SIGINT');
 
-    expect(onExit).toHaveBeenCalledOnce();
-    expect(onExit).toHaveBeenCalledWith(SIGNAL_EXIT_CODES().SIGINT, {
+    expect(onExit).toHaveBeenCalledExactlyOnceWith(SIGNAL_EXIT_CODES().SIGINT, {
       kind: 'signal',
       signal: 'SIGINT',
     });
     expect(onError).not.toHaveBeenCalled();
   });
 
   it('should call onExit and exit with code 0 for SIGTERM', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
 
     (process as any).emit('SIGTERM');
 
-    expect(onExit).toHaveBeenCalledOnce();
-    expect(onExit).toHaveBeenCalledWith(SIGNAL_EXIT_CODES().SIGTERM, {
-      kind: 'signal',
-      signal: 'SIGTERM',
-    });
+    expect(onExit).toHaveBeenCalledExactlyOnceWith(
+      SIGNAL_EXIT_CODES().SIGTERM,
+      {
+        kind: 'signal',
+        signal: 'SIGTERM',
+      },
+    );
     expect(onError).not.toHaveBeenCalled();
   });
 
   it('should call onExit and exit with code 0 for SIGQUIT', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
 
     (process as any).emit('SIGQUIT');
 
-    expect(onExit).toHaveBeenCalledOnce();
-    expect(onExit).toHaveBeenCalledWith(SIGNAL_EXIT_CODES().SIGQUIT, {
-      kind: 'signal',
-      signal: 'SIGQUIT',
-    });
+    expect(onExit).toHaveBeenCalledExactlyOnceWith(
+      SIGNAL_EXIT_CODES().SIGQUIT,
+      {
+        kind: 'signal',
+        signal: 'SIGQUIT',
+      },
+    );
     expect(onError).not.toHaveBeenCalled();
   });
 
   it('should call onExit for successful process termination with exit code 0', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
 
     (process as any).emit('exit', 0);
 
-    expect(onExit).toHaveBeenCalledOnce();
-    expect(onExit).toHaveBeenCalledWith(0, { kind: 'exit' });
+    expect(onExit).toHaveBeenCalledExactlyOnceWith(0, { kind: 'exit' });
     expect(onError).not.toHaveBeenCalled();
     expect(processExitSpy).not.toHaveBeenCalled();
   });
 
   it('should call onExit for failed process termination with exit code 1', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
 
     (process as any).emit('exit', 1);
 
-    expect(onExit).toHaveBeenCalledOnce();
-    expect(onExit).toHaveBeenCalledWith(1, { kind: 'exit' });
+    expect(onExit).toHaveBeenCalledExactlyOnceWith(1, { kind: 'exit' });
     expect(onError).not.toHaveBeenCalled();
     expect(processExitSpy).not.toHaveBeenCalled();
   });