@remix-run/cli 0.0.0 → 0.1.0

package/dist/lib/doctor/controller-placeholders.js

@@ -0,0 +1,183 @@
+import * as path from 'node:path';
+import { getOwnerFileExtension } from "../controller-files.js";
+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, entryPath) {
+    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, entryPath, resolvedEntryPathByRouteName) {
+    let extension = getOwnerFileExtension(entryPath);
+    let lines = [];
+    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, entryPath, resolvedEntryPathByRouteName) {
+    let imports = [];
+    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, entryPath, resolvedEntryPathByRouteName) {
+    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) {
+    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) {
+    return `${toIdentifier(key)}Controller`;
+}
+function getActionExportName(key) {
+    return toIdentifier(key);
+}
+function getRouteAccessExpression(routeName) {
+    let segments = routeName.split('.');
+    let expression = 'routes';
+    for (let segment of segments) {
+        expression += isIdentifier(segment) ? `.${segment}` : `[${JSON.stringify(segment)}]`;
+    }
+    return expression;
+}
+function getRelativeImportPath(fromFilePath, toFilePath) {
+    let relativePath = path.posix.relative(path.posix.dirname(fromFilePath), toFilePath);
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function formatObjectKey(key) {
+    return isIdentifier(key) ? key : JSON.stringify(key);
+}
+function toIdentifier(value) {
+    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) {
+    return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+function isIdentifier(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+}

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

@@ -0,0 +1,8 @@
+import { type OwnershipRouteNode } from '../controller-ownership.ts';
+import { type DoctorFixPlan, type DoctorSuiteResult } from './types.ts';
+export interface ControllerDoctorResult {
+    fixPlans: DoctorFixPlan[];
+    suite: DoctorSuiteResult;
+}
+export declare function checkControllerConventions(appRoot: string, tree: OwnershipRouteNode[]): Promise<ControllerDoctorResult>;
+//# sourceMappingURL=controllers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controllers.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAGhG,OAAO,EAAqB,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAE1F,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,KAAK,EAAE,iBAAiB,CAAA;CACzB;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,kBAAkB,EAAE,GACzB,OAAO,CAAC,sBAAsB,CAAC,CASjC"}

package/dist/lib/doctor/controllers.js

@@ -0,0 +1,13 @@
+import { inspectControllerOwnership } from "../controller-ownership.js";
+import { getControllerFindings } from "./controller-findings.js";
+import { getControllerFixPlans } from "./controller-fix-plans.js";
+import { createDoctorSuite } from "./types.js";
+export async function checkControllerConventions(appRoot, tree) {
+    let ownership = await inspectControllerOwnership(appRoot, tree);
+    let fixPlans = await getControllerFixPlans(appRoot, tree, ownership);
+    let findings = getControllerFindings(ownership, fixPlans);
+    return {
+        fixPlans,
+        suite: createDoctorSuite('controllers', findings),
+    };
+}

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

@@ -0,0 +1,17 @@
+import { type DoctorFixPlan, type DoctorSuiteResult } from './types.ts';
+interface DoctorPackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    engines?: Record<string, string>;
+    name?: string;
+}
+export interface EnvironmentDoctorResult {
+    packageJson?: DoctorPackageJson;
+    packageJsonPath?: string;
+    projectRoot?: string;
+    suite: DoctorSuiteResult;
+}
+export declare function checkEnvironment(cwd?: string): Promise<EnvironmentDoctorResult>;
+export declare function getEnvironmentFixPlans(result: EnvironmentDoctorResult, remixVersion: string | undefined): DoctorFixPlan[];
+export {};
+//# sourceMappingURL=environment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/environment.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAA;AAEnB,UAAU,iBAAiB;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,uBAAuB;IACtC,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,iBAAiB,CAAA;CACzB;AAED,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,uBAAuB,CAAC,CAwFlC;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,aAAa,EAAE,CA6CjB"}

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"}