@remix-run/cli 0.3.4 → 0.4.0

package/src/lib/doctor/project.ts

@@ -1,12 +1,6 @@
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 
-import {
-  getOwnerFileExtension,
-  isActionFileName,
-  isControllerEntryFileName,
-  type OwnerFileExtension,
-} from '../controller-files.ts'
 import { CliError } from '../errors.ts'
 import { loadRouteManifestFromAppRoot, type LoadedRouteManifest } from '../route-map.ts'
 import {
@@ -61,9 +55,6 @@ export async function checkProject(projectRoot: string): Promise<ProjectDoctorRe
 
 export async function getProjectFixPlans(projectRoot: string): Promise<DoctorFixPlan[]> {
   let routesFile = path.join(projectRoot, 'app', 'routes.ts')
-  let homeActionPath = normalizeRelativePath(
-    path.join('app', 'actions', `controller${await inferHomeOwnerExtension(projectRoot)}`),
-  )
 
   if (await pathExists(routesFile)) {
     let routesSource = await fs.readFile(routesFile, 'utf8')
@@ -79,18 +70,6 @@ export async function getProjectFixPlans(projectRoot: string): Promise<DoctorFix
         path: 'app/routes.ts',
         suite: 'project',
       },
-      ...((await pathExists(path.join(projectRoot, homeActionPath)))
-        ? []
-        : [
-            {
-              code: 'missing-owner',
-              contents: renderDefaultHomeAction(homeActionPath),
-              kind: 'create-file',
-              path: homeActionPath,
-              routeName: 'home',
-              suite: 'project',
-            } satisfies DoctorFixPlan,
-          ]),
     ]
   }
 
@@ -102,14 +81,6 @@ export async function getProjectFixPlans(projectRoot: string): Promise<DoctorFix
       path: 'app/routes.ts',
       suite: 'project',
     },
-    {
-      code: 'missing-owner',
-      contents: renderDefaultHomeAction(homeActionPath),
-      kind: 'create-file',
-      path: homeActionPath,
-      routeName: 'home',
-      suite: 'project',
-    },
   ]
 }
 
@@ -224,78 +195,6 @@ function hasOnlyWhitespaceAndComments(source: string): boolean {
   return true
 }
 
