@vercel/gatsby-plugin-vercel-builder 2.2.19 → 2.2.20

package/dist/index.js

@@ -814,6 +814,7 @@ var require_superstatic = __commonJS({
     var superstatic_exports = {};
     __export2(superstatic_exports, {
       collectHasSegments: () => collectHasSegments,
+      compilePathToRegexpTemplate: () => compilePathToRegexpTemplate2,
       convertCleanUrls: () => convertCleanUrls,
       convertHeaders: () => convertHeaders,
       convertRedirects: () => convertRedirects,
@@ -957,6 +958,22 @@ var require_superstatic = __commonJS({
             }
             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;
           }
@@ -1097,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;
@@ -1498,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 = {
@@ -1663,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",
@@ -1860,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",
@@ -2043,6 +2221,7 @@ var require_schemas = __commonJS({
             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: {
@@ -2211,6 +2390,7 @@ var require_dist3 = __commonJS({
     var src_exports2 = {};
     __export2(src_exports2, {
       appendRoutesToPhase: () => import_append.appendRoutesToPhase,
+      compilePathToRegexpTemplate: () => import_superstatic2.compilePathToRegexpTemplate,
       getCleanUrls: () => import_superstatic2.getCleanUrls,
       getOwnershipGuard: () => import_service_route_ownership.getOwnershipGuard,
       getTransformedRoutes: () => getTransformedRoutes2,
@@ -2384,7 +2564,8 @@ var require_dist3 = __commonJS({
     function checkPatternSyntax(type, index, {
       source,
       destination,
-      has
+      has,
+      transforms
     }) {
       let sourceSegments = /* @__PURE__ */ new Set();
       const destinationSegments = /* @__PURE__ */ new Set();
@@ -2424,6 +2605,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/gatsby-plugin-vercel-builder",
-  "version": "2.2.19",
+  "version": "2.2.20",
   "main": "dist/index.js",
   "files": [
     "dist",
@@ -17,7 +17,7 @@
     "esbuild": "0.27.0",
     "etag": "1.8.1",
     "fs-extra": "11.1.0",
-    "@vercel/build-utils": "13.30.0"
+    "@vercel/build-utils": "13.31.0"
   },
   "devDependencies": {
     "@types/etag": "1.8.0",
@@ -25,7 +25,7 @@
     "@types/node": "20.11.0",
     "@types/react": "18.0.26",
     "vitest": "2.0.3",
-    "@vercel/routing-utils": "6.3.0"
+    "@vercel/routing-utils": "6.3.1"
   },
   "license": "Apache-2.0",
   "scripts": {