ts-repo-utils 6.1.0 → 7.0.0

package/src/functions/format.mts

@@ -1,89 +1,120 @@
+import { type ExecException } from 'node:child_process';
 import * as prettier from 'prettier';
-import { Arr, Result } from 'ts-data-forge';
+import { Arr, isNotUndefined, Result } from 'ts-data-forge';
 import '../node-global.mjs';
-import { getDiffFrom, getUntrackedFiles } from './diff.mjs';
+import {
+  getDiffFrom,
+  getModifiedFiles,
+  getStagedFiles,
+  getUntrackedFiles,
+} from './diff.mjs';
 
 /**
  * Format a list of files using Prettier
  *
  * @param files - Array of file paths to format
- * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatFilesList = async (
+export const formatFiles = async (
   files: readonly string[],
   options?: Readonly<{ silent?: boolean }>,
-): Promise<'ok' | 'err'> => {
+): Promise<Result<undefined, readonly unknown[]>> => {
   const silent = options?.silent ?? false;
 
+  const conditionalEcho = silent ? () => {} : echo;
+
   if (files.length === 0) {
-    if (!silent) {
-      echo('No files to format');
-    }
-    return 'ok';
+    conditionalEcho('No files to format');
+    return Result.ok(undefined);
   }
 
-  if (!silent) {
-    echo(`Formatting ${files.length} files...`);
-  }
+  conditionalEcho(`Formatting ${files.length} files...`);
 
   // Format each file
-  const results = await Promise.allSettled(
-    files.map(async (filePath) => {
-      try {
-        // Read file content
-        const content = await fs.readFile(filePath, 'utf8');
+  const results: readonly PromiseSettledResult<Result<undefined, unknown>>[] =
+    // NOTE: Using Promise.allSettled to ensure all files are processed even if some fail
+    await Promise.allSettled(
+      files.map(async (filePath) => {
+        try {
+          // Check if file exists first
+          try {
+            await fs.access(filePath);
+          } catch {
+            // File doesn't exist, skip it
+            conditionalEcho(`Skipping non-existent file: ${filePath}`);
+            return Result.ok(undefined);
+          }
 
-        // Resolve prettier config for this file
-        const prettierOptions = await prettier.resolveConfig(filePath);
+          // Read file content
+          const content = await fs.readFile(filePath, 'utf8');
 
-        // Check if file is ignored by prettier
-        const fileInfo = await prettier.getFileInfo(filePath, {
-          ignorePath: '.prettierignore',
-        });
+          // Resolve prettier config for this file
+          const prettierOptions = await prettier.resolveConfig(filePath);
 
-        if (fileInfo.ignored) {
-          if (!silent) {
-            echo(`Skipping ignored file: ${filePath}`);
+          // Check if file is ignored by prettier
+          const fileInfo = await prettier.getFileInfo(filePath, {
+            ignorePath: '.prettierignore',
+          });
+
+          if (fileInfo.ignored) {
+            conditionalEcho(`Skipping ignored file: ${filePath}`);
+            return Result.ok(undefined);
           }
-          return;
-        }
 
-        // Format the content
-        const formatted = await prettier.format(content, {
-          ...prettierOptions,
-          filepath: filePath,
-        });
+          // Format the content
+          const formatted = await prettier.format(content, {
+            ...prettierOptions,
+            filepath: filePath,
+          });
+
+          // Only write if content changed
+          if (formatted === content) {
+            conditionalEcho(`Unchanged: ${filePath}`);
+          } else {
+            await fs.writeFile(filePath, formatted, 'utf8');
+            conditionalEcho(`Formatted: ${filePath}`);
+          }
 
-        // Only write if content changed
-        if (formatted !== content) {
-          await fs.writeFile(filePath, formatted, 'utf8');
+          return Result.ok(undefined);
+        } catch (error) {
           if (!silent) {
-            echo(`Formatted: ${filePath}`);
+            console.error(`Error formatting ${filePath}:`, error);
           }
+          return Result.err(error);
         }
-      } catch (error) {
-        console.error(`Error formatting ${filePath}:`, error);
-        throw error;
-      }
-    }),
-  );
+      }),
+    );
 
-  // Check if any formatting failed
-  const hasErrors = results.some((result) => result.status === 'rejected');
-  return hasErrors ? 'err' : 'ok';
+  if (results.every((r) => r.status === 'fulfilled')) {
+    const fulfilled = results.map((r) => r.value);
+    if (fulfilled.every(Result.isOk)) {
+      return Result.ok(undefined);
+    } else {
+      const errors: readonly unknown[] = fulfilled
+        .filter(Result.isErr)
+        .map((r) => r.value);
+
+      return Result.err(errors);
+    }
+  } else {
+    const errors: readonly unknown[] = results
+      .filter((r) => r.status === 'rejected')
+      .map((r) => r.reason as unknown);
+
+    return Result.err(errors);
+  }
 };
 
 /**
  * Format files matching the given glob pattern using Prettier
  *
  * @param pathGlob - Glob pattern to match files
- * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatFiles = async (
+export const formatFilesGlob = async (
   pathGlob: string,
   options?: Readonly<{ silent?: boolean }>,
-): Promise<'ok' | 'err'> => {
+): Promise<Result<undefined, unknown>> => {
   const silent = options?.silent ?? false;
+  const conditionalEcho = silent ? () => {} : echo;
 
   try {
     // Find all files matching the glob
@@ -94,16 +125,16 @@ export const formatFiles = async (
     });
 
     if (files.length === 0) {
-      if (!silent) {
-        echo('No files found matching pattern:', pathGlob);
-      }
-      return 'ok';
+      conditionalEcho('No files found matching pattern:', pathGlob);
+      return Result.ok(undefined);
     }
 
-    return await formatFilesList(files, { silent });
+    return await formatFiles(files, { silent });
   } catch (error) {
-    console.error('Error in formatFiles:', error);
-    return 'err';
+    if (!silent) {
+      console.error('Error in formatFiles:', error);
+    }
+    return Result.err(error);
   }
 };
 
@@ -111,63 +142,72 @@ export const formatFiles = async (
  * Format only files that have been changed (git status)
  *
  * @param options - Options for formatting
- * @returns 'ok' if successful, 'err' if any errors occurred
  */
