@remix-run/cli 0.1.0 → 0.3.0

package/src/lib/doctor/controller-findings.ts

@@ -1,4 +1,8 @@
-import type { ControllerOwnership, OwnedSubtree } from '../controller-ownership.ts'
+import {
+  ROOT_ROUTE_NAME,
+  type ControllerOwnership,
+  type OwnedSubtree,
+} from '../controller-ownership.ts'
 import type { DoctorFinding, DoctorFixPlan } from './types.ts'
 
 export function getControllerFindings(
@@ -7,26 +11,19 @@ export function getControllerFindings(
 ): DoctorFinding[] {
   return [
     ...getSubtreeFindings(ownership.subtrees, fixPlans),
-    ...ownership.orphanActionPaths.map((actualPath) => ({
-      actualPath,
-      code: 'orphan-action' as const,
-      message: `Standalone action ${actualPath} does not match any top-level route.`,
-      severity: 'warn' as const,
-      suite: 'controllers' as const,
-    })),
     ...ownership.orphanControllerPaths.map((actualPath) => ({
       actualPath,
       code: 'orphan-controller' as const,
-      message: `Controller ${actualPath} does not match any route group.`,
+      message: `Action controller ${actualPath} does not match any route map.`,
       severity: 'warn' as const,
-      suite: 'controllers' as const,
+      suite: 'actions' as const,
     })),
     ...ownership.orphanRouteDirectoryPaths.map((actualPath) => ({
       actualPath,
       code: 'orphan-route-directory' as const,
-      message: `Directory ${actualPath} does not match any route subtree.`,
+      message: `Directory ${actualPath} does not match any route-map key path.`,
       severity: 'warn' as const,
-      suite: 'controllers' as const,
+      suite: 'actions' as const,
     })),
   ]
 }
@@ -38,71 +35,22 @@ function getSubtreeFindings(subtrees: OwnedSubtree[], fixPlans: DoctorFixPlan[])
   )
 
   for (let subtree of subtrees) {
-    let actualEntryPath = subtree.actualEntryPath ?? undefined
-    let actualAlternatePath = subtree.actualAlternatePath ?? undefined
+    let routeMapName = formatRouteMapName(subtree.routeName)
 
     if (subtree.actualEntryPaths.length > 1) {
       findings.push({
         actualPath: subtree.actualEntryPaths[0],
         code: 'duplicate-owner-file',
         expectedPath: subtree.entryDisplayPath,
-        message: `Route "${subtree.routeName}" has multiple ${subtree.kind} files: ${subtree.actualEntryPaths.join(', ')}. Keep only one ${subtree.kind} owner file.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (subtree.actualAlternatePaths.length > 1) {
-      let alternateKind = subtree.kind === 'action' ? 'controller' : 'action'
-
-      findings.push({
-        actualPath: subtree.actualAlternatePaths[0],
-        code: 'duplicate-owner-file',
-        expectedPath: subtree.entryDisplayPath,
-        message: `Route "${subtree.routeName}" has multiple ${alternateKind} files: ${subtree.actualAlternatePaths.join(', ')}. Keep only one ${alternateKind} owner file.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (actualEntryPath != null && actualAlternatePath != null) {
-      findings.push({
-        actualPath: actualAlternatePath,
-        code: 'ambiguous-owner',
-        expectedPath: actualEntryPath,
-        message:
-          subtree.kind === 'action'
-            ? `Route "${subtree.routeName}" has both action ${actualEntryPath} and controller ${actualAlternatePath}.`
-            : `Route "${subtree.routeName}" has both controller ${actualEntryPath} and standalone action ${actualAlternatePath}.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (actualAlternatePath != null) {
-      findings.push({
-        actualPath: actualAlternatePath,
-        code: 'wrong-owner-kind',
-        expectedPath: subtree.entryDisplayPath,
-        message:
-          subtree.kind === 'action'
-            ? `Route "${subtree.routeName}" expects action ${subtree.entryDisplayPath}, but found controller ${actualAlternatePath}.`
-            : `Route "${subtree.routeName}" expects controller ${subtree.entryDisplayPath}, but found standalone action ${actualAlternatePath}.`,
-        fixable: fixableFindingKeys.has(`wrong-owner-kind:${subtree.routeName}`),
+        message: `${routeMapName} has multiple action controller files: ${subtree.actualEntryPaths.join(', ')}. Keep only one controller owner file.`,
         routeName: subtree.routeName,
         severity: 'warn',
-        suite: 'controllers',
+        suite: 'actions',
       })
       continue
     }
 
-    if (subtree.kind === 'controller' && subtree.actualEntryPath == null) {
+    if (subtree.actualEntryPath == null) {
       let code =
         subtree.claimedFilePaths.length > 0
           ? ('incomplete-controller' as const)
@@ -115,43 +63,18 @@ function getSubtreeFindings(subtrees: OwnedSubtree[], fixPlans: DoctorFixPlan[])
         fixable: fixableFindingKeys.has(`${code}:${subtree.routeName}`),
         message:
           subtree.claimedFilePaths.length > 0
-            ? `Route "${subtree.routeName}" has files under ${subtree.subtreePath}, but is missing controller ${subtree.entryDisplayPath}.`
-            : `Route "${subtree.routeName}" is missing controller ${subtree.entryDisplayPath}.`,
+            ? `${routeMapName} has files under ${subtree.subtreePath}, but is missing action controller ${subtree.entryDisplayPath}.`
+            : `${routeMapName} is missing action controller ${subtree.entryDisplayPath}.`,
         routeName: subtree.routeName,
         severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (subtree.kind === 'action' && subtree.claimedFilePaths.length > 0) {
-      findings.push({
-        actualPath: subtree.subtreePath,
-        code: 'promotion-drift',
-        expectedPath: actualEntryPath ?? subtree.entryDisplayPath,
-        message:
-          actualEntryPath == null
-            ? `Route "${subtree.routeName}" has files under ${subtree.subtreePath}, but is still expected to use action ${subtree.entryDisplayPath}. Promote it to controller ${subtree.alternateDisplayPath} or move the files back into ${subtree.entryDisplayPath}.`
-            : `Route "${subtree.routeName}" uses action ${actualEntryPath}, but also has files under ${subtree.subtreePath}. Promote it to controller ${subtree.alternateDisplayPath} or keep the route in ${actualEntryPath}.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
-      })
-      continue
-    }
-
-    if (subtree.actualEntryPath == null) {
-      findings.push({
-        code: 'missing-owner',
-        expectedPath: subtree.entryDisplayPath,
-        fixable: fixableFindingKeys.has(`missing-owner:${subtree.routeName}`),
-        message: `Route "${subtree.routeName}" is missing action ${subtree.entryDisplayPath}.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'controllers',
+        suite: 'actions',
       })
     }
   }
 
   return findings
 }
+
+function formatRouteMapName(routeName: string): string {
+  return routeName === ROOT_ROUTE_NAME ? 'Root route map' : `Route map "${routeName}"`
+}

package/src/lib/doctor/controller-fix-plans.ts

@@ -11,7 +11,8 @@ import type {
   OwnedSubtree,
   OwnershipRouteNode,
 } from '../controller-ownership.ts'
-import { renderActionPlaceholder, renderControllerPlaceholder } from './controller-placeholders.ts'
+import { ROOT_ROUTE_NAME } from '../controller-ownership.ts'
+import { renderControllerPlaceholder } from './controller-placeholders.ts'
 import type { DoctorFixPlan } from './types.ts'
 
 const OWNER_EXTENSION_PRIORITY: OwnerFileExtension[] = ['.tsx', '.ts', '.jsx', '.js']
@@ -57,10 +58,7 @@ export async function getControllerFixPlans(
       continue
     }
 
-    let contents =
-      subtree.kind === 'action'
-        ? renderActionPlaceholder(routeNode, entryPath)
-        : renderControllerPlaceholder(routeNode, entryPath, resolvedEntryPathByRouteName)
+    let contents = renderControllerPlaceholder(routeNode, entryPath)
 
     fixPlans.push({
       code,
@@ -68,7 +66,7 @@ export async function getControllerFixPlans(
       kind: 'create-file',
       path: entryPath,
       routeName: subtree.routeName,
-      suite: 'controllers',
+      suite: 'actions',
     })
   }
 
@@ -76,7 +74,7 @@ export async function getControllerFixPlans(
 }
 
 function getFixCodeForSubtree(subtree: OwnedSubtree): DoctorFixPlan['code'] | null {
-  if (subtree.actualEntryPaths.length > 1 || subtree.actualAlternatePaths.length > 1) {
+  if (subtree.actualEntryPaths.length > 1) {
     return null
   }
 
@@ -84,19 +82,7 @@ function getFixCodeForSubtree(subtree: OwnedSubtree): DoctorFixPlan['code'] | nu
     return null
   }
 
-  if (subtree.actualAlternatePath != null) {
-    return 'wrong-owner-kind'
-  }
-
-  if (subtree.kind === 'controller') {
-    return subtree.claimedFilePaths.length > 0 ? 'incomplete-controller' : 'missing-owner'
-  }
-
-  if (subtree.claimedFilePaths.length > 0) {
-    return null
-  }
-
-  return 'missing-owner'
+  return subtree.claimedFilePaths.length > 0 ? 'incomplete-controller' : 'missing-owner'
 }
 
 function inferOwnerExtension(
@@ -109,15 +95,7 @@ function inferOwnerExtension(
     return subtreeExtension
   }
 
-  let alternateExtension = getMostCommonOwnerExtension(subtree.actualAlternatePaths)
-  if (alternateExtension != null) {
-    return alternateExtension
-  }
-
-  let projectExtension = getMostCommonOwnerExtension([
-    ...ownership.scan.actionEntryPaths,
-    ...ownership.scan.controllerEntryPaths,
-  ])
+  let projectExtension = getMostCommonOwnerExtension([...ownership.scan.controllerEntryPaths])
   if (projectExtension != null) {
     return projectExtension
   }
@@ -157,6 +135,12 @@ function getMostCommonOwnerExtension(filePaths: string[]): OwnerFileExtension |
 
 function getRouteNodesByName(tree: OwnershipRouteNode[]): Map<string, OwnershipRouteNode> {
   let routeNodesByName = new Map<string, OwnershipRouteNode>()
+  routeNodesByName.set(ROOT_ROUTE_NAME, {
+    children: tree,
+    key: ROOT_ROUTE_NAME,
+    kind: 'group',
+    name: ROOT_ROUTE_NAME,
+  })
 
   function visit(nodes: OwnershipRouteNode[]): void {
     for (let node of nodes) {

package/src/lib/doctor/controller-placeholders.ts

@@ -1,108 +1,19 @@
 import * as path from 'node:path'
 
 import { getOwnerFileExtension } from '../controller-files.ts'
-import type { OwnershipRouteNode } from '../controller-ownership.ts'
-
-const RESERVED_BINDING_IDENTIFIERS = new Set([
-  'await',
-  'break',
-  'case',
-  'catch',
-  'class',
-  'const',
-  'continue',
-  'debugger',
-  'default',
-  'delete',
-  'do',
-  'else',
-  'enum',
-  'export',
-  'extends',
-  'false',
-  'finally',
-  'for',
-  'function',
-  'if',
-  'implements',
-  'import',
-  'in',
-  'instanceof',
-  'interface',
-  'let',
-  'new',
-  'null',
-  'package',
-  'private',
-  'protected',
-  'public',
-  'return',
-  'static',
-  'super',
-  'switch',
-  'this',
-  'throw',
-  'true',
-  'try',
-  'typeof',
-  'var',
-  'void',
-  'while',
-  'with',
-  'yield',
-])
-
-export function renderActionPlaceholder(routeNode: OwnershipRouteNode, entryPath: string): string {
-  let routeMessage = `TODO: implement routes.${routeNode.name}`
-  let extension = getOwnerFileExtension(entryPath)
-  let exportName = getActionExportName(routeNode.key)
-
-  if (extension === '.js' || extension === '.jsx') {
-    return [
-      `export const ${exportName} = {`,
-      `  handler() {`,
-      `    return new Response(${JSON.stringify(routeMessage)})`,
-      `  },`,
-      `}`,
-      '',
-    ].join('\n')
-  }
-
-  let routeExpression = getRouteAccessExpression(routeNode.name)
-  let routesImportPath = getRelativeImportPath(entryPath, 'app/routes.ts')
-  let method = routeNode.method ?? 'ANY'
-
-  return [
-    `import type { BuildAction } from 'remix/fetch-router'`,
-    '',
-    `import type { routes } from '${routesImportPath}'`,
-    '',
-    `export const ${exportName}: BuildAction<'${method}', typeof ${routeExpression}> = {`,
-    `  handler() {`,
-    `    return new Response(${JSON.stringify(routeMessage)})`,
-    `  },`,
-    `}`,
-    '',
-  ].join('\n')
-}
+import { ROOT_ROUTE_NAME, type OwnershipRouteNode } from '../controller-ownership.ts'
 
 export function renderControllerPlaceholder(
   routeNode: OwnershipRouteNode,
   entryPath: string,
-  resolvedEntryPathByRouteName: Map<string, string>,
 ): string {
   let extension = getOwnerFileExtension(entryPath)
   let lines: string[] = []
-  let childImports = getControllerChildImports(routeNode, entryPath, resolvedEntryPathByRouteName)
-  let actionEntries = routeNode.children.map((childNode) =>
-    renderControllerActionEntry(childNode, entryPath, resolvedEntryPathByRouteName),
-  )
+  let actionEntries = routeNode.children
+    .filter((childNode) => childNode.kind === 'route')
+    .map((childNode) => renderControllerActionEntry(childNode))
 
   if (extension === '.js' || extension === '.jsx') {
-    if (childImports.length > 0) {
-      lines.push(...childImports, '')
-    }
-
     lines.push('export default {', '  actions: {')
     lines.push(...actionEntries)
     lines.push('  },', '}', '')
@@ -112,85 +23,29 @@ export function renderControllerPlaceholder(
   let routeExpression = getRouteAccessExpression(routeNode.name)
   let routesImportPath = getRelativeImportPath(entryPath, 'app/routes.ts')
 
-  lines.push(`import type { Controller } from 'remix/fetch-router'`, '')
-  lines.push(`import type { routes } from '${routesImportPath}'`)
-
-  if (childImports.length > 0) {
-    lines.push('', ...childImports)
-  }
+  lines.push(`import { createController } from 'remix/router'`, '')
+  lines.push(`import { routes } from '${routesImportPath}'`)
 
-  lines.push('', 'export default {', '  actions: {')
+  lines.push('', `export default createController(${routeExpression}, {`, '  actions: {')
   lines.push(...actionEntries)
-  lines.push('  },', `} satisfies Controller<typeof ${routeExpression}>`, '')
+  lines.push('  },', '})', '')
 
   return lines.join('\n')
 }
 
-function getControllerChildImports(
-  routeNode: OwnershipRouteNode,
-  entryPath: string,
-  resolvedEntryPathByRouteName: Map<string, string>,
-): string[] {
-  let imports: string[] = []
-
-  for (let childNode of routeNode.children) {
-    if (childNode.kind !== 'group') {
-      continue
-    }
-
-    let childEntryPath = resolvedEntryPathByRouteName.get(childNode.name)
-    if (childEntryPath == null) {
-      continue
-    }
-
-    imports.push(
-      `import ${getControllerImportName(childNode.key)} from '${getRelativeImportPath(entryPath, childEntryPath)}'`,
-    )
-  }
-
-  return imports
+function renderControllerActionEntry(childNode: OwnershipRouteNode): string {
+  return [
+    `    ${formatObjectKey(childNode.key)}() {`,
+    `      return new Response(${JSON.stringify(`TODO: implement routes.${childNode.name}`)})`,
+    `    },`,
+  ].join('\n')
 }
 
-function renderControllerActionEntry(
-  childNode: OwnershipRouteNode,
-  entryPath: string,
-  resolvedEntryPathByRouteName: Map<string, string>,
-): string {
-  if (childNode.kind === 'route') {
-    return [
-      `    ${formatObjectKey(childNode.key)}() {`,
-      `      return new Response(${JSON.stringify(`TODO: implement routes.${childNode.name}`)})`,
-      `    },`,
-    ].join('\n')
-  }
-
-  let childEntryPath = resolvedEntryPathByRouteName.get(childNode.name)
-  if (childEntryPath != null) {
-    return `    ${formatObjectKey(childNode.key)}: ${getControllerImportName(childNode.key)},`
+function getRouteAccessExpression(routeName: string): string {
+  if (routeName === ROOT_ROUTE_NAME) {
+    return 'routes'
   }
 
-  return `    ${formatObjectKey(childNode.key)}: ${renderInlineControllerPlaceholder(childNode)},`
-}
-
-function renderInlineControllerPlaceholder(routeNode: OwnershipRouteNode): string {
-  let childEntries = routeNode.children.map((childNode) =>
-    childNode.kind === 'route'
-      ? `${formatObjectKey(childNode.key)}() { return new Response(${JSON.stringify(`TODO: implement routes.${childNode.name}`)}) }`
-      : `${formatObjectKey(childNode.key)}: ${renderInlineControllerPlaceholder(childNode)}`,
-  )
-
-  return `{ actions: { ${childEntries.join(', ')} } }`
-}
-
-function getControllerImportName(key: string): string {
-  return `${toIdentifier(key)}Controller`
-}
-
-function getActionExportName(key: string): string {
-  return toIdentifier(key)
-}
-
-function getRouteAccessExpression(routeName: string): string {
   let segments = routeName.split('.')
   let expression = 'routes'
 
@@ -210,33 +65,6 @@ function formatObjectKey(key: string): string {
   return isIdentifier(key) ? key : JSON.stringify(key)
 }
 
-function toIdentifier(value: string): string {
-  let parts = value.split(/[^A-Za-z0-9_$]+/).filter(Boolean)
-  if (parts.length === 0) {
-    return 'route'
-  }
-
-  let identifier = parts
-    .map((part, index) =>
-      index === 0 ? part.replace(/^./, (char) => char.toLowerCase()) : capitalize(part),
-    )
-    .join('')
-
-  if (!/^[A-Za-z_$]/.test(identifier)) {
-    return `route${capitalize(identifier)}`
-  }
-
-  if (RESERVED_BINDING_IDENTIFIERS.has(identifier)) {
-    return `route${capitalize(identifier)}`
-  }
-
-  return identifier
-}
-
-function capitalize(value: string): string {
-  return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`
-}
-
 function isIdentifier(value: string): boolean {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value)
 }

package/src/lib/doctor/controllers.ts

@@ -18,6 +18,6 @@ export async function checkControllerConventions(
 
   return {
     fixPlans,
-    suite: createDoctorSuite('controllers', findings),
+    suite: createDoctorSuite('actions', findings),
   }
 }