@remix-run/cli 0.3.4 → 0.4.0

package/schema/remix.json

@@ -0,0 +1,242 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://remix.run/schemas/remix.json",
+  "title": "Remix CLI configuration",
+  "description": "Configuration for the Remix command-line interface.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "JSON Schema used by editors to validate this file."
+    },
+    "db": {
+      "$ref": "#/$defs/db"
+    },
+    "doctor": {
+      "$ref": "#/$defs/doctor"
+    },
+    "test": {
+      "$ref": "#/$defs/test"
+    }
+  },
+  "$defs": {
+    "db": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["adapter"],
+      "properties": {
+        "adapter": {
+          "oneOf": [
+            { "$ref": "#/$defs/dbSqliteAdapter" },
+            { "$ref": "#/$defs/dbPostgresAdapter" },
+            { "$ref": "#/$defs/dbMysqlAdapter" }
+          ]
+        },
+        "migrations": {
+          "$ref": "#/$defs/dbMigrations"
+        },
+        "seed": {
+          "type": "string",
+          "description": "Path to a SQL seed file."
+        }
+      }
+    },
+    "dbString": {
+      "oneOf": [
+        { "type": "string" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["env"],
+          "properties": {
+            "env": { "type": "string" },
+            "default": { "type": "string" }
+          }
+        }
+      ]
+    },
+    "dbSqliteAdapter": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["type", "filename"],
+      "properties": {
+        "type": { "const": "sqlite" },
+        "filename": { "$ref": "#/$defs/dbString" },
+        "foreignKeys": { "type": "boolean" },
+        "busyTimeout": { "type": "number", "minimum": 0 }
+      }
+    },
+    "dbPostgresAdapter": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["type", "connectionString"],
+      "properties": {
+        "type": { "const": "postgres" },
+        "connectionString": { "$ref": "#/$defs/dbString" },
+        "maintenanceDatabase": { "type": "string" },
+        "template": { "type": "string" }
+      }
+    },
+    "dbMysqlAdapter": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["type", "uri"],
+      "properties": {
+        "type": { "const": "mysql" },
+        "uri": { "$ref": "#/$defs/dbString" },
+        "characterSet": { "type": "string" },
+        "collation": { "type": "string" }
+      }
+    },
+    "dbMigrations": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["directory"],
+      "properties": {
+        "directory": { "type": "string" },
+        "journalTable": { "type": "string" }
+      }
+    },
+    "doctor": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "strict": {
+          "type": "boolean",
+          "description": "Whether doctor exits with status 1 when warning-level findings are present."
+        }
+      }
+    },
+    "stringArray": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "test": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "browserFiles": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Glob patterns for browser test files."
+        },
+        "concurrency": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Maximum number of concurrent test workers."
+        },
+        "coverage": {
+          "$ref": "#/$defs/coverage"
+        },
+        "e2eFiles": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Glob patterns for end-to-end test files."
+        },
+        "exclude": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Glob patterns excluded from test discovery."
+        },
+        "files": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Glob patterns for all test files."
+        },
+        "only": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Regular expression patterns used to focus tests by full name."
+        },
+        "playwright": {
+          "$ref": "#/$defs/playwright"
+        },
+        "pool": {
+          "enum": ["forks", "threads"],
+          "description": "Worker pool used for server and end-to-end tests."
+        },
+        "quiet": {
+          "type": "boolean",
+          "description": "Whether skipped tests are omitted from reporter output."
+        },
+        "reporter": {
+          "enum": ["spec", "files", "tap", "dot"],
+          "description": "Reporter used for test output."
+        },
+        "setup": {
+          "type": "string",
+          "description": "Path to a module exporting globalSetup and/or globalTeardown."
+        },
+        "type": {
+          "type": "array",
+          "items": {
+            "enum": ["server", "browser", "e2e"]
+          },
+          "description": "Test types to run."
+        },
+        "watch": {
+          "type": "boolean",
+          "description": "Whether tests rerun when files change."
+        }
+      }
+    },
+    "coverage": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "branches": {
+          "type": "number",
+          "description": "Minimum branch coverage percentage."
+        },
+        "dir": {
+          "type": "string",
+          "description": "Directory where coverage reports are written."
+        },
+        "enabled": {
+          "type": "boolean",
+          "description": "Whether coverage is collected."
+        },
+        "exclude": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Glob patterns excluded from coverage."
+        },
+        "functions": {
+          "type": "number",
+          "description": "Minimum function coverage percentage."
+        },
+        "include": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Glob patterns included in coverage."
+        },
+        "lines": {
+          "type": "number",
+          "description": "Minimum line coverage percentage."
+        },
+        "statements": {
+          "type": "number",
+          "description": "Minimum statement coverage percentage."
+        }
+      }
+    },
+    "playwright": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "configFile": {
+          "type": "string",
+          "description": "Path to a Playwright configuration file."
+        },
+        "echo": {
+          "type": "boolean",
+          "description": "Whether browser console output is echoed to stdout."
+        },
+        "open": {
+          "type": "boolean",
+          "description": "Whether the browser remains open after tests finish."
+        },
+        "projects": {
+          "$ref": "#/$defs/stringArray",
+          "description": "Playwright project names to run."
+        }
+      }
+    }
+  }
+}

package/src/lib/app-root.ts

