file-system.ts

import ansis from 'ansis';
import { createJiti } from 'jiti';
import { mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';
import path from 'node:path';
import { parseJsonConfigFileContent, readConfigFile, sys } from 'typescript';
import type { Format, PersistConfig } from '@code-pushup/models';
import { formatBytes } from './formatting.js';
import { logMultipleResults } from './log-results.js';
import { logger } from './logger.js';

export async function readTextFile(filePath: string): Promise<string> {
  const buffer = await readFile(filePath);
  return buffer.toString();
}

export async function readJsonFile<T = unknown>(filePath: string): Promise<T> {
  const text = await readTextFile(filePath);
  return JSON.parse(text) as T;
}

export async function fileExists(filePath: string): Promise<boolean> {
  try {
    const stats = await stat(filePath);
    return stats.isFile();
  } catch {
    return false;
  }
}

export async function directoryExists(filePath: string): Promise<boolean> {
  try {
    const stats = await stat(filePath);
    return stats.isDirectory();
  } catch {
    return false;
  }
}

export async function ensureDirectoryExists(baseDir: string) {
  try {
    await mkdir(baseDir, { recursive: true });
    return;
  } catch (error) {
    const fsError = error as NodeJS.ErrnoException;
    logger.warn(fsError.message);
    if (fsError.code !== 'EEXIST') {
      throw error;
    }
  }
}

export async function removeDirectoryIfExists(dir: string) {
  if (await directoryExists(dir)) {
    await rm(dir, { recursive: true, force: true });
  }
}

export type FileResult = readonly [string] | readonly [string, number];
export type MultipleFileResults = PromiseSettledResult<FileResult>[];

export function logMultipleFileResults(
  fileResults: MultipleFileResults,
  messagePrefix: string,
): void {
  const succeededTransform = (result: PromiseFulfilledResult<FileResult>) => {
    const [fileName, size] = result.value;
    const formattedSize = size ? ` (${ansis.gray(formatBytes(size))})` : '';
    return `- ${ansis.bold(fileName)}${formattedSize}`;
  };
  const failedTransform = (result: PromiseRejectedResult) =>
    `- ${ansis.bold(String(result.reason))}`;

  logMultipleResults<FileResult>(
    fileResults,
    messagePrefix,
    succeededTransform,
    failedTransform,
  );
}

export function loadTargetConfig(tsConfigPath: string) {
  const resolvedConfigPath = path.resolve(tsConfigPath);
  const { config, error } = readConfigFile(resolvedConfigPath, sys.readFile);

  if (error) {
    throw new Error(
      `Error reading TypeScript config file at ${tsConfigPath}:\n${error.messageText}`,
    );
  }

  const parsedConfig = parseJsonConfigFileContent(
    config,
    sys,
    path.dirname(resolvedConfigPath),
    {},
    resolvedConfigPath,
  );

  if (parsedConfig.fileNames.length === 0) {
    throw new Error(
      'No files matched by the TypeScript configuration. Check your "include", "exclude" or "files" settings.',
    );
  }

  return parsedConfig;
}

type JitiOptions = Parameters<typeof createJiti>[1];

export function tsConfigToJitiOptionsTransformer(
  tsConfigPath: string,
): JitiOptions {
  const parsedConfig = loadTargetConfig(tsConfigPath);
  const compilerOptions = parsedConfig.options;

  const jitiOptions: JitiOptions = {};

  if (compilerOptions.paths) {
    const aliases: Record<string, string> = {};
    const basePath = compilerOptions.baseUrl || path.dirname(tsConfigPath);

    for (const alias in compilerOptions.paths) {
      const paths = compilerOptions.paths[alias];
      if (paths && paths.length > 0) {
        aliases[alias] = path.resolve(basePath, paths[0] as string);
      }
    }
    jitiOptions.alias = aliases;
  }

  if (compilerOptions.jsx) {
    jitiOptions.jsx = true;
  }

  return jitiOptions;
}

export async function importModule<T = unknown>(
  options: JitiOptions & { filepath: string; tsconfig?: string },
): Promise<T> {
  const { filepath, tsconfig, ...jitiOptions } = options;

  const jitiOptionsFromTsConfig = tsconfig
    ? tsConfigToJitiOptionsTransformer(tsconfig)
    : {};

  const jiti = createJiti(process.cwd(), {
    ...jitiOptions,
    ...jitiOptionsFromTsConfig,
  });

  const mod = await jiti.import(filepath);

  if (mod && typeof mod === 'object' && 'default' in mod) {
    return mod.default as T;
  }
  return mod as T;
}

export function createReportPath({
  outputDir,
  filename,
  format,
  suffix,
}: Pick<Required<PersistConfig>, 'filename' | 'outputDir'> & {
  format: Format;
  suffix?: string;
}): string {
  return path.join(
    outputDir,
    suffix ? `${filename}-${suffix}.${format}` : `${filename}.${format}`,
  );
}

export function pluginWorkDir(slug: string): string {
  return path.join('node_modules', '.code-pushup', slug);
}

export type CrawlFileSystemOptions<T> = {
  directory: string;
  pattern?: string | RegExp;
  fileTransform?: (filePath: string) => Promise<T> | T;
};
export async function crawlFileSystem<T = string>(
  options: CrawlFileSystemOptions<T>,
): Promise<T[]> {
  const {
    directory,
    pattern,
    fileTransform = (filePath: string) => filePath as T,
  } = options;

  const files = await readdir(directory);
  const promises = files.map(async (file): Promise<T | T[]> => {
    const filePath = path.join(directory, file);
    const stats = await stat(filePath);

    if (stats.isDirectory()) {
      return crawlFileSystem({ directory: filePath, pattern, fileTransform });
    }
    if (stats.isFile() && (!pattern || new RegExp(pattern).test(file))) {
      return fileTransform(filePath);
    }
    return [];
  });

  const resultsNestedArray = await Promise.all(promises);
  return resultsNestedArray.flat() as T[];
}

export async function findNearestFile(
  fileNames: string[],
  cwd = process.cwd(),
): Promise<string | undefined> {
  // eslint-disable-next-line functional/no-loop-statements
  for (
    // eslint-disable-next-line functional/no-let
    let directory = cwd;
    directory !== path.dirname(directory);
    directory = path.dirname(directory)
  ) {
    // eslint-disable-next-line functional/no-loop-statements
    for (const file of fileNames) {
      if (await fileExists(path.join(directory, file))) {
        return path.join(directory, file);
      }
    }
  }
  return undefined;
}

export function findLineNumberInText(
  content: string,
  pattern: string,
): number | null {
  const lines = content.split(/\r?\n/); // Split lines, handle both Windows and UNIX line endings

  const lineNumber = lines.findIndex(line => line.includes(pattern)) + 1; // +1 because line numbers are 1-based
  return lineNumber === 0 ? null : lineNumber; // If the package isn't found, return null
}

export function filePathToCliArg(filePath: string): string {
  // needs to be escaped if spaces included
  return `"${filePath}"`;
}

export function projectToFilename(project: string): string {
  return project.replace(/[/\\\s]+/g, '-').replace(/@/g, '');
}

type SplitFilePath = {
  folders: string[];
  file: string;
};

export function splitFilePath(filePath: string): SplitFilePath {
  const file = path.basename(filePath);
  const folders: string[] = [];
  // eslint-disable-next-line functional/no-loop-statements
  for (
    // eslint-disable-next-line functional/no-let
    let dirPath = path.dirname(filePath);
    path.dirname(dirPath) !== dirPath;
    dirPath = path.dirname(dirPath)
  ) {
    // eslint-disable-next-line functional/immutable-data
    folders.unshift(path.basename(dirPath));
  }
  return { folders, file };
}