zitejs 0.10.0-start.7 → 0.10.0-start.9

package/dist/esm/check/index.js

@@ -1,7 +1,8 @@
 import { execFileSync } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, relative } from 'path';
 import { listEndpointNames, listSourceDirs } from '../sourceRoots.js';
+import { formatProblem } from './start/problem.js';
 /**
  * An argument array, not a command string, so no shell is involved.
  *
@@ -57,41 +58,132 @@ function bundleFailures(output) {
 }
 const indent = (output) => output.trim().split('\n').map(l => `    ${l}`).join('\n');
 /**
- * A Start app: `vite build` first, since it regenerates the route tree tsc
- * reads, then tsc, then describe, which reports what the platform's build
- * refuses, read the same way.
+ * While `--json` checks, stdout carries only the report: app code that logs as
+ * it's described in-process goes to stderr instead.
  */
-async function checkStartApp(appPath) {
-    process.stdout.write('  vite build ... ');
-    const vite = run('npx', ['vite', 'build'], appPath);
-    console.log(vite.ok ? '✓' : '✗');
-    if (!vite.ok) {
-        console.log(indent(vite.output));
+export const withStdoutOnStderr = async (run) => {
+    const write = process.stdout.write;
+    process.stdout.write = process.stderr.write.bind(process.stderr);
+    try {
+        return await run();
+    }
+    finally {
+        process.stdout.write = write;
+    }
+};
+/** Prints as it goes, or with `--json` stays quiet and reports everything at the end. */
+export class Reporter {
+    json;
+    apps = [];
+    constructor(json) {
+        this.json = json;
+    }
+    app(path, runtime, heading) {
+        const app = { path, runtime, ok: true, steps: [], problems: [] };
+        this.apps.push(app);
+        if (heading && !this.json)
+            console.log(`\n── ${path} ──`);
+        return app;
+    }
+    step(app, name, result) {
+        const output = result.output?.trim();
+        app.steps.push({ name, ok: result.ok, ...(output && !result.ok && { output }) });
+        if (!result.ok)
+            app.ok = false;
+        if (!this.json) {
+            console.log(`  ${name} ... ${result.ok ? '✓' : '✗'}`);
+            if (!result.ok && output)
+                console.log(indent(output));
+        }
+        return result.ok;
+    }
+    problems(app, problems) {
+        app.problems.push(...problems);
+        if (problems.some(p => p.severity === 'error'))
+            app.ok = false;
+        if (!this.json && problems.length)
+            console.log(problems.map(p => `    ${formatProblem(p)}`).join('\n'));
+    }
+}
+const SKIPPED_DIRS = new Set(['node_modules', 'dist', '.output', '.tanstack', '.wrangler']);
+/** The app's own source, by app-relative path. */
+function readAppSources(appPath) {
+    const sources = {};
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (SKIPPED_DIRS.has(entry.name))
+                continue;
+            const full = join(dir, entry.name);
+            if (entry.isDirectory())
+                visit(full);
+            else if (/\.[cm]?[jt]sx?$/.test(entry.name))
+                sources[relative(appPath, full)] = readFileSync(full, 'utf-8');
+        }
+    };
+    const src = join(appPath, 'src');
+    if (existsSync(src))
+        visit(src);
+    return sources;
+}
+const isInternalApp = (appPath) => {
+    try {
+        return JSON.parse(readFileSync(join(appPath, 'zite.config.json'), 'utf-8'))?.accessMode === 'internal';
+    }
+    catch {
         return false;
     }
-    process.stdout.write('  tsc --noEmit ... ');
+};
+/**
+ * A Start app: `vite build` first, since it regenerates the route tree tsc
+ * reads, then tsc, then describe, which reports what the platform's build
+ * refuses, read the same way, then the source hints.
+ */
+async function checkStartApp(reporter, app, appPath) {
+    if (!reporter.step(app, 'vite build', run('npx', ['vite', 'build'], appPath)))
+        return;
     // --pretty for `file:line:col - error` lines, the shape the platform re-roots.
-    const tsc = run('npx', ['tsc', '--noEmit', '--pretty', '-p', 'tsconfig.app.json'], appPath);
-    console.log(tsc.ok ? '✓' : '✗');
-    if (!tsc.ok)
-        console.log(indent(tsc.output));
-    process.stdout.write('  describe ... ');
+    reporter.step(app, 'tsc --noEmit', run('npx', ['tsc', '--noEmit', '--pretty', '-p', 'tsconfig.app.json'], appPath));
+    const { describedProblems } = await import('./start/describeRules.js');
+    const { sourceProblems } = await import('./start/sourceRules.js');
     try {
         const { describeBuiltApp } = await import('../start/describeBuilt.js');
-        const { descriptionProblems } = await import('../start/problems.js');
-        const problems = descriptionProblems((await describeBuiltApp(appPath)));
-        console.log(problems.length ? '✗' : '✓');
-        if (problems.length)
-            console.log(problems.map(p => `    ${p}`).join('\n'));
-        return tsc.ok && problems.length === 0;
+        const description = (await describeBuiltApp(appPath));
+        const problems = describedProblems(description, { internal: isInternalApp(appPath) });
+        reporter.step(app, 'describe', { ok: !problems.some(p => p.severity === 'error') });
+        reporter.problems(app, problems);
     }
     catch (err) {
-        console.log('✗');
-        console.log(`    ${err instanceof Error ? err.message : String(err)}`);
-        return false;
+        reporter.step(app, 'describe', { ok: false, output: err instanceof Error ? err.message : String(err) });
+    }
+    const hints = sourceProblems(readAppSources(appPath));
+    reporter.step(app, 'source', { ok: !hints.some(p => p.severity === 'error') });
+    reporter.problems(app, hints);
+}
+function checkClassicApp(reporter, app, root, dir, appPath) {
+    // Only tsconfig.app.json compiles anything. The app's tsconfig.json is a
+    // solution-style config — `"files": []` plus a reference — so
+    // `tsc --noEmit -p tsconfig.json` type-checks zero files and exits 0. It
+    // used to be the fallback, which meant an app missing tsconfig.app.json
+    // reported a passing typecheck it never ran.
+    const tsconfigAppPath = join(appPath, 'tsconfig.app.json');
+    reporter.step(app, 'tsc --noEmit', existsSync(tsconfigAppPath)
+        ? run('npx', ['tsc', '--noEmit', '-p', tsconfigAppPath], '.')
+        : { ok: false, output: `no ${tsconfigAppPath}` });
+    // Endpoints never reach vite — they are bundled separately for the lambda,
+    // against a different resolver. tsc and vite both pass on an endpoint whose
+    // `zitejs/*` alias has no generated file behind it; only the bundler knows.
+    if (listEndpointNames(root, appPath).length > 0) {
+        const bundle = run('npx', ['zitejs', 'bundle', '--app', dir], '.');
+        const failures = bundle.ok ? bundleFailures(bundle.output) : [bundle.output];
+        reporter.step(app, 'bundle endpoints', { ok: failures.length === 0, output: failures.join('\n') });
+    }
+    if (existsSync(join(appPath, 'vite.config.ts'))) {
+        reporter.step(app, 'vite build', run('npx', ['vite', 'build'], appPath));
     }
 }