-async function inferHomeOwnerExtension(projectRoot: string): Promise<OwnerFileExtension> {
-  let actionsDir = path.join(projectRoot, 'app', 'actions')
-  let extensions = await collectOwnerExtensions(actionsDir)
-
-  if (extensions.length > 0) {
-    return getMostCommonExtension(extensions)
-  }
-
-  if (await pathExists(path.join(projectRoot, 'tsconfig.json'))) {
-    return '.tsx'
-  }
-
-  return '.js'
-}
-
-async function collectOwnerExtensions(directory: string): Promise<OwnerFileExtension[]> {
-  try {
-    let entries = await fs.readdir(directory, { withFileTypes: true })
-    let extensions: OwnerFileExtension[] = []
-
-    for (let entry of entries) {
-      let absolutePath = path.join(directory, entry.name)
-
-      if (entry.isDirectory()) {
-        extensions.push(...(await collectOwnerExtensions(absolutePath)))
-        continue
-      }
-
-      let fileName = path.basename(absolutePath)
-      if (!isActionFileName(fileName) && !isControllerEntryFileName(fileName)) {
-        continue
-      }
-
-      let extension = getOwnerFileExtension(fileName)
-      if (extension != null) {
-        extensions.push(extension)
-      }
-    }
-
-    return extensions
-  } catch (error) {
-    let nodeError = error as NodeJS.ErrnoException
-    if (nodeError.code === 'ENOENT') {
-      return []
-    }
-
-    throw error
-  }
-}
-
-function getMostCommonExtension(extensions: OwnerFileExtension[]): OwnerFileExtension {
-  let priority: OwnerFileExtension[] = ['.tsx', '.ts', '.jsx', '.js']
-  let counts = new Map<OwnerFileExtension, number>()
-
-  for (let extension of extensions) {
-    counts.set(extension, (counts.get(extension) ?? 0) + 1)
-  }
-
-  let bestExtension = priority[0]
-  let bestCount = -1
-
-  for (let extension of priority) {
-    let count = counts.get(extension) ?? 0
-    if (count > bestCount) {
-      bestCount = count
-      bestExtension = extension
-    }
-  }
-
-  return bestExtension
-}
-
 function renderDefaultRoutesFile(): string {
   return [
     `import { route } from 'remix/routes'`,
@@ -306,138 +205,3 @@ function renderDefaultRoutesFile(): string {
     '',
   ].join('\n')
 }
-
-function normalizeRelativePath(filePath: string): string {
-  return filePath.split(path.sep).join('/')
-}
-
-function renderDefaultHomeAction(entryPath: string): string {
-  let extension = getOwnerFileExtension(entryPath)
-  if (extension === '.js') {
-    return [
-      `import { html } from 'remix/html-template'`,
-      `import { createHtmlResponse } from 'remix/response/html'`,
-      '',
-      'export default {',
-      '  actions: {',
-      '    home() {',
-      '      let page = html`',
-      '        <html lang="en">',
-      '          <head>',
-      '            <meta charset="utf-8" />',
-      '            <meta name="viewport" content="width=device-width, initial-scale=1" />',
-      '            <title>Home</title>',
-      '          </head>',
-      '          <body>',
-      '            <h1>Home</h1>',
-      '            <p>Update app/routes.ts and app/actions/controller to keep building your app.</p>',
-      '          </body>',
-      '        </html>',
-      '      `',
-      '      return createHtmlResponse(page)',
-      '    },',
-      '  },',
-      '}',
-      '',
-    ].join('\n')
-  }
-
-  if (extension === '.ts') {
-    return [
-      `import { createController } from 'remix/router'`,
-      `import { html } from 'remix/html-template'`,
-      `import { createHtmlResponse } from 'remix/response/html'`,
-      '',
-      `import { routes } from '../routes.ts'`,
-      '',
-      `export default createController(routes, {`,
-      '  actions: {',
-      '    home() {',
-      '      let page = html`',
-      '        <html lang="en">',
-      '          <head>',
-      '            <meta charset="utf-8" />',
-      '            <meta name="viewport" content="width=device-width, initial-scale=1" />',
-      '            <title>Home</title>',
-      '          </head>',
-      '          <body>',
-      '            <h1>Home</h1>',
-      '            <p>Update app/routes.ts and app/actions/controller to keep building your app.</p>',
-      '          </body>',
-      '        </html>',
-      '      `',
-      '      return createHtmlResponse(page)',
-      '    },',
-      '  },',
-      `})`,
-      '',
-    ].join('\n')
-  }
-
-  if (extension === '.jsx') {
-    return [
-      `import { renderToStream } from 'remix/ui/server'`,
-      `import { createHtmlResponse } from 'remix/response/html'`,
-      '',
-      'export default {',
-      '  actions: {',
-      '    home() {',
-      '      let page = <HomePage />',
-      '      return createHtmlResponse(renderToStream(page))',
-      '    },',
-      '  },',
-      '}',
-      '',
-      'function HomePage() {',
-      '  return () => (',
-      '    <html lang="en">',
-      '      <head>',
-      '        <meta charSet="utf-8" />',
-      '        <meta name="viewport" content="width=device-width, initial-scale=1" />',
-      '        <title>Home</title>',
-      '      </head>',
-      '      <body>',
-      '        <h1>Home</h1>',
-      '        <p>Update app/routes.ts and app/actions/controller to keep building your app.</p>',
-      '      </body>',
-      '    </html>',
-      '  )',
-      '}',
-      '',
-    ].join('\n')
-  }
-
-  return [
-    `import { createController } from 'remix/router'`,
-    `import { renderToStream } from 'remix/ui/server'`,
-    `import { createHtmlResponse } from 'remix/response/html'`,
-    '',
-    `import { routes } from '../routes.ts'`,
-    '',
-    `export default createController(routes, {`,
-    '  actions: {',
-    '    home() {',
-    '      let page = <HomePage />',
-    '      return createHtmlResponse(renderToStream(page))',
-    '    },',
-    '  },',
-    `})`,
-    '',
-    'function HomePage() {',
-    '  return () => (',
-    '    <html lang="en">',
-    '      <head>',
-    '        <meta charSet="utf-8" />',
-    '        <meta name="viewport" content="width=device-width, initial-scale=1" />',
-    '        <title>Home</title>',
-    '      </head>',
-    '      <body>',
-    '        <h1>Home</h1>',
-    '        <p>Update app/routes.ts and app/actions/controller to keep building your app.</p>',
-    '      </body>',
-    '    </html>',
-    '  )',
-    '}',
-    '',
-  ].join('\n')
-}

package/src/lib/doctor/run.ts

@@ -0,0 +1,311 @@
+import * as path from 'node:path'
+import * as process from 'node:process'
+
+import { checkControllerConventions } from './controllers.ts'
+import { checkEnvironment, getEnvironmentFixPlans } from './environment.ts'
+import { applyDoctorFixPlans } from './fixes.ts'
+import { checkProject, getProjectFixPlans } from './project.ts'
+import {
+  createDoctorSuite,
+  createSkippedDoctorSuite,
+  hasWarningFindings,
+  type DoctorAppliedFix,
+  type DoctorReport,
+  type DoctorSuiteName,
+  type DoctorSuiteResult,
+} from './types.ts'
+import {
+  createCommandReporter,
+  createStepProgressReporter,
+  type CommandReporter,
+  type StepProgressReporter,
+} from '../reporter.ts'
+
+const DOCTOR_SUITE_LABELS = {
+  actions: {
+    complete: 'actions',
+    running: 'Checking actions',
+  },
+  environment: {
+    complete: 'environment',
+    running: 'Checking environment',
+  },
+  project: {
+    complete: 'project',
+    running: 'Checking project',
+  },
+} satisfies Record<DoctorSuiteName, string | { complete: string; running: string }>
+
+export interface RunRemixDoctorOptions {
+  cwd: string
+  fix: boolean
+  json: boolean
+  remixVersion?: string
+  strict: boolean
+}
+
+export async function runRemixDoctor(options: RunRemixDoctorOptions): Promise<number> {
+  let reporter: CommandReporter | null = null
+  let progress: StepProgressReporter<DoctorSuiteName> | null = null
+
+  try {
+    reporter = options.json
+      ? null
+      : createCommandReporter({
+          remixVersion: options.remixVersion,
+          stderr: process.stdout,
+          stdout: process.stdout,
+        })
+    progress = reporter == null ? null : createDoctorProgressReporter(reporter)
+    if (reporter != null) {
+      await reporter.status.commandHeader('doctor')
+    }
+
+    let report = await collectDoctorReport(progress, options, reporter)
+
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`)
+    } else if (reporter != null) {
+      writeDoctorReport(reporter, report)
+      reporter.finish()
+    }
+
+    if ((options.fix || options.strict) && hasWarningFindings(report.findings)) {
+      return 1
+    }
+
+    return 0
+  } catch (error) {
+    progress?.writeSummaryGap()
+    reporter?.finish()
+    throw error
+  }
+}
+
+async function collectDoctorReport(
+  progress: StepProgressReporter<DoctorSuiteName> | null,
+  options: RunRemixDoctorOptions,
+  reporter: CommandReporter | null,
+): Promise<DoctorReport> {
+  let cwd = options.cwd
+  let appliedFixes: DoctorAppliedFix[] = []
+  let environment = await runDoctorSuite(progress, 'environment', async () => {
+    let result = await checkEnvironment(cwd)
+    let suiteAppliedFixes: DoctorAppliedFix[] = []
+    let finalResult = result
+
+    if (options.fix && result.projectRoot != null) {
+      let fixPlans = getEnvironmentFixPlans(result, options.remixVersion)
+      if (fixPlans.length > 0) {
+        suiteAppliedFixes = await applyDoctorFixPlans(result.projectRoot, fixPlans)
+        finalResult = await checkEnvironment(result.projectRoot)
+      }
+    }
+
+    let suite = finalResult.suite
+    if (suiteAppliedFixes.length > 0) {
+      suite = {
+        ...suite,
+        appliedFixes: suiteAppliedFixes,
+      }
+    }
+
+    return {
+      appliedFixes: suiteAppliedFixes,
+      projectRoot: finalResult.projectRoot ?? result.projectRoot,
+      suite,
+    }
+  })
+  let findings = [...environment.suite.findings]
+  appliedFixes.push(...(environment.appliedFixes ?? []))
+  let suites: DoctorSuiteResult[] = [environment.suite]
+  let routesFile =
+    environment.projectRoot == null
+      ? undefined
+      : path.join(environment.projectRoot, 'app', 'routes.ts')
+  writeDoctorSuiteDetails(reporter, environment.suite)
+  progress?.writeSummaryGap()
+
+  if (hasWarningFindings(environment.suite.findings)) {
+    let projectSuite = createSkippedDoctorSuite('project', 'Blocked by environment warnings.')
+    let actionsSuite = createSkippedDoctorSuite('actions', 'Blocked by environment warnings.')
+    suites.push(projectSuite, actionsSuite)
+    progress?.skip(projectSuite.name, projectSuite.reason)
+    writeDoctorSuiteDetails(reporter, projectSuite)
+    progress?.writeSummaryGap()
+    progress?.skip(actionsSuite.name, actionsSuite.reason)
+    writeDoctorSuiteDetails(reporter, actionsSuite)
+    progress?.writeSummaryGap()
+
+    return {
+      appRoot: environment.projectRoot,
+      appliedFixes,
+      findings,
+      remainingFindings: findings,
+      routesFile,
+      suites,
+    }
+  }
+
+  let project = await runDoctorSuite(progress, 'project', async () => {
+    let result = await checkProject(environment.projectRoot!)
+    let suiteAppliedFixes: DoctorAppliedFix[] = []
+    let finalResult = result
+
+    if (options.fix) {
+      let fixPlans = await getProjectFixPlans(environment.projectRoot!)
+      if (fixPlans.length > 0) {
+        suiteAppliedFixes = await applyDoctorFixPlans(environment.projectRoot!, fixPlans)
+        finalResult = await checkProject(environment.projectRoot!)
+      }
+    }
+
+    let suite = finalResult.suite
+    if (suiteAppliedFixes.length > 0) {
+      suite = {
+        ...suite,
+        appliedFixes: suiteAppliedFixes,
+      }
+    }
+
+    return {
+      appliedFixes: suiteAppliedFixes,
+      routeManifest: finalResult.routeManifest,
+      routesFile: finalResult.routesFile,
+      suite,
+    }
+  })
+  findings.push(...project.suite.findings)
+  appliedFixes.push(...(project.appliedFixes ?? []))
+  routesFile = project.routesFile
+  suites.push(project.suite)
+  writeDoctorSuiteDetails(reporter, project.suite)
+  progress?.writeSummaryGap()
+
+  if (hasWarningFindings(project.suite.findings)) {
+    let actionsSuite = createSkippedDoctorSuite('actions', 'Blocked by project warnings.')
+    suites.push(actionsSuite)
+    progress?.skip(actionsSuite.name, actionsSuite.reason)
+    writeDoctorSuiteDetails(reporter, actionsSuite)
+    progress?.writeSummaryGap()
+
+    return {
+      appRoot: environment.projectRoot,
+      appliedFixes,
+      findings,
+      remainingFindings: findings,
+      routesFile,
+      suites,
+    }
+  }
+
+  let actions = await runDoctorSuite(progress, 'actions', async () => {
+    let controllerResult = await checkControllerConventions(
+      project.routeManifest!.appRoot,
+      project.routeManifest!.tree,
+    )
+    return { suite: controllerResult.suite }
+  })
+
+  findings.push(...actions.suite.findings)
+  suites.push(actions.suite)
+  writeDoctorSuiteDetails(reporter, actions.suite)
+  progress?.writeSummaryGap()
+
+  let report: DoctorReport = {
+    appRoot: environment.projectRoot,
+    findings,
+    routesFile,
+    suites,
+  }
+
+  if (options.fix) {
+    report.appliedFixes = appliedFixes
+    report.remainingFindings = findings
+  }
+
+  return report
+}
+
+function formatAppliedFix(appliedFix: DoctorAppliedFix): string {
+  if (appliedFix.kind === 'update-file') {
+    return `Updated ${appliedFix.path}`
+  }
+
+  return `Created ${appliedFix.path}`
+}
+
+async function runDoctorSuite<
+  result extends { appliedFixes?: DoctorAppliedFix[]; suite: DoctorSuiteResult },
+>(
+  progress: StepProgressReporter<DoctorSuiteName> | null,
+  label: DoctorSuiteName,
+  callback: () => Promise<result>,
+): Promise<result> {
+  progress?.start(label)
+
+  try {
+    let result = await callback()
+
+    if (result.suite.status === 'ok') {
+      progress?.succeed(label)
+    } else if (result.suite.status === 'issues') {
+      progress?.fail(label)
+    } else {
+      progress?.skip(label, result.suite.reason)
+    }
+
+    return result
+  } catch (error) {
+    progress?.fail(label)
+    throw error
+  }
+}
+
+function createDoctorProgressReporter(
+  reporter: CommandReporter,
+): StepProgressReporter<DoctorSuiteName> {
+  return createStepProgressReporter(reporter.status, DOCTOR_SUITE_LABELS)
+}
+
+function writeDoctorReport(reporter: CommandReporter, report: DoctorReport): void {
+  let warningCount = report.findings.filter((finding) => finding.severity === 'warn').length
+  let adviceCount = report.findings.length - warningCount
+
+  if ((report.appliedFixes?.length ?? 0) > 0) {
+    let fixCount = report.appliedFixes!.length
+    reporter.out.line(`Applied ${fixCount} ${fixCount === 1 ? 'fix' : 'fixes'}.`)
+  }
+
+  if (report.findings.length === 0) {
+    reporter.out.line('Doctor found no issues.')
+  }
+
+  reporter.out.line(`Summary: ${warningCount} warnings, ${adviceCount} advice.`)
+}
+
+function writeDoctorSuiteDetails(reporter: CommandReporter | null, suite: DoctorSuiteResult): void {
+  if (reporter == null) {
+    return
+  }
+
+  if (suite.findings.length === 0 && (suite.appliedFixes?.length ?? 0) === 0) {
+    return
+  }
+
+  reporter.out.withIndent(() => {
+    for (let finding of suite.findings) {
+      reporter.out.bullet(
+        reporter.out.label(finding.severity.toUpperCase(), finding.message, {
+          tone: finding.severity === 'warn' ? 'warn' : undefined,
+        }),
+      )
+    }
+
+    if ((suite.appliedFixes?.length ?? 0) > 0) {
+      reporter.out.section('Applied fixes:', () => {
+        reporter.out.bullets((suite.appliedFixes ?? []).map(formatAppliedFix))
+      })
+    }
+  })
+}

package/src/lib/doctor/types.ts

@@ -18,10 +18,7 @@ export type DoctorFindingCode =
   | 'route-map-invalid-json'
   | 'route-map-loader-signal'
   | 'missing-owner'
-  | 'duplicate-owner-file'
-  | 'incomplete-controller'
-  | 'orphan-controller'
-  | 'orphan-route-directory'
+  | 'missing-route-directory'
 
 export type DoctorFixKind = 'create-directory' | 'create-file' | 'update-file'
 
@@ -70,6 +67,10 @@ export interface DoctorReport {
   suites: DoctorSuiteResult[]
 }
 
+export function hasWarningFindings(findings: DoctorFinding[]): boolean {
+  return findings.some((finding) => finding.severity === 'warn')
+}
+
 export function createDoctorSuite(
   name: DoctorSuiteName,
   findings: DoctorFinding[],
@@ -77,7 +78,7 @@ export function createDoctorSuite(
   return {
     findings,
     name,
-    status: findings.some((finding) => finding.severity === 'warn') ? 'issues' : 'ok',
+    status: hasWarningFindings(findings) ? 'issues' : 'ok',
   }
 }