ts-repo-utils 6.1.0 → 7.0.0

package/src/functions/exec-async.mts

@@ -1,19 +1,15 @@
-import {
-  exec,
-  type ExecException,
-  type ExecOptions as ExecOptions_,
-} from 'node:child_process';
+import * as childProcess from 'node:child_process';
 import { Result } from 'ts-data-forge';
 
 type ExecOptionsCustom = Readonly<{
   silent?: boolean;
 }>;
 
-type ExecOptions = DeepReadonly<ExecOptions_ & ExecOptionsCustom>;
+export type ExecOptions = childProcess.ExecOptions & ExecOptionsCustom;
 
-type ExecResult<T extends string | Buffer> = Result<
+export type ExecResult<T extends string | Buffer> = Result<
   Readonly<{ stdout: T; stderr: T }>,
-  ExecException
+  childProcess.ExecException
 >;
 
 /**
@@ -30,16 +26,19 @@ export function $(
 
 export function $(
   command: string,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   options: Readonly<{ encoding: 'buffer' | null } & ExecOptions>,
 ): Promise<ExecResult<Buffer>>;
 
 export function $(
   command: string,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   options: Readonly<{ encoding: BufferEncoding } & ExecOptions>,
 ): Promise<ExecResult<string>>;
 
 export function $(
   command: string,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   options?: Readonly<
     { encoding?: BufferEncoding | 'buffer' | null } & ExecOptions
   >,
@@ -52,28 +51,21 @@ export function $(
 
   return new Promise((resolve) => {
     // eslint-disable-next-line security/detect-child-process
-    exec(
-      command,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      restOptions as {
-        encoding?: 'buffer' | null | BufferEncoding;
-      } & ExecOptions_,
-      (error, stdout, stderr) => {
-        if (!silent) {
-          if (stdout !== '') {
-            echo(stdout);
-          }
-          if (stderr !== '') {
-            console.error(stderr);
-          }
+    childProcess.exec(command, restOptions, (error, stdout, stderr) => {
+      if (!silent) {
+        if (stdout !== '') {
+          echo(stdout);
         }
-
-        if (error !== null) {
-          resolve(Result.err(error));
-        } else {
-          resolve(Result.ok({ stdout, stderr }));
+        if (stderr !== '') {
+          console.error(stderr);
         }
-      },
-    );
+      }
+
+      if (error !== null) {
+        resolve(Result.err(error));
+      } else {
+        resolve(Result.ok({ stdout, stderr }));
+      }
+    });
   });
 }

package/src/functions/exec-async.test.mts

@@ -448,53 +448,83 @@ describe('exec-async', () => {
     });
 
     test('should demonstrate type equivalence with runtime comparison', async () => {
-      // Create a type that represents what exec callback receives
-      type ExecCallbackParams<T extends string | Buffer> = {
-        error: ExecException | null;
-        stdout: T;
-        stderr: T;
-      };
-
-      // Helper to capture exec callback types
-      const captureExecTypes = <T extends string | Buffer>(
-        _encoding?: BufferEncoding | 'buffer' | null,
-      ): ExecCallbackParams<T> => {
-        const emptyParams: ExecCallbackParams<T> = {
-          error: null,
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-          stdout: undefined as unknown as T,
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-          stderr: undefined as unknown as T,
-        };
-        return emptyParams;
-      };
-
-      // Default encoding comparison
-      const _execDefault = captureExecTypes<string>();
-      const $Default = await $('echo "test"', { silent: true });
-      if (Result.isOk($Default)) {
-        expectType<typeof _execDefault.stdout, typeof $Default.value.stdout>(
-          '=',
-        );
-        expectType<typeof _execDefault.stderr, typeof $Default.value.stderr>(
-          '=',
-        );
-      }
-
-      // Buffer encoding comparison
-      const _execBuffer = captureExecTypes<Buffer>('buffer');
-      const $Buffer = await $('echo "test"', {
-        encoding: 'buffer',
-        silent: true,
-      });
-      if (Result.isOk($Buffer)) {
-        expectType<typeof _execBuffer.stdout, typeof $Buffer.value.stdout>('=');
-        expectType<typeof _execBuffer.stderr, typeof $Buffer.value.stderr>('=');
-      }
-
-      // Error type comparison
-      if (Result.isErr($Default)) {
-        expectType<ExecException, typeof $Default.value>('=');
+      // Mock console functions to suppress output
+      const consoleLogSpy = vi
+        // eslint-disable-next-line vitest/no-restricted-vi-methods
+        .spyOn(console, 'log')
+        .mockImplementation(() => {});
+
+      const consoleErrorSpy = vi
+        // eslint-disable-next-line vitest/no-restricted-vi-methods
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      const stderrWriteSpy = vi
+        // eslint-disable-next-line vitest/no-restricted-vi-methods
+        .spyOn(process.stderr, 'write')
+        .mockImplementation(() => true);
+
+      try {
+        await withSilentEcho(async () => {
+          // Create a type that represents what exec callback receives
+          type ExecCallbackParams<T extends string | Buffer> = {
+            error: ExecException | null;
+            stdout: T;
+            stderr: T;
+          };
+
+          // Helper to capture exec callback types
+          const captureExecTypes = <T extends string | Buffer>(
+            _encoding?: BufferEncoding | 'buffer' | null,
+          ): ExecCallbackParams<T> => {
+            const emptyParams: ExecCallbackParams<T> = {
+              error: null,
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+              stdout: undefined as unknown as T,
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+              stderr: undefined as unknown as T,
+            };
+            return emptyParams;
+          };
+
+          // Default encoding comparison
+          const _execDefault = captureExecTypes<string>();
+          const $Default = await $('echo "test"', { silent: true });
+          if (Result.isOk($Default)) {
+            expectType<
+              typeof _execDefault.stdout,
+              typeof $Default.value.stdout
+            >('=');
+            expectType<
+              typeof _execDefault.stderr,
+              typeof $Default.value.stderr
+            >('=');
+          }
+
+          // Buffer encoding comparison
+          const _execBuffer = captureExecTypes<Buffer>('buffer');
+          const $Buffer = await $('echo "test"', {
+            encoding: 'buffer',
+            silent: true,
+          });
+          if (Result.isOk($Buffer)) {
+            expectType<typeof _execBuffer.stdout, typeof $Buffer.value.stdout>(
+              '=',
+            );
+            expectType<typeof _execBuffer.stderr, typeof $Buffer.value.stderr>(
+              '=',
+            );
+          }
+
+          // Error type comparison
+          if (Result.isErr($Default)) {
+            expectType<ExecException, typeof $Default.value>('=');
+          }
+        });
+      } finally {
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        stderrWriteSpy.mockRestore();
       }
     });
   });