-export async function runCheck() {
+export async function runCheck(args = process.argv.slice(3)) {
+    const json = args.includes('--json');
+    const reporter = new Reporter(json);
     const { isStartAppDir } = await import('../start/entries.js');
     // Run inside a Start app, its own zitejs checks just that app: the workspace
     // root's is a classic release that doesn't know Start.
@@ -101,72 +193,27 @@ export async function runCheck() {
         console.error('No apps or automations found under apps/ or automations/.');
         process.exit(1);
     }
-    let allPassed = inStartApp ? await checkStartApp('.') : true;
-    for (const { root, dir: app, path: appPath } of appDirs) {
-        console.log(`\n── ${appPath} ──`);
-        if (isStartAppDir(appPath)) {
-            if (!(await checkStartApp(appPath)))
-                allPassed = false;
-            continue;
-        }
-        // Only tsconfig.app.json compiles anything. The app's tsconfig.json is a
-        // solution-style config — `"files": []` plus a reference — so
-        // `tsc --noEmit -p tsconfig.json` type-checks zero files and exits 0. It
-        // used to be the fallback, which meant an app missing tsconfig.app.json
-        // reported a passing typecheck it never ran.
-        const tsconfigAppPath = join(appPath, 'tsconfig.app.json');
-        if (!existsSync(tsconfigAppPath)) {
-            console.log(`  tsc --noEmit ... ✗ (no ${tsconfigAppPath})`);
-            allPassed = false;
-        }
-        else {
-            process.stdout.write('  tsc --noEmit ... ');
-            const tsc = run('npx', ['tsc', '--noEmit', '-p', tsconfigAppPath], '.');
-            if (tsc.ok) {
-                console.log('✓');
-            }
-            else {
-                console.log('✗');
-                console.log(tsc.output.trim().split('\n').map(l => `    ${l}`).join('\n'));
-                allPassed = false;
-            }
-        }
-        // Endpoints never reach vite — they are bundled separately for the lambda,
-        // against a different resolver. tsc and vite both pass on an endpoint whose
-        // `zitejs/*` alias has no generated file behind it; only the bundler knows.
-        if (listEndpointNames(root, appPath).length > 0) {
-            process.stdout.write('  bundle endpoints ... ');
-            const bundle = run('npx', ['zitejs', 'bundle', '--app', app], '.');
-            const failures = bundle.ok ? bundleFailures(bundle.output) : [bundle.output];
-            if (failures.length === 0) {
-                console.log('✓');
+    const checkAll = async () => {
+        if (inStartApp)
+            await checkStartApp(reporter, reporter.app('.', 'start', false), '.');
+        for (const { root, dir, path: appPath } of appDirs) {
+            if (isStartAppDir(appPath)) {
+                await checkStartApp(reporter, reporter.app(appPath, 'start', true), appPath);
             }
             else {
-                console.log('✗');
-                console.log(failures.map(l => `    ${l}`).join('\n'));
-                allPassed = false;
+                checkClassicApp(reporter, reporter.app(appPath, 'classic', true), root, dir, appPath);
             }
         }
-        const viteConfig = join(appPath, 'vite.config.ts');
-        if (existsSync(viteConfig)) {
-            process.stdout.write('  vite build ... ');
-            const vite = run('npx', ['vite', 'build'], appPath);
-            if (vite.ok) {
-                console.log('✓');
-            }
-            else {
-                console.log('✗');
-                console.log(vite.output.trim().split('\n').map(l => `    ${l}`).join('\n'));
-                allPassed = false;
-            }
-        }
-    }
-    console.log('');
-    if (allPassed) {
-        console.log('All apps pass.');
+    };
+    await (json ? withStdoutOnStderr(checkAll) : checkAll());
+    const allPassed = reporter.apps.every(app => app.ok);
+    if (json) {
+        process.stdout.write(`${JSON.stringify({ ok: allPassed, apps: reporter.apps })}\n`);
     }
     else {
-        console.log('Some apps failed.');
-        process.exit(1);
+        console.log('');
+        console.log(allPassed ? 'All apps pass.' : 'Some apps failed.');
     }
+    if (!allPassed)
+        process.exit(1);
 }

package/dist/esm/check/start/describeRules.d.ts

@@ -0,0 +1,35 @@
+import type { Problem } from "./problem.js";
+type Access = {
+    kind: string;
+    roles?: string[];
+};
+export type CheckedDescription = {
+    functions: Array<{
+        id: string;
+        name?: string;
+        file?: string;
+        access: Access;
+        input?: unknown;
+        problems: string[];
+    }>;
+    routes: Array<{
+        path: string;
+        file?: string;
+        description?: string;
+        methods: Record<string, Access>;
+        problems: string[];
+    }>;
+    pages?: Array<{
+        path: string;
+        file?: string;
+    }>;
+    workflows?: Array<{
+        id: string;
+        file: string;
+        problems: string[];
+    }>;
+};
+export declare function describedProblems(description: CheckedDescription, { internal }: {
+    internal: boolean;
+}): Problem[];
+export {};

package/dist/esm/check/start/describeRules.js

@@ -0,0 +1,86 @@
+// The host, TanStack and Cloudflare answer these before the app does.
+const RESERVED_PATHS = [
+    /^\/_zite/,
+    /^\/__zite/,
+    /^\/_serverFn(\/|$)/,
+    /^\/cdn-cgi(\/|$)/,
+    /^\/auth(\/|$)/,
+    /^\/api\/auth(\/|$)/,
+    /^\/manifest\.webmanifest$/,
+];
+const OWNER_INPUTS = ["userId", "ownerId"];
+/** `access-missing: no signedIn…`, or a route's `GET: access-missing: …`, as a named problem. */
+const describeProblem = (problem, subject, file) => {
+    const match = /^(?:(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|ANY): )?([a-z][a-z-]*): (.*)$/s.exec(problem);
+    const [, method, rule, message] = match ?? [undefined, undefined, "describe", problem];
+    return {
+        rule: rule ?? "describe",
+        severity: "error",
+        ...(file && { file }),
+        message: `${subject}${method ? ` ${method}` : ""}: ${message ?? problem}`,
+    };
+};
+const inputProperties = (input) => {
+    const properties = input?.properties;
+    return properties && typeof properties === "object" ? Object.keys(properties) : [];
+};
+export function describedProblems(description, { internal }) {
+    const problems = [];
+    for (const fn of description.functions) {
+        const subject = `function ${fn.name ?? fn.id}`;
+        problems.push(...fn.problems.map((p) => describeProblem(p, subject, fn.file)));
+        if (internal && fn.access.kind === "anyone") {
+            problems.push({
+                rule: "public-in-internal",
+                severity: "error",
+                ...(fn.file && { file: fn.file }),
+                message: `${subject} is a publicFn, and this internal app signs everyone in; make it a signedInFn`,
+            });
+        }
+        const owner = fn.access.kind === "signedIn" && inputProperties(fn.input).find((p) => OWNER_INPUTS.includes(p));
+        if (owner) {
+            problems.push({
+                rule: "owner-from-input",
+                severity: "warning",
+                ...(fn.file && { file: fn.file }),
+                message: `${subject} takes ${owner} as input, which any caller can set; use context.user.id`,
+            });
+        }
+    }
+    for (const route of description.routes) {
+        const subject = `route ${route.path}`;
+        problems.push(...route.problems.map((p) => describeProblem(p, subject, route.file)));
+        const publicMethods = Object.entries(route.methods).filter(([, access]) => access.kind === "anyone");
+        if (internal && publicMethods.length > 0) {
+            problems.push({
+                rule: "public-in-internal",
+                severity: "error",
+                ...(route.file && { file: route.file }),
+                message: `${subject} lets anyone call ${publicMethods.map(([m]) => m).join(", ")}, and this internal app signs everyone in; use signedIn`,
+            });
+        }
+        if (!route.description) {
+            problems.push({
+                rule: "description-missing",
+                severity: "warning",
+                ...(route.file && { file: route.file }),
+                message: `${subject} has no description; add staticData: { description } for the editor`,
+            });
+        }
+    }
+    for (const workflow of description.workflows ?? []) {
+        problems.push(...workflow.problems.map((p) => describeProblem(p, `workflow ${workflow.id}`, workflow.file)));
+    }
+    const paths = new Map([...description.routes, ...(description.pages ?? [])].map((r) => [r.path, r.file]));
+    for (const [path, file] of paths) {
+        if (RESERVED_PATHS.some((reserved) => reserved.test(path))) {
+            problems.push({
+                rule: "reserved-path",
+                severity: "error",
+                ...(file && { file }),
+                message: `${path} is the platform's; give the route another path`,
+            });
+        }
+    }
+    return problems;
+}

package/dist/esm/check/start/problem.d.ts

@@ -0,0 +1,11 @@
+export type Severity = "error" | "warning";
+/** One finding of `zitejs check`, named by its rule. Errors fail the check; warnings only report. */
+export type Problem = {
+    rule: string;
+    severity: Severity;
+    /** App-relative. */
+    file?: string;
+    line?: number;
+    message: string;
+};
+export declare const formatProblem: ({ rule, severity, file, line, message }: Problem) => string;

package/dist/esm/check/start/problem.js

@@ -0,0 +1 @@
+export const formatProblem = ({ rule, severity, file, line, message }) => `${severity} ${rule}${file ? ` ${file}${line ? `:${line}` : ""}` : ""}: ${message}`;

package/dist/esm/check/start/sourceRules.d.ts

@@ -0,0 +1,3 @@
+import type { Problem } from "./problem.js";
+/** Every source hint for one Start app, given its files by app-relative path. */
+export declare function sourceProblems(sources: Record<string, string>): Problem[];