@vercel/config 0.0.12 → 0.0.14

package/README.md

@@ -34,7 +34,7 @@ router.redirect('/old-docs', '/docs', { permanent: true });
 // Cache control
 router.cacheControl('/static/(.*)', {
   public: true,
-  maxAge: '1week',
+  maxAge: '1 week',
   immutable: true
 });
 
@@ -118,7 +118,7 @@ Set cache control headers. Options include `public`, `private`, `maxAge`, `sMaxA
 ```typescript
 router.cacheControl('/static/(.*)', {
   public: true,
-  maxAge: '1week',
+  maxAge: '1 week',
   immutable: true
 });
 ```
@@ -147,6 +147,194 @@ Set the path to a bulk redirects JSON file.
 router.bulkRedirectsPath = './bulkRedirectsDemo.json';
 ```
 
+## Conditional Routing
+
+The SDK supports powerful conditional routing using `has` and `missing` conditions. These conditions can be added to rewrites, redirects, headers, and cache control rules.
+
+### Condition Types
+
+- `header`: Match HTTP headers
+- `cookie`: Match cookies
+- `host`: Match the request host
+- `query`: Match query parameters
+- `path`: Match the request path pattern
+
+### Simple Presence Check
+
+```typescript
+// Only rewrite if x-api-key header exists
+router.rewrite('/api/(.*)', 'https://backend.com/$1', {
+  has: [
+    { type: 'header', key: 'x-api-key' }
+  ]
+});
+
+// Redirect if auth-token cookie is missing
+router.redirect('/dashboard', '/login', {
+  missing: [
+    { type: 'cookie', key: 'auth-token' }
+  ]
+});
+```
+
+### Conditional Operators
+
+The SDK supports advanced matching operators for more complex conditions:
+
+#### Equality Operators
+
+```typescript
+// Exact match using 'eq'
+router.rewrite('/api/(.*)', 'https://backend.com/$1', {
+  has: [
+    { type: 'header', key: 'x-api-version', eq: 'v2' }
+  ]
+});
+
+// Not equal using 'neq'
+router.redirect('/beta/(.*)', '/stable/$1', {
+  has: [
+    { type: 'cookie', key: 'beta-access', neq: 'granted' }
+  ]
+});
+```
+
+#### Inclusion Operators
+
+```typescript
+// Must be one of (inclusion)
+router.rewrite('/admin/(.*)', 'https://admin.backend.com/$1', {
+  has: [
+    { type: 'header', key: 'x-user-role', inc: ['admin', 'moderator', 'superuser'] }
+  ]
+});
+
+// Must NOT be one of (non-inclusion)
+router.redirect('/public/(.*)', '/private/$1', {
+  has: [
+    { type: 'header', key: 'x-user-role', ninc: ['guest', 'anonymous'] }
+  ]
+});
+```
+
+#### String Pattern Operators
+
+```typescript
+// Starts with (prefix)
+router.rewrite('/staging/(.*)', 'https://staging.backend.com/$1', {
+  has: [
+    { type: 'cookie', key: 'session', pre: 'staging-' }
+  ]
+});
+
+// Ends with (suffix)
+router.redirect('/dev/(.*)', '/development/$1', {
+  has: [
+    { type: 'header', key: 'x-environment', suf: '-dev' }
+  ]
+});
+```
+
+#### Numeric Comparison Operators
+
+```typescript
+// Greater than
+router.rewrite('/api/v3/(.*)', 'https://api-v3.backend.com/$1', {
+  has: [
+    { type: 'query', key: 'version', gt: 2 }
+  ]
+});
+
+// Greater than or equal
+router.rewrite('/premium/(.*)', '/premium-content/$1', {
+  has: [
+    { type: 'header', key: 'x-subscription-tier', gte: 3 }
+  ]
+});
+
+// Less than
+router.redirect('/legacy/(.*)', '/upgrade/$1', {
+  has: [
+    { type: 'query', key: 'api-version', lt: 2 }
+  ]
+});
+
+// Less than or equal
+router.rewrite('/free/(.*)', '/free-tier/$1', {
+  has: [
+    { type: 'header', key: 'x-plan', lte: 1 }
+  ]
+});
+```
+
+### Host and Path Matching
+
+```typescript
+// Host matching (no key required)
+router.redirect('/(.*)', 'https://www.example.com/$1', {
+  has: [
+    { type: 'host', value: 'example.com' }
+  ]
+});
+
+// Path pattern matching (no key required)
+router.rewrite('/(.*)', '/internal/$1', {
+  has: [
+    { type: 'path', value: '^/api/v[0-9]+/.*' }
+  ]
+});
+```
+
+### Multiple Conditions
+
+All conditions in a `has` or `missing` array must match (AND logic):
+
+```typescript
+router.rewrite('/secure/(.*)', 'https://secure.backend.com/$1', {
+  has: [
+    { type: 'header', key: 'x-api-key' },
+    { type: 'header', key: 'x-user-role', inc: ['admin', 'superuser'] },
+    { type: 'cookie', key: 'session', pre: 'secure-' },
+    { type: 'query', key: 'version', gte: 2 }
+  ]
+});
+```
+
+### Combining with Transforms
+
+You can combine conditions with transforms for powerful routing logic:
+
+```typescript
+router.rewrite('/api/users/:userId', 'https://backend.com/users/$1', ({ userId, env }) => ({
+  has: [
+    { type: 'header', key: 'authorization', pre: 'Bearer ' },
+    { type: 'header', key: 'x-api-version', gte: 2 }
+  ],
+  missing: [
+    { type: 'header', key: 'x-deprecated-header' }
+  ],
+  requestHeaders: {
+    'x-user-id': userId,
+    'x-internal-key': env.INTERNAL_API_KEY
+  }
+}));
+```
+
+### Available Operators
+
+| Operator | Type | Description | Example |
+|----------|------|-------------|---------|
+| `eq` | string \| number | Exact equality match | `{ eq: 'v2' }` |
+| `neq` | string | Not equal | `{ neq: 'guest' }` |
+| `inc` | string[] | Value is one of | `{ inc: ['admin', 'mod'] }` |
+| `ninc` | string[] | Value is not one of | `{ ninc: ['guest', 'banned'] }` |
+| `pre` | string | Starts with prefix | `{ pre: 'Bearer ' }` |
+| `suf` | string | Ends with suffix | `{ suf: '-dev' }` |
+| `gt` | number | Greater than | `{ gt: 2 }` |
+| `gte` | number | Greater than or equal | `{ gte: 3 }` |
+| `lt` | number | Less than | `{ lt: 5 }` |
+| `lte` | number | Less than or equal | `{ lte: 10 }` |
+
 ## Important Notes
 
 - **One config file only**: You cannot have both `vercel.ts` and `vercel.json`. The build will fail if both exist.

