@vercel/redwood 2.5.0 → 2.5.1

package/dist/index.js

@@ -814,10 +814,11 @@ var require_superstatic = __commonJS({
     var superstatic_exports = {};
     __export2(superstatic_exports, {
       collectHasSegments: () => collectHasSegments,
+      compilePathToRegexpTemplate: () => compilePathToRegexpTemplate2,
       convertCleanUrls: () => convertCleanUrls,
       convertHeaders: () => convertHeaders,
       convertRedirects: () => convertRedirects,
-      convertRewrites: () => convertRewrites,
+      convertRewrites: () => convertRewrites2,
       convertTrailingSlash: () => convertTrailingSlash,
       getCleanUrls: () => getCleanUrls2,
       pathToRegexp: () => pathToRegexp,
@@ -933,21 +934,46 @@ var require_superstatic = __commonJS({
         }
       });
     }
-    function convertRewrites(rewrites, internalParamNames) {
+    function convertRewrites2(rewrites, internalParamNames) {
       return rewrites.map((r) => {
         const { src, segments } = sourceToRegex2(r.source);
         const hasSegments = collectHasSegments(r.has);
         normalizeHasKeys(r.has);
         normalizeHasKeys(r.missing);
         try {
-          const dest = replaceSegments(
+          const interpolate = (value) => replaceSegments(
             segments,
             hasSegments,
-            r.destination,
+            value,
             false,
             internalParamNames
           );
-          const route = { src, dest, check: true };
+          let route;
+          if (typeof r.destination === "string") {
+            route = { src, dest: interpolate(r.destination), check: true };
+          } else {
+            const destination = { ...r.destination, type: "service" };
+            if (typeof destination.path === "string") {
+              destination.path = interpolate(destination.path);
+            }
+            route = { src, destination };
+          }
+          if (r.transforms) {
+            route.transforms = r.transforms.map((transform) => {
+              if (transform.type !== "request.path") {
+                return { ...transform };
+              }
+              return {
+                ...transform,
+                args: compilePathToRegexpTemplateFromSegments(
+                  transform.args,
+                  segments,
+                  hasSegments,
+                  transform.env
+                )
+              };
+            });
+          }
           if (typeof r.env !== "undefined") {
             route.env = r.env;
           }
@@ -1088,6 +1114,81 @@ var require_superstatic = __commonJS({
     }
     var escapeSegment = (str, segmentName) => str.replace(new RegExp(`:${segmentName}`, "g"), `__ESC_COLON_${segmentName}`);
     var unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ":");
+    var pathTemplateSegmentNameRegex = /^([a-zA-Z_][a-zA-Z0-9_]*)/;
+    function isEscaped(value, index) {
+      let backslashCount = 0;
+      for (let i = index - 1; i >= 0 && value[i] === "\\"; i--) {
+        backslashCount++;
+      }
+      return backslashCount % 2 === 1;
+    }
+    function collectPathTemplateSegments(template) {
+      const segments = [];
+      for (let i = 0; i < template.length; i++) {
+        if (template[i] !== ":" || isEscaped(template, i)) {
+          continue;
+        }
+        const match = template.slice(i + 1).match(pathTemplateSegmentNameRegex);
+        if (match) {
+          segments.push(match[1]);
+          i += match[1].length;
+        }
+      }
+      return segments;
+    }
+    function collectNamedDollarReferences(template) {
+      const references = [];
+      for (let i = 0; i < template.length; i++) {
+        if (template[i] !== "$" || isEscaped(template, i)) {
+          continue;
+        }
+        const remainder = template.slice(i + 1);
+        const bracedMatch = remainder.match(/^\{([a-zA-Z_][a-zA-Z0-9_]*)\}/);
+        const unbracedMatch = remainder.match(pathTemplateSegmentNameRegex);
+        const name = bracedMatch?.[1] || unbracedMatch?.[1];
+        if (name) {
+          references.push(name);
+        }
+      }
+      return references;
+    }
+    function compilePathToRegexpTemplateFromSegments(template, segments, hasItemSegments, env = []) {
+      const indexes = {};
+      segments.forEach((name, index) => {
+        indexes[name] = toSegmentDest(index);
+      });
+      hasItemSegments.forEach((name) => {
+        indexes[name] = `$${name}`;
+      });
+      for (const name of collectPathTemplateSegments(template)) {
+        if (!(name in indexes)) {
+          throw new Error(
+            `Path template references parameter ":${name}" that is not present in the source or has conditions.`
+          );
+        }
+      }
+      const routeParameters = /* @__PURE__ */ new Set([
+        ...segments.filter((name) => name !== UN_NAMED_SEGMENT),
+        ...hasItemSegments
+      ]);
+      for (const name of collectNamedDollarReferences(template)) {
+        if (routeParameters.has(name) && !env.includes(name)) {
+          throw new Error(
+            `Path template references route parameter "${name}" as \`$${name}\`. Use \`:${name}\` path-to-regexp syntax in high-level rewrites, or list "${name}" in the transform env allowlist if it is an environment variable.`
+          );
+        }
+      }
+      return safelyCompile(template, indexes, true);
+    }
+    function compilePathToRegexpTemplate2(source, template, has, env) {
+      const { segments } = sourceToRegex2(source);
+      return compilePathToRegexpTemplateFromSegments(
+        template,
+        segments,
+        collectHasSegments(has),
+        env
+      );
+    }
     function replaceSegments(segments, hasItemSegments, destination, isRedirect, internalParamNames) {
       const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
       const canNeedReplacing = destination.includes(":") && namedSegments.length > 0 || hasItemSegments.length > 0 || !isRedirect;
@@ -1489,7 +1590,8 @@ var require_schemas = __commonJS({
       redirectsSchema: () => redirectsSchema,
       rewritesSchema: () => rewritesSchema,
       routesSchema: () => routesSchema,
-      trailingSlashSchema: () => trailingSlashSchema
+      trailingSlashSchema: () => trailingSlashSchema,
+      transformsSchema: () => transformsSchema
     });
     module2.exports = __toCommonJS2(schemas_exports);
     var mitigateSchema = {
@@ -1505,6 +1607,32 @@ var require_schemas = __commonJS({
         }
       }
     };
+    var serviceNameSchema = {
+      description: "A service name identifier.",
+      type: "string",
+      minLength: 1,
+      maxLength: 64,
+      pattern: "^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$"
+    };
+    var serviceDestinationSchema = {
+      description: "A service-targeted destination that delegates routing into a named service from `services`. Identified by the presence of `service`.",
+      type: "object",
+      additionalProperties: false,
+      required: ["service"],
+      properties: {
+        type: {
+          description: "Optional explicit format marker. The destination shape is identified by the `service` property, so `type` is no longer required. When present it must be `service`.",
+          type: "string",
+          enum: ["service"]
+        },
+        service: serviceNameSchema,
+        path: {
+          description: "Routing-only path used to select a route inside the target service. It does not mutate the URL observed by user code.",
+          type: "string",
+          maxLength: 4096
+        }
+      }
+    };
     var matchableValueSchema = {
       description: "A value to match against. Can be a string (regex) or a condition operation object",
       anyOf: [
@@ -1628,18 +1756,23 @@ var require_schemas = __commonJS({
       }
     };
     var transformsSchema = {
-      description: "A list of transform rules to adjust the query parameters of a request or HTTP headers of request or response",
+      description: "A list of transform rules to adjust a request path, request query parameters, or request/response headers",
       type: "array",
       minItems: 1,
       items: {
         type: "object",
         additionalProperties: false,
-        required: ["type", "op", "target"],
+        required: ["type", "op"],
         properties: {
           type: {
             description: "The scope of the transform to apply",
             type: "string",
-            enum: ["request.headers", "request.query", "response.headers"]
+            enum: [
+              "request.headers",
+              "request.query",
+              "response.headers",
+              "request.path"
+            ]
           },
           op: {
             description: "The operation to perform on the target",
@@ -1825,10 +1958,90 @@ var require_schemas = __commonJS({
                 }
               }
             }
+          },
+          {
+            if: {
+              required: ["type"],
+              properties: {
+                type: {
+                  enum: ["request.headers", "request.query", "response.headers"]
+                }
+              }
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              required: ["target"]
+            }
+          },
+          {
+            if: {
+              required: ["type"],
+              properties: {
+                type: {
+                  enum: ["request.path"]
+                }
+              }
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              required: ["args"],
+              not: {
+                required: ["target"]
+              },
+              properties: {
+                op: {
+                  enum: ["set"]
+                },
+                args: {
+                  description: "The runtime-visible request path. Must be an origin-form path without query or fragment.",
+                  type: "string",
+                  maxLength: 2048,
+                  pattern: "^/(?!/)(?!.*[?#\\s\\x00-\\x1F\\x7F]).*$"
+                }
+              }
+            }
           }
         ]
       }
     };
+    var rewriteTransformsSchema = {
+      description: "A list of request path transforms using path-to-regexp parameters.",
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "op", "args"],
+        properties: {
+          type: {
+            description: "The request path to expose to the target runtime",
+            type: "string",
+            enum: ["request.path"]
+          },
+          op: {
+            description: "Replace the runtime-visible request path",
+            type: "string",
+            enum: ["set"]
+          },
+          args: {
+            description: "An origin-form request path. Route parameters use path-to-regexp syntax such as `/:path*`.",
+            type: "string",
+            maxLength: 2048,
+            pattern: "^/(?!/)(?!.*[?#\\s\\x00-\\x1F\\x7F]).*$"
+          },
+          env: {
+            description: "An array of environment variable names that should be replaced at runtime in the args value",
+            type: "array",
+            minItems: 1,
+            maxItems: 64,
+            items: {
+              type: "string",
+              maxLength: 256
+            }
+          }
+        }
+      }
+    };
     var routesSchema = {
       type: "array",
       description: "A list of routes objects used to rewrite paths to point towards other internal or external paths",
@@ -1853,8 +2066,10 @@ var require_schemas = __commonJS({
                 maxLength: 4096
               },
               destination: {
-                type: "string",
-                maxLength: 4096
+                anyOf: [
+                  { type: "string", maxLength: 4096 },
+                  serviceDestinationSchema
+                ]
               },
               headers: {
                 type: "object",
@@ -2003,10 +2218,10 @@ var require_schemas = __commonJS({
             maxLength: 4096
           },
           destination: {
-            description: "An absolute pathname to an existing resource or an external URL.",
-            type: "string",
-            maxLength: 4096
+            description: "An absolute pathname to an existing resource, an external URL, or a service-targeted destination object.",
+            anyOf: [{ type: "string", maxLength: 4096 }, serviceDestinationSchema]
           },
+          transforms: rewriteTransformsSchema,
           has: hasSchema,
           missing: hasSchema,
           statusCode: {
@@ -2175,6 +2390,8 @@ var require_dist3 = __commonJS({
     var src_exports2 = {};
     __export2(src_exports2, {
       appendRoutesToPhase: () => import_append.appendRoutesToPhase,
+      compilePathToRegexpTemplate: () => import_superstatic2.compilePathToRegexpTemplate,
+      convertRewrites: () => import_superstatic2.convertRewrites,
       getCleanUrls: () => import_superstatic2.getCleanUrls,
       getOwnershipGuard: () => import_service_route_ownership.getOwnershipGuard,
       getTransformedRoutes: () => getTransformedRoutes2,
@@ -2226,8 +2443,12 @@ var require_dist3 = __commonJS({
             `Route at index ${index} cannot define both \`dest\` and \`destination\`. Please use only one.`
           );
         }
-        route.dest = route.destination;
-        delete route.destination;
+        if (typeof route.destination === "string") {
+          route.dest = route.destination;
+          delete route.destination;
+        } else if (typeof route.destination.service === "string") {
+          route.destination = { ...route.destination, type: "service" };
+        }
       }
       if (route.statusCode !== void 0) {
         if (route.status !== void 0) {
@@ -2287,6 +2508,11 @@ var require_dist3 = __commonJS({
           if (regError) {
             errors.push(regError);
           }
+          if (route.destination && typeof route.destination === "object" && route.continue) {
+            errors.push(
+              `Route at index ${i} cannot define \`continue: true\` with a service \`destination\`. The service handoff is terminal.`
+            );
+          }
           const handleValue = handling[handling.length - 1];
           if (handleValue === "hit") {
             if (route.dest) {
@@ -2341,7 +2567,8 @@ var require_dist3 = __commonJS({
     function checkPatternSyntax(type, index, {
       source,
       destination,
-      has
+      has,
+      transforms
     }) {
       let sourceSegments = /* @__PURE__ */ new Set();
       const destinationSegments = /* @__PURE__ */ new Set();
@@ -2353,9 +2580,10 @@ var require_dist3 = __commonJS({
           link: "https://vercel.link/invalid-route-source-pattern"
         };
       }
-      if (destination) {
+      const destinationString = typeof destination === "string" ? destination : typeof destination?.path === "string" ? destination.path : void 0;
+      if (destinationString !== void 0) {
         try {
-          const { hostname, pathname, query } = (0, import_url.parse)(destination, true);
+          const { hostname, pathname, query } = (0, import_url.parse)(destinationString, true);
           (0, import_superstatic.sourceToRegex)(hostname || "").segments.forEach(
             (name) => destinationSegments.add(name)
           );
@@ -2380,6 +2608,19 @@ var require_dist3 = __commonJS({
           }
         }
       }
+      for (const transform of transforms || []) {
+        if (transform.type !== "request.path") {
+          continue;
+        }
+        try {
+          (0, import_superstatic.compilePathToRegexpTemplate)(source, transform.args, has, transform.env);
+        } catch (error) {
+          return {
+            message: `${type} at index ${index} has an invalid \`request.path\` transform: ${error instanceof Error ? error.message : String(error)}`,
+            link: "https://vercel.link/invalid-route-destination-segment"
+          };
+        }
+      }
       return null;
     }
     function checkRedirect(r, index) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/redwood",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs",
@@ -16,7 +16,7 @@
     "@vercel/nft": "1.10.0",
     "semver": "6.3.1",
     "ts-morph": "12.0.0",
-    "@vercel/static-config": "3.4.0"
+    "@vercel/static-config": "3.4.1"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.19",
@@ -25,8 +25,8 @@
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "vitest": "2.0.3",
-    "@vercel/build-utils": "13.28.0",
-    "@vercel/routing-utils": "6.2.0"
+    "@vercel/build-utils": "14.0.1",
+    "@vercel/routing-utils": "6.4.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",