@remix-run/cli 0.0.0 → 0.2.0

package/src/lib/doctor/project.ts

@@ -0,0 +1,435 @@
+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 {
+  createDoctorSuite,
+  type DoctorFinding,
+  type DoctorFixPlan,
+  type DoctorSuiteResult,
+} from './types.ts'
+
+export interface ProjectDoctorResult {
+  routesFile: string
+  routeManifest?: LoadedRouteManifest
+  suite: DoctorSuiteResult
+}
+
+export async function checkProject(projectRoot: string): Promise<ProjectDoctorResult> {
+  let routesFile = path.join(projectRoot, 'app', 'routes.ts')
+
+  if (!(await pathExists(routesFile))) {
+    return {
+      routesFile,
+      suite: createDoctorSuite('project', [
+        {
+          code: 'routes-file-missing',
+          expectedPath: 'app/routes.ts',
+          fixable: true,
+          message: 'Project is missing app/routes.ts.',
+          severity: 'warn',
+          suite: 'project',
+        },
+      ]),
+    }
+  }
+
+  try {
+    let routeManifest = await loadRouteManifestFromAppRoot(projectRoot)
+
+    return {
+      routeManifest,
+      routesFile,
+      suite: createDoctorSuite('project', []),
+    }
+  } catch (error) {
+    let finding = toProjectFinding(error)
+
+    return {
+      routesFile,
+      suite: createDoctorSuite('project', [finding]),
+    }
+  }
+}
+
+export async function getProjectFixPlans(projectRoot: string): Promise<DoctorFixPlan[]> {
+  let routesFile = path.join(projectRoot, 'app', 'routes.ts')
+  let homeActionPath = normalizeRelativePath(
+    path.join('app', 'controllers', `home${await inferHomeOwnerExtension(projectRoot)}`),
+  )
+
+  if (await pathExists(routesFile)) {
+    let routesSource = await fs.readFile(routesFile, 'utf8')
+    if (!hasOnlyWhitespaceAndComments(routesSource)) {
+      return []
+    }
+
+    return [
+      {
+        code: 'routes-export-missing',
+        contents: renderDefaultRoutesFile(),
+        kind: 'update-file',
+        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,
+          ]),
+    ]
+  }
+
+  return [
+    {
+      code: 'routes-file-missing',
+      contents: renderDefaultRoutesFile(),
+      kind: 'create-file',
+      path: 'app/routes.ts',
+      suite: 'project',
+    },
+    {
+      code: 'missing-owner',
+      contents: renderDefaultHomeAction(homeActionPath),
+      kind: 'create-file',
+      path: homeActionPath,
+      routeName: 'home',
+      suite: 'project',
+    },
+  ]
+}
+
+function toProjectFinding(error: unknown): DoctorFinding {
+  if (error instanceof CliError) {
+    if (error.code === 'RMX_ROUTE_MAP_LOADER_INVALID_JSON') {
+      return {
+        code: 'route-map-invalid-json',
+        message: 'Route-map loader returned invalid JSON while loading app/routes.ts.',
+        severity: 'warn',
+        suite: 'project',
+      }
+    }
+
+    if (error.code === 'RMX_ROUTE_MAP_LOADER_SIGNAL') {
+      return {
+        code: 'route-map-loader-signal',
+        message: error.message,
+        severity: 'warn',
+        suite: 'project',
+      }
+    }
+
+    if (error.code === 'RMX_ROUTE_MAP_LOADER_FAILED') {
+      return classifyRouteMapLoaderFailure(error.message)
+    }
+  }
+
+  let message = error instanceof Error ? error.message : String(error)
+  return {
+    code: 'route-module-import-failed',
+    message: `Failed to load app/routes.ts: ${message}`,
+    severity: 'warn',
+    suite: 'project',
+  }
+}
+
+function classifyRouteMapLoaderFailure(message: string): DoctorFinding {
+  if (message.includes('must export a named "routes" value')) {
+    return {
+      code: 'routes-export-missing',
+      message: 'app/routes.ts must export a named "routes" value.',
+      severity: 'warn',
+      suite: 'project',
+    }
+  }
+
+  if (
+    message.startsWith('Invalid route map value at "') ||
+    message.startsWith('Detected a route map cycle at "')
+  ) {
+    return {
+      code: 'route-map-invalid',
+      message,
+      severity: 'warn',
+      suite: 'project',
+    }
+  }
+
+  return {
+    code: 'route-module-import-failed',
+    message: `Failed to load app/routes.ts: ${message}`,
+    severity: 'warn',
+    suite: 'project',
+  }
+}
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch (error) {
+    let nodeError = error as NodeJS.ErrnoException
+    if (nodeError.code === 'ENOENT') {
+      return false
+    }
+
+    throw error
+  }
+}
+
+function hasOnlyWhitespaceAndComments(source: string): boolean {
+  for (let index = 0; index < source.length; ) {
+    let char = source[index]
+    let next = source[index + 1]
+
+    if (char == null || /\s/.test(char)) {
+      index += 1
+      continue
+    }
+
+    if (char === '/' && next === '/') {
+      index += 2
+      while (index < source.length && source[index] !== '\n') {
+        index += 1
+      }
+      continue
+    }
+
+    if (char === '/' && next === '*') {
+      index += 2
+      while (index < source.length && !(source[index] === '*' && source[index + 1] === '/')) {
+        index += 1
+      }
+      index = Math.min(index + 2, source.length)
+      continue
+    }
+
+    return false
+  }
+
+  return true
+}
+
+async function inferHomeOwnerExtension(projectRoot: string): Promise<OwnerFileExtension> {
+  let controllersDir = path.join(projectRoot, 'app', 'controllers')
+  let extensions = await collectOwnerExtensions(controllersDir)
+
+  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/fetch-router/routes'`,
+    '',
+    'export const routes = route({',
+    `  home: '/',`,
+    '})',
+    '',
+  ].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 const home = {',
+      '  handler() {',
+      '    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/controllers/home to keep building your app.</p>',
+      '        </body>',
+      '      </html>',
+      '    `',
+      '    return createHtmlResponse(page)',
+      '  },',
+      '}',
+      '',
+    ].join('\n')
+  }
+
+  if (extension === '.ts') {
+    return [
+      `import type { BuildAction } from 'remix/fetch-router'`,
+      `import { html } from 'remix/html-template'`,
+      `import { createHtmlResponse } from 'remix/response/html'`,
+      '',
+      `import type { routes } from '../routes.ts'`,
+      '',
+      `export const home: BuildAction<'ANY', typeof routes.home> = {`,
+      '  handler() {',
+      '    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/controllers/home 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 const home = {',
+      '  handler() {',
+      '    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/controllers/home to keep building your app.</p>',
+      '      </body>',
+      '    </html>',
+      '  )',
+      '}',
+      '',
+    ].join('\n')
+  }
+
+  return [
+    `import type { BuildAction } from 'remix/fetch-router'`,
+    `import { renderToStream } from 'remix/ui/server'`,
+    `import { createHtmlResponse } from 'remix/response/html'`,
+    '',
+    `import type { routes } from '../routes.ts'`,
+    '',
+    `export const home: BuildAction<'ANY', typeof routes.home> = {`,
+    '  handler() {',
+    '    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/controllers/home to keep building your app.</p>',
+    '      </body>',
+    '    </html>',
+    '  )',
+    '}',
+    '',
+  ].join('\n')
+}

