@rsc-kit/core 0.30.12 → 0.30.14

package/dist/vite.js

@@ -157,6 +157,7 @@ let typesDir;
 let hotFile;
 let hostCallOptions;
 let packageDir;
+let backendPaths = [];
 let hostGlobal;
 let interceptManifestFile;
 let packageAlias;
@@ -348,6 +349,34 @@ function aliasEntries() {
     });
     return entries;
 }
+/**
+ * The prefixes a backend owns, as the matcher reads them: `/auth`, no trailing
+ * slash. Refused rather than corrected where a mistake would silently send the
+ * whole app, or its own endpoints, to the backend.
+ */
+export function normaliseBackendPaths(paths) {
+    const out = [];
+    for (const raw of paths ?? []) {
+        const given = typeof raw === "string" ? raw.trim() : "";
+        if (!given.startsWith("/")) {
+            throw new Error(`[rsc-kit] backendPaths: ${JSON.stringify(raw)} is not a path. Each starts with a slash, as in '/auth'.`);
+        }
+        // After the slash check, so "/" is the root and not "not a path".
+        const path = given.replace(/\/+$/, "");
+        if (path === "") {
+            throw new Error("[rsc-kit] backendPaths: '/' is every url, and nothing would be left for this app. Name the prefixes the backend owns.");
+        }
+        if (path === "/_rsc" || path.startsWith("/_rsc/")) {
+            throw new Error(`[rsc-kit] backendPaths: ${JSON.stringify(raw)} is this package's own endpoint, which the renderer answers.`);
+        }
+        if (/[?#*]/.test(path)) {
+            throw new Error(`[rsc-kit] backendPaths: ${JSON.stringify(raw)} is a prefix, not a pattern: no query, fragment or wildcard.`);
+        }
+        if (!out.includes(path))
+            out.push(path);
+    }
+    return out;
+}
 function resolvePaths(options) {
     projectRoot = resolve(options.projectRoot || process.env.RSC_PROJECT_ROOT || process.cwd());
     sourceDir = resolve(options.sourceDir || process.env.RSC_SOURCE_DIR || join(projectRoot, "src"));
@@ -385,6 +414,7 @@ function resolvePaths(options) {
     hotFile = options.hotFile || process.env.RSC_HOT_FILE || "";
     hostCallOptions = options.hostCall;
     packageDir = resolve(options.packageDir || process.env.RSC_PACKAGE_DIR || thisDir());
+    backendPaths = normaliseBackendPaths(options.backendPaths);
     hostGlobal = options.hostGlobal || process.env.RSC_HOST_GLOBAL || "rpc";
     interceptManifestFile = resolve(options.interceptManifestFile ||
         process.env.RSC_INTERCEPT_MANIFEST ||
@@ -2155,13 +2185,64 @@ function tsParams(sig) {
         params.push("...rest: Array<" + tsOf(sig.rest) + ">");
     return params.join(", ");
 }
-/** The first parameter's schema with its reference followed, for decoding a form into it. */
-function firstParamSchema(sig) {
-    const first = sig?.params[0];
-    const ref = first?.$ref;
+/** A parameter's schema with its reference followed, for decoding a form into it. */
+function resolveParam(param) {
+    const ref = param?.$ref;
     if (typeof ref === "string" && ref.startsWith("#/defs/"))
         return hostDefs[ref.slice(7)] ?? null;
-    return first ?? null;
+    return param ?? null;
+}
+/**
+ * The parameter a form lands on: the last one that is a struct.
+ *
+ * A form is one object, and a backend action may take others before it - the
+ * team an action is scoped to, bound with `stub.bind(null, team)` - so it is
+ * the struct at the end, not the first parameter, that the fields belong to.
+ * -1 when no parameter is one, and then a form is not what the action takes.
+ */
+function formParam(sig) {
+    const params = sig?.params ?? [];
+    for (let i = params.length - 1; i >= 0; i--) {
+        const schema = resolveParam(params[i]);
+        if (schema && (schema.type === "object" || schema.properties))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Every name a struct can be read or refused under, as a TypeScript type: its
+ * fields, a nested object's `address.city`, and a list's `items.${number}`.
+ * The dotted paths a validation reports, so `error()` is closed to them.
+ */
+function fieldNames(schema, prefix = "", depth = 3) {
+    const properties = (schema?.properties ?? {});
+    const out = [];
+    for (const [key, raw] of Object.entries(properties)) {
+        const prop = resolveParam(raw);
+        const path = prefix + key;
+        out.push(path);
+        if (depth === 0 || !prop)
+            continue;
+        if (prop.type === "array") {
+            out.push(path + ".${number}");
+            const item = resolveParam(prop.items);
+            if (item?.properties)
+                out.push(...fieldNames(item, path + ".${number}.", depth - 1));
+        }
+        else if (prop.properties) {
+            out.push(...fieldNames(prop, path + ".", depth - 1));
+        }
+    }
+    return out;
+}
+/** What a form posted to this action is: FormFields naming the struct's fields, or a plain FormData. */
+function formType(sig) {
+    const index = formParam(sig);
+    const names = index < 0 ? [] : fieldNames(resolveParam(sig.params[index]));
+    if (names.length === 0)
+        return "FormData";
+    const literal = (name) => (name.includes("${") ? "`" + name + "`" : JSON.stringify(name));
+    return "FormFields<" + [...new Set(names)].map(literal).join(" | ") + ">";
 }
 /**
  * A form posted to a backend action. React hands the action a FormData; on
@@ -2170,10 +2251,16 @@ function firstParamSchema(sig) {
  * fields become one object, typed by the first parameter where the backend
  * described it: numbers and booleans coerced, a repeated name a list.
  */
-const FORM_ARGS = `function formArgs(args: unknown[], schema: Record<string, any> | null): unknown[] {
-  if (args.length !== 1 || !(args[0] instanceof FormData)) return args
+const FORM_ARGS = `function formArgs(args: unknown[], schemas: (Record<string, any> | null)[]): unknown[] {
+  // The form is the last argument, and it fills the parameter it lands on: the
+  // first when the action takes nothing before it, the one after the team when
+  // that was bound with stub.bind(null, team).
+  const at = args.length - 1
 
-  const form = args[0] as FormData
+  if (at < 0 || !(args[at] instanceof FormData)) return args
+
+  const form = args[at] as FormData
+  const schema = schemas[at] ?? null
   const props: Record<string, any> = schema?.properties ?? {}
   const coerce = (type: unknown, v: string): unknown =>
     type === 'integer' || type === 'number' ? (v === '' ? null : Number(v))
@@ -2198,7 +2285,7 @@ const FORM_ARGS = `function formArgs(args: unknown[], schema: Record<string, any
     if (!(key in out) && prop?.type === 'boolean') out[key] = false
   }
 
-  return [out]
+  return [...args.slice(0, at), out]
 }
 `;
 /** The "use server" module exposing each host function as a plain async call. */
@@ -2209,7 +2296,8 @@ function renderHostActions() {
         "",
     ];
     // Type-only, so the module stays what "use server" allows: functions.
-    lines.push('import type { Redirected } from "@rsc-kit/core/errors";', "");
+    lines.push('import type { Redirected } from "@rsc-kit/core/errors";');
+    lines.push('import type { FormFields } from "@rsc-kit/core/form";', "");
     lines.push(FORM_ARGS);
     for (const [name, target] of Object.entries(hostActions)) {
         const sig = hostTypes[target];
@@ -2222,7 +2310,13 @@ function renderHostActions() {
             // it as data.
             const result = "Promise<" + (sig.result ? tsOf(sig.result) : "void") + " | Redirected>";
             lines.push("export async function " + name + "(" + tsParams(sig) + "): " + result + ";");
-            lines.push("export async function " + name + "(form: FormData): " + result + ";");
+            // The form overload is last, which is the one `stub.bind(null, team)`
+            // reads: bound, it is `(form: FormFields<…>) => …`, so a form's action
+            // keeps the struct's field names. Leading parameters are the ones the
+            // form does not fill; any after the struct are left to the backend.
+            const at = formParam(sig);
+            const leading = at > 0 ? sig.params.slice(0, at).map((p, i) => "arg" + (i + 1) + ": " + tsOf(p)) : [];
+            lines.push("export async function " + name + "(" + [...leading, "form: " + formType(sig)].join(", ") + "): " + result + ";");
         }
         lines.push("export async function " + name + "(...args: unknown[]) {");
         lines.push("  return await (globalThis as any)." +
@@ -2230,7 +2324,7 @@ function renderHostActions() {
             "(" +
             JSON.stringify(target) +
             ", ...formArgs(args, " +
-            JSON.stringify(firstParamSchema(sig)) +
+            JSON.stringify((sig?.params ?? []).map(resolveParam)) +
             "));");
         lines.push("}");
         lines.push("");
@@ -2705,17 +2799,40 @@ function fallbackOrigin(): string {
 const FALLBACK_MARKER = 'x-rsc-renderer-fallback'
 const PROXIED_MARKER = 'x-rsc-proxied-by-backend'
 `;
+/**
+ * The urls the app said belong to the backend, tested before any page is
+ * matched. Emitted in both variants: a test's stand-in backend is reached by
+ * the same prefixes as the real one.
+ */
+function backendPathConsts() {
+    return `const BACKEND_PATHS: string[] = ${JSON.stringify(backendPaths)}
+
+// A prefix at a segment boundary: '/auth' is '/auth' and what is under it, not '/authors'.
+function onBackendPath(pathname: string): boolean {
+  return BACKEND_PATHS.some((prefix) => pathname === prefix || pathname.startsWith(prefix + '/'))
+}
+`;
+}
 /** With no backend configured: this app's not-found page, or a test's backend. */
-const NO_FALLBACK_BODY = `  const answer = await devHandler(request)
+const NO_FALLBACK_BODY = `  // The app named this prefix as the backend's: no page is asked about it, so one
+  // that matches (a dynamic root route) cannot answer for it.
+  const toBackend = onBackendPath(new URL(request.url).pathname)
+  const answer = toBackend ? null : await devHandler(request)
 
   if (answer) return answer
 
-  if (backendForward && !pageSaidNotFound(request)) return await backendForward(request)
+  if (backendForward && (toBackend || !pageSaidNotFound(request))) return await backendForward(request)
 
   return await notFound(request)
 `;
 const FALLBACK_BODY = `  const FALLBACK_ORIGIN = fallbackOrigin()
-  const answer = await devHandler(request)
+
+  // The app named this prefix as the backend's (rscKit({ backendPaths })): no
+  // page is asked about it. A dynamic root route such as [team]/[app] matches
+  // /gitlab/connect, renders, says notFound() - and a page that said that is not
+  // forwarded, so the backend's own route was the not-found page.
+  const toBackend = onBackendPath(new URL(request.url).pathname)
+  const answer = toBackend ? null : await devHandler(request)
 
   if (answer) return answer
 
@@ -2723,7 +2840,7 @@ const FALLBACK_BODY = `  const FALLBACK_ORIGIN = fallbackOrigin()
   // its guard, or a backend's 404. That is this app's not-found.tsx, not a
   // url for the backend: forwarded, the backend answered with its own 404
   // and the app's never showed.
-  if (pageSaidNotFound(request)) return await notFound(request)
+  if (!toBackend && pageSaidNotFound(request)) return await notFound(request)
 
   // Nothing here owns this url. In development the backend usually does — a
   // Blade page, /login, a webhook, an uploaded file under /storage — so the
@@ -5643,7 +5760,7 @@ export async function handleRscPprShell(
  * server rendering live pages it had already frozen. The gate is the mode, not
  * the file.
  */
-${fallbackOrigin === false ? "" : FALLBACK_CONSTS.replace("__ORIGIN__", JSON.stringify(fallbackOrigin))}${NITRO_HOST_CALLS}
+${backendPathConsts()}${fallbackOrigin === false ? "" : FALLBACK_CONSTS.replace("__ORIGIN__", JSON.stringify(fallbackOrigin))}${NITRO_HOST_CALLS}
 let devHandler: ((request: Request) => Promise<Response | null>) | null = null
 
 export default async function handler(request: Request): Promise<Response> {