@vercel/routing-utils 5.0.7 → 5.0.8

package/dist/schemas.d.ts

@@ -691,6 +691,176 @@ export declare const routesSchema: {
                         };
                     };
                 };
+                readonly transforms: {
+                    readonly description: "A list of transform rules to adjust the query parameters of a request or HTTP headers of request or response";
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["type", "op", "target"];
+                        readonly properties: {
+                            readonly type: {
+                                readonly description: "The scope of the transform to apply";
+                                readonly type: "string";
+                                readonly enum: readonly ["request.headers", "request.query", "response.headers"];
+                            };
+                            readonly op: {
+                                readonly description: "The operation to perform on the target";
+                                readonly type: "string";
+                                readonly enum: readonly ["append", "set", "delete"];
+                            };
+                            readonly target: {
+                                readonly description: "The target of the transform";
+                                readonly type: "object";
+                                readonly required: readonly ["key"];
+                                readonly properties: {
+                                    readonly key: {
+                                        readonly description: "A value to match against. Can be a string or a condition operation object (without regex support)";
+                                        readonly anyOf: readonly [{
+                                            readonly description: "A valid header name (letters, numbers, hyphens, underscores)";
+                                            readonly type: "string";
+                                            readonly maxLength: 4096;
+                                        }, {
+                                            readonly description: "A condition operation object";
+                                            readonly type: "object";
+                                            readonly additionalProperties: false;
+                                            readonly minProperties: 1;
+                                            readonly properties: {
+                                                readonly eq: {
+                                                    readonly description: "Equal to";
+                                                    readonly anyOf: readonly [{
+                                                        readonly type: "string";
+                                                        readonly maxLength: 4096;
+                                                    }, {
+                                                        readonly type: "number";
+                                                    }];
+                                                };
+                                                readonly neq: {
+                                                    readonly description: "Not equal";
+                                                    readonly type: "string";
+                                                    readonly maxLength: 4096;
+                                                };
+                                                readonly inc: {
+                                                    readonly description: "In array";
+                                                    readonly type: "array";
+                                                    readonly items: {
+                                                        readonly type: "string";
+                                                        readonly maxLength: 4096;
+                                                    };
+                                                };
+                                                readonly ninc: {
+                                                    readonly description: "Not in array";
+                                                    readonly type: "array";
+                                                    readonly items: {
+                                                        readonly type: "string";
+                                                        readonly maxLength: 4096;
+                                                    };
+                                                };
+                                                readonly pre: {
+                                                    readonly description: "Starts with";
+                                                    readonly type: "string";
+                                                    readonly maxLength: 4096;
+                                                };
+                                                readonly suf: {
+                                                    readonly description: "Ends with";
+                                                    readonly type: "string";
+                                                    readonly maxLength: 4096;
+                                                };
+                                                readonly gt: {
+                                                    readonly description: "Greater than";
+                                                    readonly type: "number";
+                                                };
+                                                readonly gte: {
+                                                    readonly description: "Greater than or equal to";
+                                                    readonly type: "number";
+                                                };
+                                                readonly lt: {
+                                                    readonly description: "Less than";
+                                                    readonly type: "number";
+                                                };
+                                                readonly lte: {
+                                                    readonly description: "Less than or equal to";
+                                                    readonly type: "number";
+                                                };
+                                            };
+                                        }];
+                                    };
+                                };
+                            };
+                            readonly args: {
+                                readonly description: "The arguments to the operation";
+                                readonly anyOf: readonly [{
+                                    readonly type: "string";
+                                    readonly maxLength: 4096;
+                                }, {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly maxLength: 4096;
+                                    };
+                                }];
+                            };
+                        };
+                        readonly allOf: readonly [{
+                            readonly if: {
+                                readonly properties: {
+                                    readonly op: {
+                                        readonly enum: readonly ["append", "set"];
+                                    };
+                                };
+                            };
+                            readonly then: {
+                                readonly required: readonly ["args"];
+                            };
+                        }, {
+                            readonly if: {
+                                readonly allOf: readonly [{
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly enum: readonly ["request.headers", "response.headers"];
+                                        };
+                                    };
+                                }, {
+                                    readonly properties: {
+                                        readonly op: {
+                                            readonly enum: readonly ["set", "append"];
+                                        };
+                                    };
+                                }];
+                            };
+                            readonly then: {
+                                readonly properties: {
+                                    readonly target: {
+                                        readonly properties: {
+                                            readonly key: {
+                                                readonly if: {
+                                                    readonly type: "string";
+                                                };
+                                                readonly then: {
+                                                    readonly pattern: "^[a-zA-Z0-9_-]+$";
+                                                };
+                                            };
+                                        };
+                                    };
+                                    readonly args: {
+                                        readonly anyOf: readonly [{
+                                            readonly type: "string";
+                                            readonly pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$";
+                                        }, {
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "string";
+                                                readonly pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$";
+                                            };
+                                        }];
+                                    };
+                                };
+                            };
+                        }];
+                    };
+                };
             };
         }, {
             readonly type: "object";

package/dist/schemas.js

@@ -162,6 +162,195 @@ const hasSchema = {
     ]
   }
 };