-export const formatUntracked = async (
-  options?: Readonly<{ silent?: boolean }>,
-): Promise<'ok' | 'err'> => {
-  const silent = options?.silent ?? false;
-
-  try {
-    const untrackedFilesResult = await getUntrackedFiles({
-      silent,
-    });
+export const formatUncommittedFiles = async (
+  options?: Readonly<{
+    untracked?: boolean;
+    modified?: boolean;
+    staged?: boolean;
+    silent?: boolean;
+  }>,
+): Promise<
+  Result<
+    undefined,
+    ExecException | Readonly<{ message: string }> | readonly unknown[]
+  >
+> => {
+  const {
+    untracked = true,
+    modified = true,
+    staged = true,
+    silent = false,
+  } = options ?? {};
+
+  const mut_files: string[] = [];
+
+  if (untracked) {
+    const untrackedFilesResult = await getUntrackedFiles({ silent });
 
     if (Result.isErr(untrackedFilesResult)) {
-      console.error('Error getting changed files:', untrackedFilesResult.value);
-      return 'err';
+      if (!silent) {
+        console.error(
+          'Error getting changed files:',
+          untrackedFilesResult.value,
+        );
+      }
+      return untrackedFilesResult;
     }
 
-    const files = untrackedFilesResult.value;
+    mut_files.push(...untrackedFilesResult.value);
+  }
+
+  if (modified) {
+    const diffFilesResult = await getModifiedFiles({ silent });
 
-    if (files.length === 0) {
+    if (Result.isErr(diffFilesResult)) {
       if (!silent) {
-        echo('No changed files to format');
+        console.error('Error getting changed files:', diffFilesResult.value);
       }
-      return 'ok';
+      return diffFilesResult;
     }
 
-    if (!silent) {
-      echo('Formatting changed files:', files);
-    }
+    mut_files.push(...diffFilesResult.value);
+  }
 
-    // Filter out non-existent files before formatting
-    const fileExistenceChecks = await Promise.allSettled(
-      files.map(async (filePath) => {
-        try {
-          await fs.readFile(filePath, 'utf8');
-          return filePath;
-        } catch {
-          if (!silent) {
-            echo(`Skipping non-existent file: ${filePath}`);
-          }
-          return undefined;
-        }
-      }),
-    );
+  if (staged) {
+    const stagedFilesResult = await getStagedFiles({ silent });
 
-    const existingFiles = fileExistenceChecks
-      .filter(
-        (result): result is PromiseFulfilledResult<string> =>
-          result.status === 'fulfilled' && result.value !== undefined,
-      )
-      .map((result) => result.value);
+    if (Result.isErr(stagedFilesResult)) {
+      if (!silent) {
+        console.error('Error getting changed files:', stagedFilesResult.value);
+      }
+      return stagedFilesResult;
+    }
 
-    return await formatFilesList(existingFiles, { silent });
-  } catch (error) {
-    console.error('Error in formatUntracked:', error);
-    return 'err';
+    mut_files.push(...stagedFilesResult.value);
   }
+
+  return formatFiles(Arr.uniq(mut_files), { silent });
 };
 
 /**
@@ -178,71 +218,103 @@ export const formatUntracked = async (
  * @param options - Options for formatting
  * @param options.includeUntracked - Include untracked files in addition to diff
  *   files (default is true)
+ * @param options.includeStaged - Include staged files in addition to diff files
+ *   (default is true)
  * @param options.silent - Silent mode to suppress command output (default is
  *   false)
- * @returns 'ok' if successful, 'err' if any errors occurred
  */
 export const formatDiffFrom = async (
   base: string,
-  options?: Readonly<{ includeUntracked?: boolean; silent?: boolean }>,
-): Promise<'ok' | 'err'> => {
-  const silent = options?.silent ?? false;
-
-  try {
-    // Get files that differ from base branch/commit (excluding deleted files)
-    const diffFromBaseResult = await getDiffFrom(base, {
-      silent,
-    });
-
-    if (Result.isErr(diffFromBaseResult)) {
+  options?: Readonly<{
+    includeUntracked?: boolean;
+    includeModified?: boolean;
+    includeStaged?: boolean;
+    silent?: boolean;
+  }>,
+): Promise<
+  Result<
+    undefined,
+    | ExecException
+    | Readonly<{
+        message: string;
+      }>
+    | readonly unknown[]
+  >
+> => {
+  // const silent = options?.silent ?? false;
+  const {
+    silent = false,
+    includeUntracked = true,
+    includeModified = true,
+    includeStaged = true,
+  } = options ?? {};
+
+  const conditionalEcho = silent ? () => {} : echo;
+
+  // Get files that differ from base branch/commit (excluding deleted files)
+  const diffFromBaseResult = await getDiffFrom(base, {
+    silent,
+  });
+
+  if (Result.isErr(diffFromBaseResult)) {
+    if (!silent) {
       console.error('Error getting changed files:', diffFromBaseResult.value);
-      return 'err';
     }
+    return diffFromBaseResult;
+  }
 
-    const diffFiles = diffFromBaseResult.value;
-    let mut_allFiles = diffFiles;
-
-    // If includeUntracked is true, also get untracked files
-    if (options?.includeUntracked ?? true) {
-      const untrackedFilesResult = await getUntrackedFiles({
-        silent,
-      });
-
-      if (Result.isErr(untrackedFilesResult)) {
-        console.error(
-          'Error getting untracked files:',
-          untrackedFilesResult.value,
-        );
-        return 'err';
+  const diffFiles = diffFromBaseResult.value;
+  const mut_allFiles: string[] = diffFiles.slice();
+
+  // If includeUntracked is true, also get untracked files
+  for (const { type, flag, fn } of [
+    { type: 'untracked', flag: includeUntracked, fn: getUntrackedFiles },
+    { type: 'modified', flag: includeModified, fn: getModifiedFiles },
+    { type: 'staged', flag: includeStaged, fn: getStagedFiles },
+  ]) {
+    if (flag) {
+      // eslint-disable-next-line no-await-in-loop
+      const filesResult = await fn({ silent });
+
+      if (Result.isErr(filesResult)) {
+        if (!silent) {
+          console.error(`Error getting ${type} files:`, filesResult.value);
+        }
+        return filesResult;
       }
 
-      const untrackedFiles = untrackedFilesResult.value;
+      const files = filesResult.value;
 
       // Combine and deduplicate files
-      mut_allFiles = Arr.uniq([...diffFiles, ...untrackedFiles]);
-
-      if (!silent) {
-        echo(
-          `Formatting files that differ from ${base} and untracked files:`,
-          mut_allFiles,
-        );
-      }
-    } else {
-      if (!silent) {
-        echo(`Formatting files that differ from ${base}:`, mut_allFiles);
-      }
+      mut_allFiles.push(...files);
     }
+  }
 
-    if (mut_allFiles.length === 0) {
-      if (!silent) {
-        echo(`No files to format`);
-      }
-      return 'ok';
-    }
+  const allFiles = Arr.uniq(mut_allFiles);
 
-    return await formatFilesList(mut_allFiles, { silent });
-  } catch (error) {
-    console.error('Error in formatDiffFrom:', error);
-    return 'err';
+  if (!silent) {
+    const includedFileTypes = [
+      includeUntracked ? 'untracked files' : undefined,
+      includeModified ? 'modified files' : undefined,
+      includeStaged ? 'staged files' : undefined,
+    ].filter(isNotUndefined);
+
+    const message = [
+      `Formatting files that differ from ${base}`,
+      includedFileTypes
+        .map((s, i) =>
+          i !== includedFileTypes.length - 1 ? `, ${s}` : ` and ${s}`,
+        )
+        .join(''),
+    ].join('');
+
+    conditionalEcho(`${message}:`, allFiles);
   }
+
+  if (allFiles.length === 0) {
+    conditionalEcho('No files to format');
+    return Result.ok(undefined);
+  }
+
+  return formatFiles(allFiles, { silent });
 };