@remix-run/cli 0.3.4 → 0.4.0

package/src/lib/controller-ownership.ts

@@ -3,16 +3,12 @@ import * as path from 'node:path'
 
 import {
   getControllerOwnerCandidates,
-  getOwnerModuleBaseName,
   getPreferredOwnerDisplayPath,
   getRouteSubtreePath,
-  isControllerEntryFileName,
   toDiskSegment,
 } from './controller-files.ts'
 import type { RouteTreeNodeKind } from './route-map.ts'
 
-const ACTIONS_PATH_PREFIX = 'app/actions/'
-
 export const ROOT_ROUTE_NAME = '<root>'
 
 export interface OwnershipRouteNode {
@@ -23,17 +19,15 @@ export interface OwnershipRouteNode {
   name: string
 }
 
-export interface ControllerDirectoryScan {
-  controllerEntryPaths: Set<string>
-  routeDirectoryPaths: Set<string>
-  routeLocalFilePaths: Set<string>
-}
-
 export interface RouteDirectoryPlan {
   directoryPath: string
   routeName: string
 }
 
+export interface RouteDirectory extends RouteDirectoryPlan {
+  exists: boolean
+}
+
 export interface OwnedSubtreePlan {
   entryCandidates: string[]
   entryDisplayPath: string
@@ -43,16 +37,10 @@ export interface OwnedSubtreePlan {
 
 export interface OwnedSubtree extends OwnedSubtreePlan {
   actualEntryPath: string | null
-  actualEntryPaths: string[]
-  claimedFilePaths: string[]
-  claimedRouteLocalFilePaths: string[]
 }
 
 export interface ControllerOwnership {
-  orphanControllerPaths: string[]
-  orphanRouteDirectoryPaths: string[]
-  routeDirectories: RouteDirectoryPlan[]
-  scan: ControllerDirectoryScan
+  routeDirectories: RouteDirectory[]
   subtrees: OwnedSubtree[]
 }
 
@@ -61,15 +49,14 @@ export async function inspectControllerOwnership(
   tree: OwnershipRouteNode[],
 ): Promise<ControllerOwnership> {
   let subtreePlans = buildOwnedSubtrees(tree)
-  let routeDirectories = buildRouteDirectories(tree)
-  let scan = await scanControllersDirectory(appRoot)
-  let subtrees = applyScanToSubtrees(subtreePlans, scan)
+  let routeDirectoryPlans = buildRouteDirectories(tree)
+  let [routeDirectories, subtrees] = await Promise.all([
+    inspectRouteDirectories(appRoot, routeDirectoryPlans),
+    inspectOwnedSubtrees(appRoot, subtreePlans),
+  ])
 
   return {
-    orphanControllerPaths: getOrphanControllerPaths(subtreePlans, scan),
-    orphanRouteDirectoryPaths: getOrphanRouteDirectoryPaths(routeDirectories, scan),
     routeDirectories,
-    scan,
     subtrees,
   }
 }
@@ -138,197 +125,57 @@ function addSubtreePlan(routeName: string, segments: string[], subtrees: OwnedSu
   })
 }
 
-async function scanControllersDirectory(appRoot: string): Promise<ControllerDirectoryScan> {
-  let actionsDir = path.join(appRoot, 'app', 'actions')
-  let controllerEntryPaths = new Set<string>()
-  let routeDirectoryPaths = new Set<string>()
-  let routeLocalFilePaths = new Set<string>()
-
-  async function walk(currentDir: string, isRoot: boolean): Promise<void> {
-    let entries
-    try {
-      entries = await fs.readdir(currentDir, { withFileTypes: true })
-    } catch (error) {
-      let nodeError = error as NodeJS.ErrnoException
-      if (nodeError.code === 'ENOENT' && isRoot) {
-        return
-      }
-
-      throw error
-    }
-
-    for (let entry of entries) {
-      let entryPath = path.join(currentDir, entry.name)
-      let relativePath = normalizeRelativePath(path.relative(appRoot, entryPath))
-
-      if (entry.isDirectory()) {
-        routeDirectoryPaths.add(relativePath)
-        await walk(entryPath, false)
-        continue
-      }
-
-      if (!entry.isFile()) {
-        continue
-      }
-
-      if (isControllerEntryFileName(entry.name)) {
-        controllerEntryPaths.add(relativePath)
-        continue
-      }
-
-      if (isRouteLocalFileName(entry.name)) {
-        routeLocalFilePaths.add(relativePath)
-      }
-    }
-  }
-
-  await walk(actionsDir, true)
-
-  return {
-    controllerEntryPaths,
-    routeDirectoryPaths,
-    routeLocalFilePaths,
-  }
-}
-
-function applyScanToSubtrees(
-  subtreePlans: OwnedSubtreePlan[],
-  scan: ControllerDirectoryScan,
-): OwnedSubtree[] {
-  let claimedRouteLocalPaths = claimFilesToDeepestSubtree(
-    [...scan.routeLocalFilePaths],
-    subtreePlans,
-  )
-  let claimedContentPaths = claimFilesToDeepestSubtree(getNestedContentPaths(scan), subtreePlans)
-
-  return subtreePlans.map((subtree) => {
-    let actualEntryPaths = findOwnerPaths(scan, subtree.entryCandidates)
-
-    return {
-      ...subtree,
-      actualEntryPath: actualEntryPaths[0] ?? null,
-      actualEntryPaths,
-      claimedFilePaths: claimedContentPaths.get(subtree.routeName) ?? [],
-      claimedRouteLocalFilePaths: claimedRouteLocalPaths.get(subtree.routeName) ?? [],
-    }
-  })
-}
-
-function getNestedContentPaths(scan: ControllerDirectoryScan): string[] {
-  let nestedControllerPaths = [...scan.controllerEntryPaths].filter((filePath) =>
-    isNestedControllerPath(filePath),
-  )
-
-  return [...new Set([...nestedControllerPaths, ...scan.routeLocalFilePaths])].sort()
-}
-
-function claimFilesToDeepestSubtree(
-  filePaths: string[],
-  subtreePlans: OwnedSubtreePlan[],
-): Map<string, string[]> {
-  let subtreesByDepth = [...subtreePlans].sort((left, right) => {
-    if (right.subtreePath.length !== left.subtreePath.length) {
-      return right.subtreePath.length - left.subtreePath.length
-    }
-
-    return left.routeName.localeCompare(right.routeName)
-  })
-  let claims = new Map<string, string[]>()
-
-  for (let filePath of filePaths.sort()) {
-    let matchingSubtree = subtreesByDepth.find((subtree) =>
-      isWithinDirectory(filePath, subtree.subtreePath),
-    )
-
-    if (matchingSubtree == null) {
-      continue
-    }
-
-    let claimedPaths = claims.get(matchingSubtree.routeName)
-    if (claimedPaths == null) {
-      claims.set(matchingSubtree.routeName, [filePath])
-      continue
-    }
-
-    claimedPaths.push(filePath)
-  }
-
-  return claims
-}
-
-function getOrphanControllerPaths(
-  subtreePlans: OwnedSubtreePlan[],
-  scan: ControllerDirectoryScan,
-): string[] {
-  let expectedControllerPaths = new Set(subtreePlans.flatMap((subtree) => subtree.entryCandidates))
-
-  return [...scan.controllerEntryPaths]
-    .filter((filePath) => !expectedControllerPaths.has(filePath))
-    .sort()
-}
-
-function getOrphanRouteDirectoryPaths(
-  routeDirectories: RouteDirectoryPlan[],
-  scan: ControllerDirectoryScan,
-): string[] {
-  let expectedRouteDirectories = new Set(
-    routeDirectories.map((routeDirectory) => routeDirectory.directoryPath),
-  )
-  let actualControllerDirectories = [...scan.controllerEntryPaths].map((controllerPath) =>
-    normalizeRelativePath(path.dirname(controllerPath)),
+async function inspectRouteDirectories(
+  appRoot: string,
+  plans: RouteDirectoryPlan[],
+): Promise<RouteDirectory[]> {
+  return Promise.all(
+    plans.map(async (plan) => ({
+      ...plan,
+      exists: await pathHasType(appRoot, plan.directoryPath, 'directory'),
+    })),
   )
-
-  return [...scan.routeDirectoryPaths]
-    .filter((directoryPath) => !expectedRouteDirectories.has(directoryPath))
-    .filter(
-      (directoryPath) =>
-        !actualControllerDirectories.some((controllerPath) =>
-          isDirectoryWithinDirectory(controllerPath, directoryPath),
-        ),
-    )
-    .sort()
 }
 
-function isRouteLocalFileName(fileName: string): boolean {
-  let baseName = getOwnerModuleBaseName(fileName)
-
-  return (
-    baseName != null &&
-    baseName !== 'controller' &&
-    !baseName.endsWith('.test') &&
-    !baseName.endsWith('.spec')
+async function inspectOwnedSubtrees(
+  appRoot: string,
+  plans: OwnedSubtreePlan[],
+): Promise<OwnedSubtree[]> {
+  return Promise.all(
+    plans.map(async (plan) => ({
+      ...plan,
+      actualEntryPath: await findControllerEntryPath(appRoot, plan.entryCandidates),
+    })),
   )
 }
 
-function findOwnerPaths(scan: ControllerDirectoryScan, candidatePaths: string[]): string[] {
-  let existingPaths: string[] = []
-
+async function findControllerEntryPath(
+  appRoot: string,
+  candidatePaths: string[],
+): Promise<string | null> {
   for (let candidatePath of candidatePaths) {
-    if (scan.controllerEntryPaths.has(candidatePath)) {
-      existingPaths.push(candidatePath)
+    if (await pathHasType(appRoot, candidatePath, 'file')) {
+      return candidatePath
     }
   }
 
-  return existingPaths
-}
-
-function isNestedControllerPath(filePath: string): boolean {
-  return (
-    filePath.startsWith(ACTIONS_PATH_PREFIX) &&
-    filePath.slice(ACTIONS_PATH_PREFIX.length).includes('/')
-  )
-}
-
-function isWithinDirectory(filePath: string, directoryPath: string): boolean {
-  return filePath.startsWith(`${directoryPath}/`)
+  return null
 }
 
-function isDirectoryWithinDirectory(directoryPath: string, parentDirectoryPath: string): boolean {
-  return (
-    directoryPath === parentDirectoryPath || isWithinDirectory(directoryPath, parentDirectoryPath)
-  )
-}
+async function pathHasType(
+  appRoot: string,
+  relativePath: string,
+  type: 'directory' | 'file',
+): Promise<boolean> {
+  try {
+    let stats = await fs.stat(path.join(appRoot, relativePath))
+    return type === 'directory' ? stats.isDirectory() : stats.isFile()
+  } catch (error) {
+    let nodeError = error as NodeJS.ErrnoException
+    if (nodeError.code === 'ENOENT' || nodeError.code === 'ENOTDIR') {
+      return false
+    }
 
-function normalizeRelativePath(filePath: string): string {
-  return filePath.split(path.sep).join('/')
+    throw error
+  }
 }

package/src/lib/database-command.ts

@@ -0,0 +1,31 @@
+import type { RemixDbAdapterConfig } from './remix-config.ts'
+
+export type DatabaseCommand = 'migrate' | 'reset' | 'seed' | 'status' | 'wipe'
+
+export interface DatabaseCommandInvocation {
+  command: DatabaseCommand
+  connectionEnv?: string
+  journalTable?: string
+  migrations?: string
+  seed?: string
+  to?: string
+}
+
+export interface DatabaseCommandPlan {
+  adapter: RemixDbAdapterConfig
+  command: DatabaseCommand
+  journalTable?: string
+  migrations?: string
+  seed?: string
+  to?: string
+}
+
+export function isDatabaseCommand(value: unknown): value is DatabaseCommand {
+  return (
+    value === 'migrate' ||
+    value === 'reset' ||
+    value === 'seed' ||
+    value === 'status' ||
+    value === 'wipe'
+  )
+}

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

@@ -2,69 +2,52 @@ import {
   ROOT_ROUTE_NAME,
   type ControllerOwnership,
   type OwnedSubtree,
+  type RouteDirectory,
 } from '../controller-ownership.ts'
-import type { DoctorFinding, DoctorFixPlan } from './types.ts'
+import type { DoctorFinding } from './types.ts'
+
+export function getControllerFindings(ownership: ControllerOwnership): DoctorFinding[] {
+  let missingRouteNames = new Set(
+    ownership.routeDirectories
+      .filter((directory) => !directory.exists)
+      .map((directory) => directory.routeName),
+  )
 
-export function getControllerFindings(
-  ownership: ControllerOwnership,
-  fixPlans: DoctorFixPlan[],
-): DoctorFinding[] {
   return [
-    ...getSubtreeFindings(ownership.subtrees, fixPlans),
-    ...ownership.orphanControllerPaths.map((actualPath) => ({
-      actualPath,
-      code: 'orphan-controller' as const,
-      message: `Action controller ${actualPath} does not match any route map.`,
-      severity: 'warn' 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-map key path.`,
+    ...getSubtreeFindings(ownership.subtrees, missingRouteNames),
+    ...getRouteDirectoryFindings(ownership.routeDirectories),
+  ]
+}
+
+function getRouteDirectoryFindings(directories: RouteDirectory[]): DoctorFinding[] {
+  return directories
+    .filter((directory) => !directory.exists)
+    .map((directory) => ({
+      code: 'missing-route-directory' as const,
+      expectedPath: directory.directoryPath,
+      message: `Route map "${directory.routeName}" is missing action directory ${directory.directoryPath}.`,
+      routeName: directory.routeName,
       severity: 'warn' as const,
       suite: 'actions' as const,
-    })),
-  ]
+    }))
 }
 
-function getSubtreeFindings(subtrees: OwnedSubtree[], fixPlans: DoctorFixPlan[]): DoctorFinding[] {
+function getSubtreeFindings(
+  subtrees: OwnedSubtree[],
+  missingRouteNames: Set<string>,
+): DoctorFinding[] {
   let findings: DoctorFinding[] = []
-  let fixableFindingKeys = new Set(
-    fixPlans.map((fixPlan) => `${fixPlan.code}:${fixPlan.routeName ?? ''}`),
-  )
 
   for (let subtree of subtrees) {
-    let routeMapName = formatRouteMapName(subtree.routeName)
-
-    if (subtree.actualEntryPaths.length > 1) {
-      findings.push({
-        actualPath: subtree.actualEntryPaths[0],
-        code: 'duplicate-owner-file',
-        expectedPath: subtree.entryDisplayPath,
-        message: `${routeMapName} has multiple action controller files: ${subtree.actualEntryPaths.join(', ')}. Keep only one controller owner file.`,
-        routeName: subtree.routeName,
-        severity: 'warn',
-        suite: 'actions',
-      })
+    if (missingRouteNames.has(subtree.routeName)) {
       continue
     }
 
     if (subtree.actualEntryPath == null) {
-      let code =
-        subtree.claimedFilePaths.length > 0
-          ? ('incomplete-controller' as const)
-          : ('missing-owner' as const)
-
       findings.push({
-        actualPath: subtree.claimedFilePaths.length > 0 ? subtree.subtreePath : undefined,
-        code,
+        code: 'missing-owner',
         expectedPath: subtree.entryDisplayPath,
-        fixable: fixableFindingKeys.has(`${code}:${subtree.routeName}`),
-        message:
-          subtree.claimedFilePaths.length > 0
-            ? `${routeMapName} has files under ${subtree.subtreePath}, but is missing action controller ${subtree.entryDisplayPath}.`
-            : `${routeMapName} is missing action controller ${subtree.entryDisplayPath}.`,
+        message: `${formatRouteMapName(subtree.routeName)} is missing action controller ${subtree.entryDisplayPath}.`,
         routeName: subtree.routeName,
         severity: 'warn',
         suite: 'actions',

package/src/lib/doctor/controllers.ts

@@ -1,10 +1,8 @@
 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'
+import { createDoctorSuite, type DoctorSuiteResult } from './types.ts'
 
 export interface ControllerDoctorResult {
-  fixPlans: DoctorFixPlan[]
   suite: DoctorSuiteResult
 }
 
@@ -13,11 +11,9 @@ export async function checkControllerConventions(
   tree: OwnershipRouteNode[],
 ): Promise<ControllerDoctorResult> {
   let ownership = await inspectControllerOwnership(appRoot, tree)
-  let fixPlans = await getControllerFixPlans(appRoot, tree, ownership)
-  let findings = getControllerFindings(ownership, fixPlans)
+  let findings = getControllerFindings(ownership)
 
   return {
-    fixPlans,
     suite: createDoctorSuite('actions', findings),
   }
 }