package/dist/cli.js

@@ -37,10 +37,9 @@ const ROUTE_BASED_EXPORTS = new Set([
     'redirects',
     'rewrites',
     'headers',
-    'crons',
     'env',
     'cacheControl',
-    '__esModule' // ES module metadata
+    '__esModule'
 ]);
 /**
  * Read the user's vercel.ts file and collect both default export and export const declarations

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { createRouter, Router } from "./router";
 export * from "./router";
+export type { VercelConfig } from "./types";

package/dist/router.d.ts

@@ -87,14 +87,75 @@ export interface CacheOptions {
  * - 'cookie': Match if a specific cookie is present (or missing).
  * - 'host':   Match if the incoming host matches a given pattern.
  * - 'query':  Match if a query parameter is present (or missing).
+ * - 'path':   Match if the path matches a given pattern.
  */
-export type ConditionType = 'header' | 'cookie' | 'host' | 'query';
+export type ConditionType = 'header' | 'cookie' | 'host' | 'query' | 'path';
 /**
- * Used to define "has" or "missing" conditions.
+ * Conditional matching operators for has/missing conditions.
+ * These can be used with the value field to perform advanced matching.
  */
-export interface Condition {
+export interface ConditionOperators {
+    /** Check equality on a value (exact match) */
+    eq?: string | number;
+    /** Check inequality on a value (not equal) */
+    neq?: string;
+    /** Check inclusion in an array of values (value is one of) */
+    inc?: string[];
+    /** Check non-inclusion in an array of values (value is not one of) */
+    ninc?: string[];
+    /** Check if value starts with a prefix */
+    pre?: string;
+    /** Check if value ends with a suffix */
+    suf?: string;
+    /** Check if value is greater than (numeric comparison) */
+    gt?: number;
+    /** Check if value is greater than or equal to */
+    gte?: number;
+    /** Check if value is less than (numeric comparison) */
+    lt?: number;
+    /** Check if value is less than or equal to */
+    lte?: number;
+}
+/**
+ * Used to define "has" or "missing" conditions with advanced matching operators.
+ *
+ * @example
+ * // Simple header presence check
+ * { type: 'header', key: 'x-api-key' }
+ *
+ * @example
+ * // Header with exact value match
+ * { type: 'header', key: 'x-api-version', value: 'v2' }
+ *
+ * @example
+ * // Header with conditional operators
+ * { type: 'header', key: 'x-user-role', inc: ['admin', 'moderator'] }
+ *
+ * @example
+ * // Cookie with prefix matching
+ * { type: 'cookie', key: 'session', pre: 'prod-' }
+ *
+ * @example
+ * // Host matching
+ * { type: 'host', value: 'api.example.com' }
+ *
+ * @example
+ * // Query parameter with numeric comparison
+ * { type: 'query', key: 'version', gte: 2 }
+ *
+ * @example
+ * // Path pattern matching
+ * { type: 'path', value: '^/api/v[0-9]+/.*' }
+ */
+export interface Condition extends ConditionOperators {
     type: ConditionType;
-    key: string;
+    /** The key to match. Not used for 'host' or 'path' types. */
+    key?: string;
+    /**
+     * Simple string/regex pattern to match against.
+     * For 'host' and 'path' types, this is the only matching option.
+     * For other types, you can use value OR the conditional operators (eq, neq, etc).
+     */
     value?: string;
 }
 /**
@@ -188,6 +249,8 @@ export interface Route {
     src: string;
     /** Optional destination for rewrite/redirect */
     dest?: string;
+    /** Array of HTTP methods to match. If not provided, matches all methods */
+    methods?: string[];
     /** Array of transforms to apply */
     transforms?: Transform[];
     /** Optional conditions that must be present */
@@ -196,7 +259,7 @@ export interface Route {
     missing?: Condition[];
     /** If true, this is a redirect (status defaults to 308 or specified) */
     redirect?: boolean;
-    /** Status code for redirects */
+    /** Status code for the response */
     status?: number;
     /** Headers to set (alternative to using transforms) */
     headers?: Record<string, string>;
@@ -359,6 +422,10 @@ export interface RewriteRule {
      */
     source: string;
     destination: string;
+    /** Array of HTTP methods to match. If not provided, matches all methods */
+    methods?: string[];
+    /** Status code for the response */
+    status?: number;
     has?: Condition[];
     missing?: Condition[];
     /** Internal field: transforms generated from requestHeaders/responseHeaders/requestQuery */
@@ -512,6 +579,8 @@ export declare class Router {
      *    });
      */
     rewrite(source: string, destination: string, optionsOrCallback?: {
+        methods?: string[];
+        status?: number;
         has?: Condition[];
         missing?: Condition[];
         requestHeaders?: Record<string, string | string[]>;
@@ -526,6 +595,8 @@ export declare class Router {
     } | ((params: Record<string, string> & {
         env: any;
     }) => {
+        methods?: string[];
+        status?: number;
         has?: Condition[];
         missing?: Condition[];
         requestHeaders?: Record<string, string | string[]>;

package/dist/router.js

@@ -305,7 +305,7 @@ class Router {
             options = optionsOrCallback;
         }
         // Extract transform options
-        const { requestHeaders, responseHeaders, requestQuery, appendRequestHeaders, appendResponseHeaders, appendRequestQuery, deleteRequestHeaders, deleteResponseHeaders, deleteRequestQuery, has, missing } = options || {};
+        const { methods, status, requestHeaders, responseHeaders, requestQuery, appendRequestHeaders, appendResponseHeaders, appendRequestQuery, deleteRequestHeaders, deleteResponseHeaders, deleteRequestQuery, has, missing } = options || {};
         const transformOpts = {
             requestHeaders,
             responseHeaders,
@@ -327,6 +327,8 @@ class Router {
         this.rewriteRules.push({
             source,
             destination,
+            ...(methods && { methods }),
+            ...(status && { status }),
             has,
             missing,
             transforms,
@@ -410,7 +412,7 @@ class Router {
             options = optionsOrCallback;
         }
         // Extract transform options
-        const { requestHeaders, responseHeaders, requestQuery, appendRequestHeaders, appendResponseHeaders, appendRequestQuery, deleteRequestHeaders, deleteResponseHeaders, deleteRequestQuery, permanent, statusCode, has, missing, } = options || {};
+        const { methods, requestHeaders, responseHeaders, requestQuery, appendRequestHeaders, appendResponseHeaders, appendRequestQuery, deleteRequestHeaders, deleteResponseHeaders, deleteRequestQuery, permanent, statusCode, has, missing, } = options || {};
         // If transforms are provided, create a route instead of a redirect
         const hasTransforms = requestHeaders || responseHeaders || requestQuery ||
             appendRequestHeaders || appendResponseHeaders || appendRequestQuery ||
@@ -431,6 +433,7 @@ class Router {
             this.routeRules.push({
                 src: source,
                 dest: destination,
+                ...(methods && { methods }),
                 transforms,
                 redirect: true,
                 status: statusCode || (permanent ? 308 : 307),
@@ -580,16 +583,22 @@ class Router {
      * so that Vercel can pick it up.
      */
     getConfig() {
-        // Separate rewrites into those with and without transforms
-        const rewritesWithoutTransforms = this.rewriteRules.filter((r) => !r.transforms);
-        const rewritesWithTransforms = this.rewriteRules.filter((r) => r.transforms);
-        // Convert rewrites with transforms to routes
-        const routesFromRewrites = rewritesWithTransforms.map((rewrite) => {
+        // Separate rewrites into those that need to be routes vs. legacy rewrites
+        // Routes are needed for: transforms, methods, or custom status
+        const rewritesNeedingRoutes = this.rewriteRules.filter((r) => r.transforms || r.methods || r.status);
+        const legacyRewrites = this.rewriteRules.filter((r) => !r.transforms && !r.methods && !r.status);
+        // Convert rewrites to routes
+        const routesFromRewrites = rewritesNeedingRoutes.map((rewrite) => {
             const route = {
                 src: rewrite.source,
                 dest: rewrite.destination,
-                transforms: rewrite.transforms,
             };
+            if (rewrite.transforms)
+                route.transforms = rewrite.transforms;
+            if (rewrite.methods)
+                route.methods = rewrite.methods;
+            if (rewrite.status)
+                route.status = rewrite.status;
             if (rewrite.has)
                 route.has = rewrite.has;
             if (rewrite.missing)
@@ -598,11 +607,67 @@ class Router {
         });
         // Combine with existing routes
         const allRoutes = [...routesFromRewrites, ...this.routeRules];
-        // If routes exist, only return routes (not the legacy fields)
+        // If routes exist, convert everything to routes format
+        // Vercel doesn't allow mixing routes with redirects, rewrites, headers, cleanUrls, or trailingSlash
         if (allRoutes.length > 0) {
+            // Convert standalone redirects to routes
+            const routesFromRedirects = this.redirectRules.map(redirectRule => {
+                const route = {
+                    src: redirectRule.source,
+                    dest: redirectRule.destination,
+                    redirect: true,
+                    status: redirectRule.statusCode || (redirectRule.permanent ? 308 : 307),
+                };
+                if (redirectRule.has)
+                    route.has = redirectRule.has;
+                if (redirectRule.missing)
+                    route.missing = redirectRule.missing;
+                return route;
+            });
+            // Convert legacy rewrites (without transforms) to routes
+            const routesFromLegacyRewrites = legacyRewrites.map(rewrite => {
+                const route = {
+                    src: rewrite.source,
+                    dest: rewrite.destination,
+                };
+                if (rewrite.has)
+                    route.has = rewrite.has;
+                if (rewrite.missing)
+                    route.missing = rewrite.missing;
+                return route;
+            });
+            // Convert standalone headers to routes (except rewrite caching headers)
+            const routesFromHeaders = this.headerRules
+                .filter(rule => {
+                // Exclude rewrite caching headers (they're automatically added for rewrites)
+                const isCachingHeader = rule.headers.length === 1 &&
+                    rule.headers[0].key === 'x-vercel-enable-rewrite-caching';
+                return !isCachingHeader;
+            })
+                .map(headerRule => {
+                const transforms = headerRule.headers.map(header => ({
+                    type: 'response.headers',
+                    op: 'set',
+                    target: { key: header.key },
+                    args: header.value,
+                }));
+                const route = {
+                    src: headerRule.source,
+                    transforms,
+                };
+                if (headerRule.has)
+                    route.has = headerRule.has;
+                if (headerRule.missing)
+                    route.missing = headerRule.missing;
+                return route;
+            });
+            // Combine all routes: redirects, legacy rewrites, rewrites with transforms, explicit routes, and headers as routes
+            const combinedRoutes = [...routesFromRedirects, ...routesFromLegacyRewrites, ...routesFromRewrites, ...this.routeRules, ...routesFromHeaders];
             const config = {
-                routes: allRoutes,
+                routes: combinedRoutes,
             };
+            // NOTE: crons are now handled via export const crons in vercel.ts
+            // They are no longer included in router.getConfig()
             // Only include optional fields if they're explicitly set
             if (this.bulkRedirectsPathConfig !== undefined) {
                 config.bulkRedirectsPath = this.bulkRedirectsPathConfig;
@@ -619,10 +684,10 @@ class Router {
         const config = {
             redirects: this.redirectRules,
             headers: this.headerRules,
-            rewrites: rewritesWithoutTransforms,
+            rewrites: legacyRewrites,
             cleanUrls: this.cleanUrlsConfig,
             trailingSlash: this.trailingSlashConfig,
-            crons: this.cronRules,
+            // NOTE: crons are now handled via export const crons in vercel.ts
         };
         // Only include optional fields if they're explicitly set
         if (this.bulkRedirectsPathConfig !== undefined) {

package/dist/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Vercel configuration type that mirrors the vercel.json schema
+ * https://openapi.vercel.sh/vercel.json
+ */
+export type Framework = 'blitzjs' | 'nextjs' | 'gatsby' | 'remix' | 'react-router' | 'astro' | 'hexo' | 'eleventy' | 'docusaurus-2' | 'docusaurus' | 'preact' | 'solidstart-1' | 'solidstart' | 'dojo' | 'ember' | 'vue' | 'scully' | 'ionic-angular' | 'angular' | 'polymer' | 'svelte' | 'sveltekit' | 'sveltekit-1' | 'ionic-react' | 'create-react-app' | 'gridsome' | 'umijs' | 'sapper' | 'saber' | 'stencil' | 'nuxtjs' | 'redwoodjs' | 'hugo' | 'jekyll' | 'brunch' | 'middleman' | 'zola' | 'hydrogen' | 'vite' | 'tanstack-start' | 'vitepress' | 'vuepress' | 'parcel' | 'fastapi' | 'flask' | 'fasthtml' | 'sanity-v3' | 'sanity' | 'storybook' | 'nitro' | 'hono' | 'express' | 'h3' | 'nestjs' | 'elysia' | 'fastify' | 'xmcp' | null;
+export interface CronJob {
+    schedule: string;
+    path: string;
+}
+export interface FunctionConfig {
+    excludeFiles?: string;
+    includeFiles?: string;
+    maxDuration?: number;
+    memory?: number;
+    runtime?: string;
+    supportsCancellation?: boolean;
+    experimentalTriggers?: Array<{
+        type: 'queue/v1beta';
+        topic: string;
+        consumer: string;
+        maxDeliveries?: number;
+        retryAfterSeconds?: number;
+        initialDelaySeconds?: number;
+    }>;
+}
+export interface GitDeploymentConfig {
+    [branch: string]: boolean;
+}
+export interface GitConfig {
+    deploymentEnabled?: boolean | GitDeploymentConfig;
+}
+export interface GithubConfig {
+    enabled?: boolean;
+    autoAlias?: boolean;
+    autoJobCancelation?: boolean;
+}
+export interface Header {
+    key: string;
+    value: string;
+}
+export interface HeaderRule {
+    source: string;
+    headers: Header[];
+}
+/**
+ * Route represents a single routing rule that can be a redirect, rewrite, or header rule
+ * Matches the output of router.redirect(), router.rewrite(), router.header(), etc.
+ */
+export type RouteType = any;
+export interface WildcardDomain {
+    domain: string;
+    value: string;
+}
+export interface VercelConfig {
+    /**
+     * Aliases that will get assigned when the deployment is `READY` and the target is `production`.
+     */
+    alias?: string | string[];
+    /**
+     * When set to `true`, all HTML files and Serverless Functions will have their extension removed.
+     */
+    cleanUrls?: boolean;
+    /**
+     * An array of cron jobs that should be created for production Deployments.
+     */
+    crons?: CronJob[];
+    /**
+     * An object containing the deployment's environment variables.
+     */
+    env?: Record<string, string>;
+    /**
+     * An array of the passive regions the deployment's Serverless Functions should be deployed to.
+     */
+    passiveRegions?: string[];
+    /**
+     * Same as passiveRegions. An array of passive regions for failover.
+     */
+    functionFailoverRegions?: string[];
+    /**
+     * An object describing custom options for Serverless Functions.
+     */
+    functions?: Record<string, FunctionConfig>;
+    /**
+     * Git-related configuration.
+     */
+    git?: GitConfig;
+    /**
+     * GitHub-related configuration.
+     */
+    github?: GithubConfig;
+    /**
+     * HTTP headers configuration.
+     * Can use router.header() and router.cacheControl() helpers.
+     */
+    headers?: RouteType[];
+    /**
+     * HTTP redirects configuration.
+     * Can use router.redirect() helper.
+     */
+    redirects?: RouteType[];
+    /**
+     * HTTP rewrites configuration.
+     * Can use router.rewrite() helper.
+     */
+    rewrites?: RouteType[];
+    /**
+     * Wildcard domain configuration.
+     */
+    wildcard?: WildcardDomain[];
+    /**
+     * The build command for this project. When `null`, automatically detected.
+     */
+    buildCommand?: string | null;
+    /**
+     * The ignore command for this project.
+     */
+    ignoreCommand?: string | null;
+    /**
+     * The dev command for this project. When `null`, automatically detected.
+     */
+    devCommand?: string | null;
+    /**
+     * The framework being used. When `null`, no framework is selected.
+     */
+    framework?: Framework;
+    /**
+     * The install command for this project. When `null`, automatically detected.
+     */
+    installCommand?: string | null;
+    /**
+     * The output directory of the project. When `null`, automatically detected.
+     */
+    outputDirectory?: string | null;
+    /**
+     * When `false`, visiting a path that ends with a forward slash will redirect to the path without the trailing slash.
+     */
+    trailingSlash?: boolean;
+    /**
+     * An array of projectIds to associate with the current project.
+     */
+    relatedProjects?: string[];
+    /**
+     * Enables Fluid compute for the project.
+     */
+    fluid?: boolean;
+    /**
+     * Enables Bun for the project and specifies the version to use.
+     */
+    bunVersion?: string;
+    /**
+     * Node.js version for this project.
+     */
+    nodeVersion?: string;
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Vercel configuration type that mirrors the vercel.json schema
+ * https://openapi.vercel.sh/vercel.json
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/config",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "A TypeScript SDK for programmatically generating Vercel configuration files",
   "bugs": {
     "url": "https://github.com/vercel/router-sdk/issues"