+const transformsSchema = {
+  description: "A list of transform rules to adjust the query parameters of a request or HTTP headers of request or response",
+  type: "array",
+  minItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["type", "op", "target"],
+    properties: {
+      type: {
+        description: "The scope of the transform to apply",
+        type: "string",
+        enum: ["request.headers", "request.query", "response.headers"]
+      },
+      op: {
+        description: "The operation to perform on the target",
+        type: "string",
+        enum: ["append", "set", "delete"]
+      },
+      target: {
+        description: "The target of the transform",
+        type: "object",
+        required: ["key"],
+        properties: {
+          // re is not supported for transforms. Once supported, replace target.key with matchableValueSchema
+          key: {
+            description: "A value to match against. Can be a string or a condition operation object (without regex support)",
+            anyOf: [
+              {
+                description: "A valid header name (letters, numbers, hyphens, underscores)",
+                type: "string",
+                maxLength: 4096
+              },
+              {
+                description: "A condition operation object",
+                type: "object",
+                additionalProperties: false,
+                minProperties: 1,
+                properties: {
+                  eq: {
+                    description: "Equal to",
+                    anyOf: [
+                      {
+                        type: "string",
+                        maxLength: 4096
+                      },
+                      {
+                        type: "number"
+                      }
+                    ]
+                  },
+                  neq: {
+                    description: "Not equal",
+                    type: "string",
+                    maxLength: 4096
+                  },
+                  inc: {
+                    description: "In array",
+                    type: "array",
+                    items: {
+                      type: "string",
+                      maxLength: 4096
+                    }
+                  },
+                  ninc: {
+                    description: "Not in array",
+                    type: "array",
+                    items: {
+                      type: "string",
+                      maxLength: 4096
+                    }
+                  },
+                  pre: {
+                    description: "Starts with",
+                    type: "string",
+                    maxLength: 4096
+                  },
+                  suf: {
+                    description: "Ends with",
+                    type: "string",
+                    maxLength: 4096
+                  },
+                  gt: {
+                    description: "Greater than",
+                    type: "number"
+                  },
+                  gte: {
+                    description: "Greater than or equal to",
+                    type: "number"
+                  },
+                  lt: {
+                    description: "Less than",
+                    type: "number"
+                  },
+                  lte: {
+                    description: "Less than or equal to",
+                    type: "number"
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      args: {
+        description: "The arguments to the operation",
+        anyOf: [
+          {
+            type: "string",
+            maxLength: 4096
+          },
+          {
+            type: "array",
+            minItems: 1,
+            items: {
+              type: "string",
+              maxLength: 4096
+            }
+          }
+        ]
+      }
+    },
+    allOf: [
+      {
+        if: {
+          properties: {
+            op: {
+              enum: ["append", "set"]
+            }
+          }
+        },
+        then: {
+          required: ["args"]
+        }
+      },
+      {
+        if: {
+          allOf: [
+            {
+              properties: {
+                type: {
+                  enum: ["request.headers", "response.headers"]
+                }
+              }
+            },
+            {
+              properties: {
+                op: {
+                  enum: ["set", "append"]
+                }
+              }
+            }
+          ]
+        },
+        then: {
+          properties: {
+            target: {
+              properties: {
+                key: {
+                  if: {
+                    type: "string"
+                  },
+                  then: {
+                    pattern: "^[a-zA-Z0-9_-]+$"
+                  }
+                }
+              }
+            },
+            args: {
+              anyOf: [
+                {
+                  type: "string",
+                  pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$"
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$"
+                  }
+                }
+              ]
+            }
+          }
+        }
+      }
+    ]
+  }
+};
 const routesSchema = {
   type: "array",
   maxItems: 2048,
@@ -274,7 +463,8 @@ const routesSchema = {
           },
           has: hasSchema,
           missing: hasSchema,
-          mitigate: mitigateSchema
+          mitigate: mitigateSchema,
+          transforms: transformsSchema
         }
       },
       {

package/dist/types.d.ts

@@ -29,6 +29,25 @@ export type HasField = Array<{
     key: string;
     value?: MatchableValue;
 }>;
+type Transform = {
+    type: 'request.headers' | 'request.query' | 'response.headers';
+    op: 'append' | 'set' | 'delete';
+    target: {
+        key: string | {
+            eq?: string | number;
+            neq?: string;
+            inc?: string[];
+            ninc?: string[];
+            pre?: string;
+            suf?: string;
+            gt?: number;
+            gte?: number;
+            lt?: number;
+            lte?: number;
+        };
+    };
+    args?: string | string[];
+};
 export type RouteWithSrc = {
     src: string;
     dest?: string;
@@ -47,6 +66,7 @@ export type RouteWithSrc = {
     mitigate?: {
         action: MitigateAction;
     };
+    transforms?: Transform[];
     locale?: {
         redirect?: Record<string, string>;
         cookie?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/routing-utils",
-  "version": "5.0.7",
+  "version": "5.0.8",
   "description": "Vercel routing utilities",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",