@@ -0,0 +1,46 @@
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+
+/**
+ * Walks up from `startDir` looking for the closest directory that contains
+ * `relativeFilePath`.
+ *
+ * @param startDir Directory the walk starts from.
+ * @param relativeFilePath Slash-separated app file path, for example `app/routes.ts`.
+ * @returns The closest ancestor directory that contains the file, or `null`
+ *          when no ancestor contains it.
+ */
+export async function findAppRoot(
+  startDir: string,
+  relativeFilePath: string,
+): Promise<string | null> {
+  let relativeSegments = relativeFilePath.split('/')
+  let currentDir = path.resolve(startDir)
+
+  while (true) {
+    if (await pathExists(path.join(currentDir, ...relativeSegments))) {
+      return currentDir
+    }
+
+    let parentDir = path.dirname(currentDir)
+    if (parentDir === currentDir) {
+      return null
+    }
+
+    currentDir = parentDir
+  }
+}
+
+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/cli-context.ts

@@ -2,14 +2,20 @@ import * as path from 'node:path'
 import * as process from 'node:process'
 
 import { resolveDefaultRemixVersion } from './remix-version.ts'
+import { loadRemixConfig, type RemixConfig } from './remix-config.ts'
 
 interface ResolveCliContextOptions {
+  configPath?: string
   cwd?: string
   remixVersion?: string
 }
 
 export interface CliContext {
+  /** Explicit Remix configuration path selected by the caller. */
+  configPath?: string
   cwd: string
+  /** Loads and validates the Remix config file, memoizing the result. */
+  loadConfig(): Promise<RemixConfig>
   remixVersion?: string
 }
 
@@ -19,8 +25,19 @@ export async function resolveCliContext(
   let cwd = resolveCwd(options.cwd)
   let remixVersion = normalizeRemixVersion(options.remixVersion)
 
+  let configPromise: Promise<RemixConfig> | undefined
+  let loadConfig = () => (configPromise ??= loadRemixConfig(cwd, options.configPath))
+
+  // Validate an explicitly selected config file up front so every command
+  // fails fast on a bad --config path. The default remix.json is loaded
+  // lazily by the commands that read it, so an invalid file doesn't break
+  // unrelated commands like help, version, or shell completion.
+  if (options.configPath !== undefined) await loadConfig()
+
   return {
+    configPath: options.configPath,
     cwd,
+    loadConfig,
     remixVersion: remixVersion ?? (await resolveDefaultRemixVersion(cwd)),
   }
 }

package/src/lib/cli.ts

@@ -2,7 +2,7 @@ import * as process from 'node:process'
 
 import { getCliHelpText, runHelpCommand } from './commands/help.ts'
 import { resolveCliContext, type CliContext } from './cli-context.ts'
-import { renderCliError, unknownCommand } from './errors.ts'
+import { missingOptionValue, renderCliError, toCliError, unknownCommand } from './errors.ts'
 import { configureColors, restoreTerminalFormatting } from './terminal.ts'
 
 /**
@@ -23,8 +23,9 @@ export interface RunRemixOptions {
 
 /**
  * Entry point for the `remix` CLI. Parses `argv`, dispatches to the matching
- * subcommand (`new`, `doctor`, `routes`, `test`, `version`, `completion`,
- * `help`), and resolves with the exit code the process should use.
+ * subcommand (`new`, `db`, `doctor`, `routes`, `test`, `version`,
+ * `completion`, `help`), and resolves with the exit code the process should
+ * use.
  *
  * @param argv Argument vector to parse, excluding the node and script paths
  *             (default `process.argv.slice(2)`).
@@ -43,14 +44,13 @@ export async function runRemix(
   argv: string[] = process.argv.slice(2),
   options: RunRemixOptions = {},
 ): Promise<number> {
-  let context = await resolveCliContext(options)
-
   try {
     argv = stripLeadingSeparators(argv)
 
     let globalOptions = extractGlobalOptions(argv)
     argv = stripLeadingSeparators(globalOptions.argv)
     configureColors({ disabled: globalOptions.noColor })
+    let context = await resolveCliContext({ ...options, configPath: globalOptions.configPath })
 
     if (argv.length === 0) {
       process.stdout.write(getCliHelpText())
@@ -65,6 +65,11 @@ export async function runRemix(
     }
 
     return await runCommand(command, rest, context)
+  } catch (error) {
+    process.stderr.write(
+      renderCliError(toCliError(error), { helpText: getCliHelpText(process.stderr) }),
+    )
+    return 1
   } finally {
     restoreTerminalFormatting()
   }
@@ -103,6 +108,11 @@ async function runCommand(command: string, argv: string[], context: CliContext):
     return runDoctorCommand(argv, context)
   }
 
+  if (command === 'db') {
+    let { runDbCommand } = await import('./commands/db.ts')
+    return runDbCommand(argv, context)
+  }
+
   if (command === 'routes') {
     let { runRoutesCommand } = await import('./commands/routes.ts')
     return runRoutesCommand(argv, context)
@@ -124,8 +134,13 @@ async function runCommand(command: string, argv: string[], context: CliContext):
   return 1
 }
 
-function extractGlobalOptions(argv: string[]): { argv: string[]; noColor: boolean } {
+function extractGlobalOptions(argv: string[]): {
+  argv: string[]
+  configPath?: string
+  noColor: boolean
+} {
   let filteredArgv: string[] = []
+  let configPath: string | undefined
   let noColor = false
 
   for (let index = 0; index < argv.length; index++) {
@@ -141,11 +156,31 @@ function extractGlobalOptions(argv: string[]): { argv: string[]; noColor: boolea
       continue
     }
 
+    if (arg === '--config') {
+      let value = argv[index + 1]
+      if (value == null || value.length === 0 || value.startsWith('-')) {
+        throw missingOptionValue('--config')
+      }
+      configPath = value
+      index++
+      continue
+    }
+
+    if (arg.startsWith('--config=')) {
+      let value = arg.slice('--config='.length)
+      if (value.length === 0) {
+        throw missingOptionValue('--config')
+      }
+      configPath = value
+      continue
+    }
+
     filteredArgv.push(arg)
   }
 
   return {
     argv: filteredArgv,
+    configPath,
     noColor,
   }
 }