@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/doctor/environment.js

@@ -0,0 +1,226 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { createRequire } from 'node:module';
+import * as semver from 'semver';
+import { MINIMUM_SUPPORTED_NODE_VERSION } from "../bootstrap-project.js";
+import { createDoctorSuite, } from "./types.js";
+export async function checkEnvironment(cwd = process.cwd()) {
+    let projectRoot = await findNearestPackageRoot(cwd);
+    if (projectRoot == null) {
+        return {
+            suite: createDoctorSuite('environment', [
+                {
+                    code: 'project-root-not-found',
+                    message: 'Could not find package.json. Run this command inside a Remix project.',
+                    severity: 'warn',
+                    suite: 'environment',
+                },
+            ]),
+        };
+    }
+    let packageJsonPath = path.join(projectRoot, 'package.json');
+    let packageJson = await readPackageJson(packageJsonPath);
+    if ('suite' in packageJson) {
+        return {
+            projectRoot,
+            suite: packageJson.suite,
+        };
+    }
+    let findings = [];
+    let nodeRequirement = packageJson.engines?.node;
+    if (nodeRequirement == null) {
+        findings.push({
+            actualPath: 'package.json',
+            code: 'node-engine-missing',
+            fixable: true,
+            message: 'package.json does not declare engines.node. Add one to document the supported Node.js version.',
+            severity: 'advice',
+            suite: 'environment',
+        });
+    }
+    else {
+        let nodeSupport = satisfiesNodeRange(process.version, nodeRequirement);
+        if (nodeSupport == null) {
+            findings.push({
+                actualPath: 'package.json',
+                code: 'node-engine-unparseable',
+                fixable: true,
+                message: `Could not evaluate engines.node "${nodeRequirement}" automatically.`,
+                severity: 'advice',
+                suite: 'environment',
+            });
+        }
+        else if (!nodeSupport) {
+            findings.push({
+                actualPath: 'package.json',
+                code: 'node-version-unsupported',
+                fixable: true,
+                message: `Project requires Node.js ${nodeRequirement}, but the current runtime is ${process.version}.`,
+                severity: 'warn',
+                suite: 'environment',
+            });
+        }
+    }
+    if (!hasRemixDependency(packageJson)) {
+        findings.push({
+            actualPath: 'package.json',
+            code: 'remix-dependency-missing',
+            fixable: true,
+            message: 'package.json does not declare a remix dependency.',
+            severity: 'warn',
+            suite: 'environment',
+        });
+    }
+    if (!(await canResolveRemix(projectRoot))) {
+        findings.push({
+            actualPath: 'package.json',
+            code: 'remix-install-missing',
+            message: 'Could not resolve remix from this project. Install dependencies and try again.',
+            severity: 'warn',
+            suite: 'environment',
+        });
+    }
+    return {
+        packageJson,
+        packageJsonPath,
+        projectRoot,
+        suite: createDoctorSuite('environment', findings),
+    };
+}
+export function getEnvironmentFixPlans(result, remixVersion) {
+    if (result.projectRoot == null || result.packageJson == null || result.packageJsonPath == null) {
+        return [];
+    }
+    let packageJson = structuredClone(result.packageJson);
+    let code = getEnvironmentFixCode(result.suite.findings);
+    let changed = false;
+    if (result.suite.findings.some((finding) => finding.code === 'node-engine-missing' ||
+        finding.code === 'node-engine-unparseable' ||
+        finding.code === 'node-version-unsupported')) {
+        packageJson.engines = {
+            ...packageJson.engines,
+            node: `>=${MINIMUM_SUPPORTED_NODE_VERSION}`,
+        };
+        changed = true;
+    }
+    if (result.suite.findings.some((finding) => finding.code === 'remix-dependency-missing')) {
+        packageJson.dependencies = {
+            ...packageJson.dependencies,
+            remix: remixVersion ?? 'latest',
+        };
+        changed = true;
+    }
+    if (!changed || code == null) {
+        return [];
+    }
+    return [
+        {
+            code,
+            contents: `${JSON.stringify(packageJson, null, 2)}\n`,
+            kind: 'update-file',
+            path: 'package.json',
+            suite: 'environment',
+        },
+    ];
+}
+async function findNearestPackageRoot(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        if (await pathExists(path.join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        let parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+async function readPackageJson(packageJsonPath) {
+    let source;
+    try {
+        source = await fs.readFile(packageJsonPath, 'utf8');
+    }
+    catch (error) {
+        let nodeError = error;
+        let detail = nodeError.code == null
+            ? 'Could not read package.json.'
+            : `Could not read package.json (${nodeError.code}).`;
+        return {
+            suite: createDoctorSuite('environment', [
+                {
+                    actualPath: 'package.json',
+                    code: 'package-json-read-failed',
+                    message: detail,
+                    severity: 'warn',
+                    suite: 'environment',
+                },
+            ]),
+        };
+    }
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        return {
+            suite: createDoctorSuite('environment', [
+                {
+                    actualPath: 'package.json',
+                    code: 'package-json-invalid',
+                    message: 'package.json is not valid JSON.',
+                    severity: 'warn',
+                    suite: 'environment',
+                },
+            ]),
+        };
+    }
+}
+function hasRemixDependency(packageJson) {
+    return packageJson.dependencies?.remix != null || packageJson.devDependencies?.remix != null;
+}
+function getEnvironmentFixCode(findings) {
+    let fixableFinding = findings.find((finding) => finding.code === 'node-engine-missing' ||
+        finding.code === 'node-engine-unparseable' ||
+        finding.code === 'node-version-unsupported' ||
+        finding.code === 'remix-dependency-missing');
+    return fixableFinding?.code ?? null;
+}
+async function canResolveRemix(projectRoot) {
+    if (!(await pathExists(path.join(projectRoot, 'node_modules', 'remix', 'package.json')))) {
+        return false;
+    }
+    try {
+        let require = createRequire(path.join(projectRoot, 'package.json'));
+        require.resolve('remix/package.json');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function satisfiesNodeRange(version, range) {
+    let parsedVersion = semver.valid(version);
+    let trimmedRange = range.trim();
+    if (parsedVersion == null || trimmedRange === '') {
+        return null;
+    }
+    let parsedRange = semver.validRange(trimmedRange);
+    if (parsedRange == null) {
+        return null;
+    }
+    return semver.satisfies(parsedVersion, parsedRange);
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/lib/doctor/fixes.d.ts

@@ -0,0 +1,3 @@
+import type { DoctorAppliedFix, DoctorFixPlan } from './types.ts';
+export declare function applyDoctorFixPlans(appRoot: string, fixPlans: DoctorFixPlan[]): Promise<DoctorAppliedFix[]>;
+//# sourceMappingURL=fixes.d.ts.map

package/dist/lib/doctor/fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/fixes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAEjE,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,aAAa,EAAE,GACxB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAmC7B"}

package/dist/lib/doctor/fixes.js

@@ -0,0 +1,65 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { resolveContainedPath } from "../contained-path.js";
+export async function applyDoctorFixPlans(appRoot, fixPlans) {
+    let appliedFixes = [];
+    for (let fixPlan of dedupeDoctorFixPlans(fixPlans)) {
+        let absolutePath = resolveDoctorFixPath(appRoot, fixPlan.path);
+        if (fixPlan.kind === 'create-directory') {
+            await fs.mkdir(absolutePath, { recursive: true });
+            appliedFixes.push(toAppliedDoctorFix(fixPlan));
+            continue;
+        }
+        await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+        if (fixPlan.kind === 'update-file') {
+            await fs.writeFile(absolutePath, fixPlan.contents ?? '', { encoding: 'utf8' });
+            appliedFixes.push(toAppliedDoctorFix(fixPlan));
+            continue;
+        }
+        try {
+            await fs.writeFile(absolutePath, fixPlan.contents ?? '', { encoding: 'utf8', flag: 'wx' });
+        }
+        catch (error) {
+            let nodeError = error;
+            if (nodeError.code !== 'EEXIST') {
+                throw error;
+            }
+            continue;
+        }
+        appliedFixes.push(toAppliedDoctorFix(fixPlan));
+    }
+    return appliedFixes;
+}
+function dedupeDoctorFixPlans(fixPlans) {
+    let seen = new Set();
+    let uniqueFixPlans = [];
+    for (let fixPlan of fixPlans) {
+        let key = `${fixPlan.kind}:${fixPlan.path}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        uniqueFixPlans.push(fixPlan);
+    }
+    return uniqueFixPlans;
+}
+function toAppliedDoctorFix(fixPlan) {
+    return {
+        code: fixPlan.code,
+        kind: fixPlan.kind,
+        path: fixPlan.path,
+        routeName: fixPlan.routeName,
+        suite: fixPlan.suite,
+    };
+}
+function resolveDoctorFixPath(appRoot, fixPath) {
+    try {
+        return resolveContainedPath(appRoot, fixPath);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('escapes the allowed root')) {
+            throw new Error(`Doctor fix path resolves outside the app root: ${fixPath}`);
+        }
+        throw error;
+    }
+}

package/dist/lib/doctor/project.d.ts

@@ -0,0 +1,10 @@
+import { type LoadedRouteManifest } from '../route-map.ts';
+import { type DoctorFixPlan, type DoctorSuiteResult } from './types.ts';
+export interface ProjectDoctorResult {
+    routesFile: string;
+    routeManifest?: LoadedRouteManifest;
+    suite: DoctorSuiteResult;
+}
+export declare function checkProject(projectRoot: string): Promise<ProjectDoctorResult>;
+export declare function getProjectFixPlans(projectRoot: string): Promise<DoctorFixPlan[]>;
+//# sourceMappingURL=project.d.ts.map

package/dist/lib/doctor/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/project.ts"],"names":[],"mappings":"AAUA,OAAO,EAAgC,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACxF,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,mBAAmB,CAAA;IACnC,KAAK,EAAE,iBAAiB,CAAA;CACzB;AAED,wBAAsB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAmCpF;AAED,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAoDtF"}

package/dist/lib/doctor/project.js

@@ -0,0 +1,371 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { getOwnerFileExtension, isActionFileName, isControllerEntryFileName, } from "../controller-files.js";
+import { CliError } from "../errors.js";
+import { loadRouteManifestFromAppRoot } from "../route-map.js";
+import { createDoctorSuite, } from "./types.js";
+export async function checkProject(projectRoot) {
+    let routesFile = path.join(projectRoot, 'app', 'routes.ts');
+    if (!(await pathExists(routesFile))) {
+        return {
+            routesFile,
+            suite: createDoctorSuite('project', [
+                {
+                    code: 'routes-file-missing',
+                    expectedPath: 'app/routes.ts',
+                    fixable: true,
+                    message: 'Project is missing app/routes.ts.',
+                    severity: 'warn',
+                    suite: 'project',
+                },
+            ]),
+        };
+    }
+    try {
+        let routeManifest = await loadRouteManifestFromAppRoot(projectRoot);
+        return {
+            routeManifest,
+            routesFile,
+            suite: createDoctorSuite('project', []),
+        };
+    }
+    catch (error) {
+        let finding = toProjectFinding(error);
+        return {
+            routesFile,
+            suite: createDoctorSuite('project', [finding]),
+        };
+    }
+}
+export async function getProjectFixPlans(projectRoot) {
+    let routesFile = path.join(projectRoot, 'app', 'routes.ts');
+    let homeActionPath = normalizeRelativePath(path.join('app', 'controllers', `home${await inferHomeOwnerExtension(projectRoot)}`));
+    if (await pathExists(routesFile)) {
+        let routesSource = await fs.readFile(routesFile, 'utf8');
+        if (!hasOnlyWhitespaceAndComments(routesSource)) {
+            return [];
+        }
+        return [
+            {
+                code: 'routes-export-missing',
+                contents: renderDefaultRoutesFile(),
+                kind: 'update-file',
+                path: 'app/routes.ts',
+                suite: 'project',
+            },
+            ...((await pathExists(path.join(projectRoot, homeActionPath)))
+                ? []
+                : [
+                    {
+                        code: 'missing-owner',
+                        contents: renderDefaultHomeAction(homeActionPath),
+                        kind: 'create-file',
+                        path: homeActionPath,
+                        routeName: 'home',
+                        suite: 'project',
+                    },
+                ]),
+        ];
+    }
+    return [
+        {
+            code: 'routes-file-missing',
+            contents: renderDefaultRoutesFile(),
+            kind: 'create-file',
+            path: 'app/routes.ts',
+            suite: 'project',
+        },
+        {
+            code: 'missing-owner',
+            contents: renderDefaultHomeAction(homeActionPath),
+            kind: 'create-file',
+            path: homeActionPath,
+            routeName: 'home',
+            suite: 'project',
+        },
+    ];
+}
+function toProjectFinding(error) {
+    if (error instanceof CliError) {
+        if (error.code === 'RMX_ROUTE_MAP_LOADER_INVALID_JSON') {
+            return {
+                code: 'route-map-invalid-json',
+                message: 'Route-map loader returned invalid JSON while loading app/routes.ts.',
+                severity: 'warn',
+                suite: 'project',
+            };
+        }
+        if (error.code === 'RMX_ROUTE_MAP_LOADER_SIGNAL') {
+            return {
+                code: 'route-map-loader-signal',
+                message: error.message,
+                severity: 'warn',
+                suite: 'project',
+            };
+        }
+        if (error.code === 'RMX_ROUTE_MAP_LOADER_FAILED') {
+            return classifyRouteMapLoaderFailure(error.message);
+        }
+    }
+    let message = error instanceof Error ? error.message : String(error);
+    return {
+        code: 'route-module-import-failed',
+        message: `Failed to load app/routes.ts: ${message}`,
+        severity: 'warn',
+        suite: 'project',
+    };
+}
+function classifyRouteMapLoaderFailure(message) {
+    if (message.includes('must export a named "routes" value')) {
+        return {
+            code: 'routes-export-missing',
+            message: 'app/routes.ts must export a named "routes" value.',
+            severity: 'warn',
+            suite: 'project',
+        };
+    }
+    if (message.startsWith('Invalid route map value at "') ||
+        message.startsWith('Detected a route map cycle at "')) {
+        return {
+            code: 'route-map-invalid',
+            message,
+            severity: 'warn',
+            suite: 'project',
+        };
+    }
+    return {
+        code: 'route-module-import-failed',
+        message: `Failed to load app/routes.ts: ${message}`,
+        severity: 'warn',
+        suite: 'project',
+    };
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+function hasOnlyWhitespaceAndComments(source) {
+    for (let index = 0; index < source.length;) {
+        let char = source[index];
+        let next = source[index + 1];
+        if (char == null || /\s/.test(char)) {
+            index += 1;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            index += 2;
+            while (index < source.length && source[index] !== '\n') {
+                index += 1;
+            }
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            index += 2;
+            while (index < source.length && !(source[index] === '*' && source[index + 1] === '/')) {
+                index += 1;
+            }
+            index = Math.min(index + 2, source.length);
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+async function inferHomeOwnerExtension(projectRoot) {
+    let controllersDir = path.join(projectRoot, 'app', 'controllers');
+    let extensions = await collectOwnerExtensions(controllersDir);
+    if (extensions.length > 0) {
+        return getMostCommonExtension(extensions);
+    }
+    if (await pathExists(path.join(projectRoot, 'tsconfig.json'))) {
+        return '.tsx';
+    }
+    return '.js';
+}
+async function collectOwnerExtensions(directory) {
+    try {
+        let entries = await fs.readdir(directory, { withFileTypes: true });
+        let extensions = [];
+        for (let entry of entries) {
+            let absolutePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                extensions.push(...(await collectOwnerExtensions(absolutePath)));
+                continue;
+            }
+            let fileName = path.basename(absolutePath);
+            if (!isActionFileName(fileName) && !isControllerEntryFileName(fileName)) {
+                continue;
+            }
+            let extension = getOwnerFileExtension(fileName);
+            if (extension != null) {
+                extensions.push(extension);
+            }
+        }
+        return extensions;
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function getMostCommonExtension(extensions) {
+    let priority = ['.tsx', '.ts', '.jsx', '.js'];
+    let counts = new Map();
+    for (let extension of extensions) {
+        counts.set(extension, (counts.get(extension) ?? 0) + 1);
+    }
+    let bestExtension = priority[0];
+    let bestCount = -1;
+    for (let extension of priority) {
+        let count = counts.get(extension) ?? 0;
+        if (count > bestCount) {
+            bestCount = count;
+            bestExtension = extension;
+        }
+    }
+    return bestExtension;
+}
+function renderDefaultRoutesFile() {
+    return [
+        `import { route } from 'remix/fetch-router/routes'`,
+        '',
+        'export const routes = route({',
+        `  home: '/',`,
+        '})',
+        '',
+    ].join('\n');
+}
+function normalizeRelativePath(filePath) {
+    return filePath.split(path.sep).join('/');
+}
+function renderDefaultHomeAction(entryPath) {
+    let extension = getOwnerFileExtension(entryPath);
+    if (extension === '.js') {
+        return [
+            `import { html } from 'remix/html-template'`,
+            `import { createHtmlResponse } from 'remix/response/html'`,
+            '',
+            'export const home = {',
+            '  handler() {',
+            '    let page = html`',
+            '      <html lang="en">',
+            '        <head>',
+            '          <meta charset="utf-8" />',
+            '          <meta name="viewport" content="width=device-width, initial-scale=1" />',
+            '          <title>Home</title>',
+            '        </head>',
+            '        <body>',
+            '          <h1>Home</h1>',
+            '          <p>Update app/routes.ts and app/controllers/home to keep building your app.</p>',
+            '        </body>',
+            '      </html>',
+            '    `',
+            '    return createHtmlResponse(page)',
+            '  },',
+            '}',
+            '',
+        ].join('\n');
+    }
+    if (extension === '.ts') {
+        return [
+            `import type { BuildAction } from 'remix/fetch-router'`,
+            `import { html } from 'remix/html-template'`,
+            `import { createHtmlResponse } from 'remix/response/html'`,
+            '',
+            `import type { routes } from '../routes.ts'`,
+            '',
+            `export const home: BuildAction<'ANY', typeof routes.home> = {`,
+            '  handler() {',
+            '    let page = html`',
+            '      <html lang="en">',
+            '        <head>',
+            '          <meta charset="utf-8" />',
+            '          <meta name="viewport" content="width=device-width, initial-scale=1" />',
+            '          <title>Home</title>',
+            '        </head>',
+            '        <body>',
+            '          <h1>Home</h1>',
+            '          <p>Update app/routes.ts and app/controllers/home to keep building your app.</p>',
+            '        </body>',
+            '      </html>',
+            '    `',
+            '    return createHtmlResponse(page)',
+            '  },',
+            '}',
+            '',
+        ].join('\n');
+    }
+    if (extension === '.jsx') {
+        return [
+            `import { renderToStream } from 'remix/ui/server'`,
+            `import { createHtmlResponse } from 'remix/response/html'`,
+            '',
+            'export const home = {',
+            '  handler() {',
+            '    let page = <HomePage />',
+            '    return createHtmlResponse(renderToStream(page))',
+            '  },',
+            '}',
+            '',
+            'function HomePage() {',
+            '  return () => (',
+            '    <html lang="en">',
+            '      <head>',
+            '        <meta charSet="utf-8" />',
+            '        <meta name="viewport" content="width=device-width, initial-scale=1" />',
+            '        <title>Home</title>',
+            '      </head>',
+            '      <body>',
+            '        <h1>Home</h1>',
+            '        <p>Update app/routes.ts and app/controllers/home to keep building your app.</p>',
+            '      </body>',
+            '    </html>',
+            '  )',
+            '}',
+            '',
+        ].join('\n');
+    }
+    return [
+        `import type { BuildAction } from 'remix/fetch-router'`,
+        `import { renderToStream } from 'remix/ui/server'`,
+        `import { createHtmlResponse } from 'remix/response/html'`,
+        '',
+        `import type { routes } from '../routes.ts'`,
+        '',
+        `export const home: BuildAction<'ANY', typeof routes.home> = {`,
+        '  handler() {',
+        '    let page = <HomePage />',
+        '    return createHtmlResponse(renderToStream(page))',
+        '  },',
+        '}',
+        '',
+        'function HomePage() {',
+        '  return () => (',
+        '    <html lang="en">',
+        '      <head>',
+        '        <meta charSet="utf-8" />',
+        '        <meta name="viewport" content="width=device-width, initial-scale=1" />',
+        '        <title>Home</title>',
+        '      </head>',
+        '      <body>',
+        '        <h1>Home</h1>',
+        '        <p>Update app/routes.ts and app/controllers/home to keep building your app.</p>',
+        '      </body>',
+        '    </html>',
+        '  )',
+        '}',
+        '',
+    ].join('\n');
+}