@remix-run/cli 0.0.0 → 0.1.0

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

@@ -0,0 +1,184 @@
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+
+import {
+  getOwnerCandidateForExtension,
+  getOwnerFileExtension,
+  type OwnerFileExtension,
+} from '../controller-files.ts'
+import type {
+  ControllerOwnership,
+  OwnedSubtree,
+  OwnershipRouteNode,
+} from '../controller-ownership.ts'
+import { renderActionPlaceholder, renderControllerPlaceholder } from './controller-placeholders.ts'
+import type { DoctorFixPlan } from './types.ts'
+
+const OWNER_EXTENSION_PRIORITY: OwnerFileExtension[] = ['.tsx', '.ts', '.jsx', '.js']
+
+export async function getControllerFixPlans(
+  appRoot: string,
+  tree: OwnershipRouteNode[],
+  ownership: ControllerOwnership,
+): Promise<DoctorFixPlan[]> {
+  let routeNodesByName = getRouteNodesByName(tree)
+  let hasTsconfig = await pathExists(path.join(appRoot, 'tsconfig.json'))
+  let resolvedEntryPathByRouteName = new Map<string, string>()
+
+  for (let subtree of ownership.subtrees) {
+    if (subtree.actualEntryPath != null) {
+      resolvedEntryPathByRouteName.set(subtree.routeName, subtree.actualEntryPath)
+      continue
+    }
+
+    let fixCode = getFixCodeForSubtree(subtree)
+    if (fixCode == null) {
+      continue
+    }
+
+    let extension = inferOwnerExtension(subtree, ownership, hasTsconfig)
+    let targetPath =
+      getOwnerCandidateForExtension(subtree.entryCandidates, extension) ?? subtree.entryDisplayPath
+
+    resolvedEntryPathByRouteName.set(subtree.routeName, targetPath)
+  }
+
+  let fixPlans: DoctorFixPlan[] = []
+
+  for (let subtree of ownership.subtrees) {
+    let code = getFixCodeForSubtree(subtree)
+    if (code == null) {
+      continue
+    }
+
+    let routeNode = routeNodesByName.get(subtree.routeName)
+    let entryPath = resolvedEntryPathByRouteName.get(subtree.routeName)
+    if (routeNode == null || entryPath == null) {
+      continue
+    }
+
+    let contents =
+      subtree.kind === 'action'
+        ? renderActionPlaceholder(routeNode, entryPath)
+        : renderControllerPlaceholder(routeNode, entryPath, resolvedEntryPathByRouteName)
+
+    fixPlans.push({
+      code,
+      contents,
+      kind: 'create-file',
+      path: entryPath,
+      routeName: subtree.routeName,
+      suite: 'controllers',
+    })
+  }
+
+  return fixPlans
+}
+
+function getFixCodeForSubtree(subtree: OwnedSubtree): DoctorFixPlan['code'] | null {
+  if (subtree.actualEntryPaths.length > 1 || subtree.actualAlternatePaths.length > 1) {
+    return null
+  }
+
+  if (subtree.actualEntryPath != null) {
+    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'
+}
+
+function inferOwnerExtension(
+  subtree: OwnedSubtree,
+  ownership: ControllerOwnership,
+  hasTsconfig: boolean,
+): OwnerFileExtension {
+  let subtreeExtension = getMostCommonOwnerExtension(subtree.claimedRouteLocalFilePaths)
+  if (subtreeExtension != null) {
+    return subtreeExtension
+  }
+
+  let alternateExtension = getMostCommonOwnerExtension(subtree.actualAlternatePaths)
+  if (alternateExtension != null) {
+    return alternateExtension
+  }
+
+  let projectExtension = getMostCommonOwnerExtension([
+    ...ownership.scan.actionEntryPaths,
+    ...ownership.scan.controllerEntryPaths,
+  ])
+  if (projectExtension != null) {
+    return projectExtension
+  }
+
+  return hasTsconfig ? '.tsx' : '.js'
+}
+
+function getMostCommonOwnerExtension(filePaths: string[]): OwnerFileExtension | null {
+  let counts = new Map<OwnerFileExtension, number>()
+
+  for (let filePath of filePaths) {
+    let extension = getOwnerFileExtension(filePath)
+    if (extension == null) {
+      continue
+    }
+
+    counts.set(extension, (counts.get(extension) ?? 0) + 1)
+  }
+
+  if (counts.size === 0) {
+    return null
+  }
+
+  let bestExtension: OwnerFileExtension | null = null
+  let bestCount = -1
+
+  for (let extension of OWNER_EXTENSION_PRIORITY) {
+    let count = counts.get(extension) ?? 0
+    if (count > bestCount) {
+      bestCount = count
+      bestExtension = extension
+    }
+  }
+
+  return bestExtension
+}
+
+function getRouteNodesByName(tree: OwnershipRouteNode[]): Map<string, OwnershipRouteNode> {
+  let routeNodesByName = new Map<string, OwnershipRouteNode>()
+
+  function visit(nodes: OwnershipRouteNode[]): void {
+    for (let node of nodes) {
+      routeNodesByName.set(node.name, node)
+      visit(node.children)
+    }
+  }
+
+  visit(tree)
+  return routeNodesByName
+}
+
+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
+  }
+}

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

@@ -0,0 +1,242 @@
+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')
+}
+
+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),
+  )
+
+  if (extension === '.js' || extension === '.jsx') {
+    if (childImports.length > 0) {
+      lines.push(...childImports, '')
+    }
+
+    lines.push('export default {', '  actions: {')
+    lines.push(...actionEntries)
+    lines.push('  },', '}', '')
+    return lines.join('\n')
+  }
+
+  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('', 'export default {', '  actions: {')
+  lines.push(...actionEntries)
+  lines.push('  },', `} satisfies Controller<typeof ${routeExpression}>`, '')
+
+  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,
+  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)},`
+  }
+
+  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'
+
+  for (let segment of segments) {
+    expression += isIdentifier(segment) ? `.${segment}` : `[${JSON.stringify(segment)}]`
+  }
+
+  return expression
+}
+
+function getRelativeImportPath(fromFilePath: string, toFilePath: string): string {
+  let relativePath = path.posix.relative(path.posix.dirname(fromFilePath), toFilePath)
+  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+}
+
+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

@@ -0,0 +1,23 @@
+import { inspectControllerOwnership, type OwnershipRouteNode } from '../controller-ownership.ts'
+import { getControllerFindings } from './controller-findings.ts'
+import { getControllerFixPlans } from './controller-fix-plans.ts'
+import { createDoctorSuite, type DoctorFixPlan, type DoctorSuiteResult } from './types.ts'
+
+export interface ControllerDoctorResult {
+  fixPlans: DoctorFixPlan[]
+  suite: DoctorSuiteResult
+}
+
+export async function checkControllerConventions(
+  appRoot: string,
+  tree: OwnershipRouteNode[],
+): Promise<ControllerDoctorResult> {
+  let ownership = await inspectControllerOwnership(appRoot, tree)
+  let fixPlans = await getControllerFixPlans(appRoot, tree, ownership)
+  let findings = getControllerFindings(ownership, fixPlans)
+
+  return {
+    fixPlans,
+    suite: createDoctorSuite('controllers', findings),
+  }
+}