package/src/lib/doctor/types.ts

@@ -0,0 +1,95 @@
+export type DoctorSuiteName = 'environment' | 'project' | 'controllers'
+export type DoctorFindingSeverity = 'warn' | 'advice'
+export type DoctorSuiteStatus = 'ok' | 'issues' | 'skipped'
+
+export type DoctorFindingCode =
+  | 'project-root-not-found'
+  | 'package-json-read-failed'
+  | 'package-json-invalid'
+  | 'node-engine-missing'
+  | 'node-engine-unparseable'
+  | 'node-version-unsupported'
+  | 'remix-dependency-missing'
+  | 'remix-install-missing'
+  | 'routes-file-missing'
+  | 'routes-export-missing'
+  | 'route-map-invalid'
+  | 'route-module-import-failed'
+  | 'route-map-invalid-json'
+  | 'route-map-loader-signal'
+  | 'missing-owner'
+  | 'wrong-owner-kind'
+  | 'ambiguous-owner'
+  | 'duplicate-owner-file'
+  | 'incomplete-controller'
+  | 'promotion-drift'
+  | 'orphan-action'
+  | 'orphan-controller'
+  | 'orphan-route-directory'
+
+export type DoctorFixKind = 'create-directory' | 'create-file' | 'update-file'
+
+export interface DoctorFinding {
+  actualPath?: string
+  code: DoctorFindingCode
+  expectedPath?: string
+  fixable?: boolean
+  message: string
+  routeName?: string
+  severity: DoctorFindingSeverity
+  suite: DoctorSuiteName
+}
+
+export interface DoctorFixPlan {
+  code: DoctorFindingCode
+  contents?: string
+  kind: DoctorFixKind
+  path: string
+  routeName?: string
+  suite: DoctorSuiteName
+}
+
+export interface DoctorAppliedFix {
+  code: DoctorFindingCode
+  kind: DoctorFixKind
+  path: string
+  routeName?: string
+  suite: DoctorSuiteName
+}
+
+export interface DoctorSuiteResult {
+  appliedFixes?: DoctorAppliedFix[]
+  findings: DoctorFinding[]
+  name: DoctorSuiteName
+  reason?: string
+  status: DoctorSuiteStatus
+}
+
+export interface DoctorReport {
+  appliedFixes?: DoctorAppliedFix[]
+  appRoot?: string
+  findings: DoctorFinding[]
+  remainingFindings?: DoctorFinding[]
+  routesFile?: string
+  suites: DoctorSuiteResult[]
+}
+
+export function createDoctorSuite(
+  name: DoctorSuiteName,
+  findings: DoctorFinding[],
+): DoctorSuiteResult {
+  return {
+    findings,
+    name,
+    status: findings.some((finding) => finding.severity === 'warn') ? 'issues' : 'ok',
+  }
+}
+
+export function createSkippedDoctorSuite(name: DoctorSuiteName, reason: string): DoctorSuiteResult {
+  return {
+    findings: [],
+    name,
+    reason,
+    status: 'skipped',
+  }
+}