@remix-run/cli 0.3.4 → 0.4.0

package/dist/lib/remix-config.js

@@ -0,0 +1,411 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { findNodeAtLocation, getNodeValue, parseTree, printParseErrorCode, } from 'jsonc-parser';
+import { invalidRemixConfig, remixConfigNotFound } from './errors.js';
+const reporters = ['spec', 'files', 'tap', 'dot'];
+const testPools = ['forks', 'threads'];
+const testTypes = ['server', 'browser', 'e2e'];
+export async function loadRemixConfig(cwd, configPath) {
+    let filePath = path.resolve(cwd, configPath ?? 'remix.json');
+    let text;
+    try {
+        text = await fs.readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            if (configPath === undefined)
+                return {};
+            throw remixConfigNotFound(filePath);
+        }
+        throw error;
+    }
+    // Editors saving "UTF-8 with BOM" prefix the file with U+FEFF, which
+    // jsonc-parser reports as an InvalidSymbol error.
+    if (text.charCodeAt(0) === 0xfeff)
+        text = text.slice(1);
+    let parseErrors = [];
+    let root = parseTree(text, parseErrors, {
+        allowTrailingComma: true,
+        disallowComments: false,
+    });
+    let value = root === undefined ? undefined : getNodeValue(root);
+    let source = { filePath, root, text };
+    // An empty or comments-only file has no JSON value at all; treat it like a
+    // missing file rather than a malformed one.
+    if (root === undefined &&
+        parseErrors.every((error) => printParseErrorCode(error.error) === 'ValueExpected')) {
+        return {};
+    }
+    if (parseErrors.length > 0) {
+        let error = parseErrors[0];
+        throwConfigError(source, [], printParseErrorCode(error.error), error.offset);
+    }
+    return parseConfig(value, source, path.dirname(filePath), cwd);
+}
+function parseConfig(value, source, configDir, cwd) {
+    let object = requireObject(value, source, []);
+    requireKnownProperties(object, ['$schema', 'db', 'doctor', 'test'], source, []);
+    if (object.$schema !== undefined) {
+        requireString(object.$schema, source, ['$schema']);
+    }
+    let config = {};
+    if (object.db !== undefined) {
+        config.db = parseDbConfig(object.db, source, configDir);
+    }
+    if (object.doctor !== undefined) {
+        config.doctor = parseDoctorConfig(object.doctor, source);
+    }
+    if (object.test !== undefined) {
+        config.test = parseTestConfig(object.test, source, configDir, cwd);
+    }
+    return config;
+}
+function parseDbConfig(value, source, configDir) {
+    let objectPath = ['db'];
+    let object = requireObject(value, source, objectPath);
+    requireKnownProperties(object, ['adapter', 'migrations', 'seed'], source, objectPath);
+    if (object.adapter === undefined) {
+        throwConfigError(source, [...objectPath, 'adapter'], 'Expected an adapter configuration');
+    }
+    let config = {
+        adapter: parseDbAdapterConfig(object.adapter, source),
+    };
+    if (object.migrations !== undefined) {
+        let migrationsPath = [...objectPath, 'migrations'];
+        let migrations = requireObject(object.migrations, source, migrationsPath);
+        requireKnownProperties(migrations, ['directory', 'journalTable'], source, migrationsPath);
+        let directory = requireString(migrations.directory, source, [...migrationsPath, 'directory']);
+        let journalTable = optionalString(migrations.journalTable, source, [
+            ...migrationsPath,
+            'journalTable',
+        ]);
+        config.migrations = {
+            directory: path.resolve(configDir, directory),
+            journalTable,
+        };
+    }
+    if (object.seed !== undefined) {
+        let seed = requireString(object.seed, source, [...objectPath, 'seed']);
+        config.seed = path.resolve(configDir, seed);
+    }
+    return config;
+}
+function parseDbAdapterConfig(value, source) {
+    let objectPath = ['db', 'adapter'];
+    let object = requireObject(value, source, objectPath);
+    let type = requireEnum(object.type, ['sqlite', 'postgres', 'mysql'], source, [
+        ...objectPath,
+        'type',
+    ]);
+    if (type === 'sqlite') {
+        requireKnownProperties(object, ['busyTimeout', 'filename', 'foreignKeys', 'type'], source, objectPath);
+        let busyTimeout = optionalNumber(object.busyTimeout, source, [...objectPath, 'busyTimeout']);
+        if (busyTimeout !== undefined && busyTimeout < 0) {
+            throwConfigError(source, [...objectPath, 'busyTimeout'], 'Expected a non-negative number');
+        }
+        return {
+            type,
+            filename: parseDbString(object.filename, source, [...objectPath, 'filename']),
+            foreignKeys: optionalBoolean(object.foreignKeys, source, [...objectPath, 'foreignKeys']),
+            busyTimeout,
+        };
+    }
+    if (type === 'postgres') {
+        requireKnownProperties(object, ['connectionString', 'maintenanceDatabase', 'template', 'type'], source, objectPath);
+        return {
+            type,
+            connectionString: parseDbString(object.connectionString, source, [
+                ...objectPath,
+                'connectionString',
+            ]),
+            maintenanceDatabase: optionalString(object.maintenanceDatabase, source, [
+                ...objectPath,
+                'maintenanceDatabase',
+            ]),
+            template: optionalString(object.template, source, [...objectPath, 'template']),
+        };
+    }
+    requireKnownProperties(object, ['characterSet', 'collation', 'type', 'uri'], source, objectPath);
+    return {
+        type,
+        uri: parseDbString(object.uri, source, [...objectPath, 'uri']),
+        characterSet: optionalString(object.characterSet, source, [...objectPath, 'characterSet']),
+        collation: optionalString(object.collation, source, [...objectPath, 'collation']),
+    };
+}
+function parseDbString(value, source, propertyPath) {
+    if (typeof value === 'string')
+        return value;
+    let object = requireObject(value, source, propertyPath);
+    requireKnownProperties(object, ['default', 'env'], source, propertyPath);
+    let env = requireString(object.env, source, [...propertyPath, 'env']);
+    let defaultValue = optionalString(object.default, source, [...propertyPath, 'default']);
+    return defaultValue === undefined ? { env } : { env, default: defaultValue };
+}
+function parseDoctorConfig(value, source) {
+    let objectPath = ['doctor'];
+    let object = requireObject(value, source, objectPath);
+    requireKnownProperties(object, ['strict'], source, objectPath);
+    let config = {};
+    let strict = optionalBoolean(object.strict, source, [...objectPath, 'strict']);
+    if (strict !== undefined)
+        config.strict = strict;
+    return config;
+}
+function parseTestConfig(value, source, configDir, cwd) {
+    let objectPath = ['test'];
+    let object = requireObject(value, source, objectPath);
+    requireKnownProperties(object, [
+        'browserFiles',
+        'concurrency',
+        'coverage',
+        'e2eFiles',
+        'exclude',
+        'files',
+        'only',
+        'playwright',
+        'pool',
+        'quiet',
+        'reporter',
+        'setup',
+        'type',
+        'watch',
+    ], source, objectPath);
+    let config = {};
+    let browserFiles = optionalStringArray(object.browserFiles, source, [
+        ...objectPath,
+        'browserFiles',
+    ]);
+    let e2eFiles = optionalStringArray(object.e2eFiles, source, [...objectPath, 'e2eFiles']);
+    let exclude = optionalStringArray(object.exclude, source, [...objectPath, 'exclude']);
+    let files = optionalStringArray(object.files, source, [...objectPath, 'files']);
+    let only = optionalStringArray(object.only, source, [...objectPath, 'only']);
+    let concurrency = optionalNumber(object.concurrency, source, [...objectPath, 'concurrency']);
+    let setup = optionalString(object.setup, source, [...objectPath, 'setup']);
+    if (browserFiles !== undefined)
+        config.browserFiles = resolveGlobs(browserFiles, configDir, cwd);
+    if (e2eFiles !== undefined)
+        config.e2eFiles = resolveGlobs(e2eFiles, configDir, cwd);
+    if (exclude !== undefined)
+        config.exclude = resolveGlobs(exclude, configDir, cwd);
+    if (files !== undefined)
+        config.files = resolveGlobs(files, configDir, cwd);
+    if (only !== undefined) {
+        for (let [index, pattern] of only.entries()) {
+            validateOnlyPattern(pattern, source, [...objectPath, 'only', index]);
+        }
+        config.only = only;
+    }
+    if (concurrency !== undefined) {
+        if (!Number.isInteger(concurrency) || concurrency < 1) {
+            throwConfigError(source, [...objectPath, 'concurrency'], 'Expected a positive integer');
+        }
+        config.concurrency = concurrency;
+    }
+    let pool = optionalEnum(object.pool, testPools, source, [...objectPath, 'pool']);
+    if (pool !== undefined)
+        config.pool = pool;
+    let quiet = optionalBoolean(object.quiet, source, [...objectPath, 'quiet']);
+    if (quiet !== undefined)
+        config.quiet = quiet;
+    let reporter = optionalEnum(object.reporter, reporters, source, [...objectPath, 'reporter']);
+    if (reporter !== undefined)
+        config.reporter = reporter;
+    if (setup !== undefined)
+        config.setup = path.resolve(configDir, setup);
+    let type = optionalEnumArray(object.type, testTypes, source, [...objectPath, 'type']);
+    if (type !== undefined)
+        config.type = type;
+    let watch = optionalBoolean(object.watch, source, [...objectPath, 'watch']);
+    if (watch !== undefined)
+        config.watch = watch;
+    if (object.coverage !== undefined) {
+        config.coverage = parseCoverageConfig(object.coverage, source, configDir, cwd);
+    }
+    if (object.playwright !== undefined) {
+        config.playwright = parsePlaywrightConfig(object.playwright, source, configDir);
+    }
+    return config;
+}
+function parseCoverageConfig(value, source, configDir, cwd) {
+    let objectPath = ['test', 'coverage'];
+    let object = requireObject(value, source, objectPath);
+    requireKnownProperties(object, ['branches', 'dir', 'enabled', 'exclude', 'functions', 'include', 'lines', 'statements'], source, objectPath);
+    let config = {};
+    let branches = optionalNumber(object.branches, source, [...objectPath, 'branches']);
+    let dir = optionalString(object.dir, source, [...objectPath, 'dir']);
+    let enabled = optionalBoolean(object.enabled, source, [...objectPath, 'enabled']);
+    let exclude = optionalStringArray(object.exclude, source, [...objectPath, 'exclude']);
+    let functions = optionalNumber(object.functions, source, [...objectPath, 'functions']);
+    let include = optionalStringArray(object.include, source, [...objectPath, 'include']);
+    let lines = optionalNumber(object.lines, source, [...objectPath, 'lines']);
+    let statements = optionalNumber(object.statements, source, [...objectPath, 'statements']);
+    if (branches !== undefined)
+        config.branches = branches;
+    if (dir !== undefined)
+        config.dir = path.resolve(configDir, dir);
+    if (enabled !== undefined)
+        config.enabled = enabled;
+    if (exclude !== undefined)
+        config.exclude = resolveGlobs(exclude, configDir, cwd);
+    if (functions !== undefined)
+        config.functions = functions;
+    if (include !== undefined)
+        config.include = resolveGlobs(include, configDir, cwd);
+    if (lines !== undefined)
+        config.lines = lines;
+    if (statements !== undefined)
+        config.statements = statements;
+    return config;
+}
+function parsePlaywrightConfig(value, source, configDir) {
+    let objectPath = ['test', 'playwright'];
+    let object = requireObject(value, source, objectPath);
+    requireKnownProperties(object, ['configFile', 'echo', 'open', 'projects'], source, objectPath);
+    let config = {};
+    let configFile = optionalString(object.configFile, source, [...objectPath, 'configFile']);
+    let echo = optionalBoolean(object.echo, source, [...objectPath, 'echo']);
+    let open = optionalBoolean(object.open, source, [...objectPath, 'open']);
+    let projects = optionalStringArray(object.projects, source, [...objectPath, 'projects']);
+    if (configFile !== undefined)
+        config.configFile = path.resolve(configDir, configFile);
+    if (echo !== undefined)
+        config.echo = echo;
+    if (open !== undefined)
+        config.open = open;
+    if (projects !== undefined)
+        config.projects = projects;
+    return config;
+}
+function requireObject(value, source, propertyPath) {
+    if (!isRecord(value)) {
+        throwConfigError(source, propertyPath, 'Expected an object');
+    }
+    return value;
+}
+function requireKnownProperties(object, knownProperties, source, propertyPath) {
+    for (let property of Object.keys(object)) {
+        if (!knownProperties.includes(property)) {
+            throwConfigError(source, [...propertyPath, property], `Unknown property "${property}"`);
+        }
+    }
+}
+function optionalBoolean(value, source, propertyPath) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'boolean')
+        throwConfigError(source, propertyPath, 'Expected a boolean');
+    return value;
+}
+function optionalNumber(value, source, propertyPath) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throwConfigError(source, propertyPath, 'Expected a number');
+    }
+    return value;
+}
+function optionalString(value, source, propertyPath) {
+    if (value === undefined)
+        return undefined;
+    return requireString(value, source, propertyPath);
+}
+function requireString(value, source, propertyPath) {
+    if (typeof value !== 'string')
+        throwConfigError(source, propertyPath, 'Expected a string');
+    return value;
+}
+function optionalStringArray(value, source, propertyPath) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        throwConfigError(source, propertyPath, 'Expected an array of strings');
+    return value.map((item, index) => requireString(item, source, [...propertyPath, index]));
+}
+function optionalEnum(input, values, source, propertyPath) {
+    if (input === undefined)
+        return undefined;
+    return requireEnum(input, values, source, propertyPath);
+}
+function optionalEnumArray(input, values, source, propertyPath) {
+    if (input === undefined)
+        return undefined;
+    if (!Array.isArray(input))
+        throwConfigError(source, propertyPath, 'Expected an array');
+    return input.map((item, index) => requireEnum(item, values, source, [...propertyPath, index]));
+}
+function requireEnum(input, values, source, propertyPath) {
+    let string = requireString(input, source, propertyPath);
+    let matched = values.find((value) => value === string);
+    if (matched === undefined) {
+        throwConfigError(source, propertyPath, `Expected one of: ${values.join(', ')}`);
+    }
+    return matched;
+}
+function resolveGlobs(values, configDir, cwd) {
+    return values.map((value) => toPosix(path.relative(cwd, path.resolve(configDir, value))));
+}
+function toPosix(value) {
+    return path.sep === '/' ? value : value.replaceAll(path.sep, '/');
+}
+function validateOnlyPattern(pattern, source, propertyPath) {
+    let regex = parseRegexLiteral(pattern) ?? { flags: 'i', source: pattern };
+    try {
+        new RegExp(regex.source, regex.flags);
+    }
+    catch (error) {
+        let reason = error instanceof Error ? error.message : String(error);
+        throwConfigError(source, propertyPath, `Expected a valid JavaScript regular expression: ${reason}`);
+    }
+}
+function parseRegexLiteral(pattern) {
+    if (!pattern.startsWith('/') || pattern.length < 2)
+        return undefined;
+    // The closing delimiter is the last unescaped slash; escape state must be
+    // tracked left-to-right since it depends on the preceding backslashes.
+    let closingIndex = -1;
+    let escaped = false;
+    for (let index = 1; index < pattern.length; index++) {
+        if (escaped) {
+            escaped = false;
+        }
+        else if (pattern[index] === '\\') {
+            escaped = true;
+        }
+        else if (pattern[index] === '/') {
+            closingIndex = index;
+        }
+    }
+    if (closingIndex === -1)
+        return undefined;
+    return {
+        flags: pattern.slice(closingIndex + 1),
+        source: pattern.slice(1, closingIndex),
+    };
+}
+function throwConfigError(source, propertyPath, details, offset) {
+    let node = source.root == null ? undefined : findNodeAtLocation(source.root, propertyPath);
+    let location = getLineAndColumn(source.text, offset ?? node?.offset ?? 0);
+    let label = propertyPath.length === 0 ? '' : ` at ${propertyPath.join('.')}`;
+    throw invalidRemixConfig(source.filePath, `${details}${label}`, location.line, location.column);
+}
+function getLineAndColumn(text, offset) {
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < offset; index++) {
+        if (text[index] === '\n') {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { column, line };
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/lib/reporter.js

@@ -1,5 +1,5 @@
 import * as process from 'node:process';
-import { bold, canUseAnsi, clearCurrentLine, lightGray, lightGreen, lightRed, lightYellow, remixWordmark, } from "./terminal.js";
+import { bold, canUseAnsi, clearCurrentLine, lightGray, lightGreen, lightRed, lightYellow, remixWordmark, } from './terminal.js';
 const BULLET = '•';
 const DOT_FRAMES = ['.', '..', '...'];
 const DEFAULT_INDENT = '  ';

package/dist/lib/route-map.js

@@ -1,10 +1,10 @@
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as process from 'node:process';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { ROOT_ROUTE_NAME, inspectControllerOwnership, } from "./controller-ownership.js";
-import { routeMapLoaderFailed, routeMapLoaderInvalidJson, routeMapLoaderSignal, routeOwnerPlanUnresolved, routesFileNotFound, } from "./errors.js";
+import { findAppRoot } from './app-root.js';
+import { ROOT_ROUTE_NAME, inspectControllerOwnership, } from './controller-ownership.js';
+import { routeMapLoaderFailed, routeMapLoaderInvalidJson, routeMapLoaderSignal, routeOwnerPlanUnresolved, routesFileNotFound, } from './errors.js';
 export async function loadRouteMap(cwd = process.cwd()) {
     let manifest = await loadRouteManifest(cwd);
     let ownership = await inspectControllerOwnership(manifest.appRoot, manifest.tree);
@@ -73,15 +73,15 @@ async function loadRawRouteMap(appRoot, routesFile) {
 function decorateRouteTree(rawTree, ownership) {
     let subtreesByRouteName = new Map(ownership.subtrees.map((subtree) => [subtree.routeName, subtree]));
     let directoriesByRouteName = new Map(ownership.routeDirectories.map((directory) => [directory.routeName, directory]));
-    return decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, directoriesByRouteName, ownership.scan.routeDirectoryPaths);
+    return decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, directoriesByRouteName);
 }
-function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories, parentSegments = []) {
+function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, directoriesByRouteName, parentSegments = []) {
     return rawTree.map((rawNode) => {
-        let owner = getRouteOwner(rawNode, parentSegments, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories);
+        let owner = getRouteOwner(rawNode, parentSegments, subtreesByRouteName, directoriesByRouteName);
         let nextParentSegments = rawNode.kind === 'group' ? [...parentSegments, rawNode.key] : parentSegments;
         return {
             children: rawNode.kind === 'group'
-                ? decorateRouteTreeWithLookup(rawNode.children, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories, nextParentSegments)
+                ? decorateRouteTreeWithLookup(rawNode.children, subtreesByRouteName, directoriesByRouteName, nextParentSegments)
                 : [],
             key: rawNode.key,
             kind: rawNode.kind,
@@ -92,7 +92,7 @@ function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, directoriesBy
         };
     });
 }
-function getRouteOwner(rawNode, parentSegments, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories) {
+function getRouteOwner(rawNode, parentSegments, subtreesByRouteName, directoriesByRouteName) {
     let ownerRouteName = rawNode.kind === 'group'
         ? rawNode.name
         : parentSegments.length === 0
@@ -112,7 +112,7 @@ function getRouteOwner(rawNode, parentSegments, subtreesByRouteName, directories
             throw routeOwnerPlanUnresolved(rawNode.name);
         }
         return {
-            exists: actualRouteDirectories.has(directory.directoryPath),
+            exists: directory.exists,
             kind: 'directory',
             path: directory.directoryPath,
         };
@@ -165,31 +165,11 @@ function assertRawRouteTreeNode(value) {
     };
 }
 async function findRemixAppRoot(startDir) {
-    let currentDir = path.resolve(startDir);
-    while (true) {
-        if (await pathExists(path.join(currentDir, 'app', 'routes.ts'))) {
-            return currentDir;
-        }
-        let parentDir = path.dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    throw routesFileNotFound(startDir);
-}
-async function pathExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch (error) {
-        let nodeError = error;
-        if (nodeError.code === 'ENOENT') {
-            return false;
-        }
-        throw error;
+    let appRoot = await findAppRoot(startDir, 'app/routes.ts');
+    if (appRoot == null) {
+        throw routesFileNotFound(startDir);
     }
+    return appRoot;
 }
 function getRouteMapWorkerPath() {
     let currentFilePath = fileURLToPath(import.meta.url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix-run/cli",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Command-line interface for Remix",
   "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
@@ -14,6 +14,7 @@
     "LICENSE",
     "README.md",
     "dist",
+    "schema",
     "src",
     "template",
     "!src/**/*.test.ts"
@@ -30,14 +31,19 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
+    "jsonc-parser": "^3.3.1",
     "semver": "^7.7.4",
-    "@remix-run/test": "^0.5.0",
-    "@remix-run/terminal": "^0.1.1"
+    "@remix-run/data-table": "^0.4.0",
+    "@remix-run/data-table-mysql": "^0.5.0",
+    "@remix-run/data-table-sqlite": "^0.6.0",
+    "@remix-run/terminal": "^0.1.1",
+    "@remix-run/data-table-postgres": "^0.5.0",
+    "@remix-run/test": "^0.6.0"
   },
   "devDependencies": {
     "@types/node": "^24.6.0",
     "@types/semver": "^7.5.8",
-    "@typescript/native-preview": "7.0.0-dev.20251125.1",
+    "typescript": "^7.0.2",
     "@remix-run/assert": "^0.3.0"
   },
   "keywords": [
@@ -48,9 +54,9 @@
     "command-line"
   ],
   "scripts": {
-    "build": "tsgo -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
     "clean": "git clean -fdX",
-    "test": "remix-test --concurrency 1",
-    "typecheck": "tsgo --noEmit"
+    "test": "remix test --concurrency 1",
+    "typecheck": "tsc --noEmit"
   }
 }