@vercel/config 0.0.14 → 0.0.16

package/dist/router.js

@@ -111,187 +111,35 @@ class Router {
         });
         return { proxy, accessedVars };
     }
+    // Deprecated: extractEnvVars method no longer needed after refactor
     /**
-     * Helper to extract environment variable names from a string or string array.
-     * Environment variables are identified by the pattern $VAR_NAME where VAR_NAME
-     * is typically uppercase with underscores (e.g., $API_KEY, $BEARER_TOKEN).
-     */
-    extractEnvVars(args) {
-        const envVars = new Set();
-        const values = Array.isArray(args) ? args : [args];
-        for (const value of values) {
-            const matches = value.match(/\$([A-Z][A-Z0-9_]*)/g);
-            if (matches) {
-                for (const match of matches) {
-                    envVars.add(match.substring(1));
-                }
-            }
-        }
-        return Array.from(envVars);
-    }
-    /**
+     * @deprecated No longer used after refactor to return schema objects directly
      * Internal helper to convert TransformOptions to Transform array
      * @param options Transform options to convert
      * @param trackedEnvVars Optional set of environment variables that were accessed via the env proxy
      */
-    transformOptionsToTransforms(options, trackedEnvVars) {
-        const transforms = [];
-        // Helper to get env vars for a value
-        const getEnvVars = (value) => {
-            if (trackedEnvVars) {
-                return Array.from(trackedEnvVars).filter(envVar => {
-                    const valueStr = Array.isArray(value) ? value.join(' ') : value;
-                    return valueStr.includes(`$${envVar}`);
-                });
-            }
-            return this.extractEnvVars(value);
-        };
-        // SET operations
-        // Convert requestHeaders (set)
-        if (options.requestHeaders) {
-            for (const [key, value] of Object.entries(options.requestHeaders)) {
-                const envVars = getEnvVars(value);
-                transforms.push({
-                    type: 'request.headers',
-                    op: 'set',
-                    target: { key },
-                    args: value,
-                    ...(envVars.length > 0 && { env: envVars }),
-                });
-            }
-        }
-        // Convert responseHeaders (set)
-        if (options.responseHeaders) {
-            for (const [key, value] of Object.entries(options.responseHeaders)) {
-                const envVars = getEnvVars(value);
-                transforms.push({
-                    type: 'response.headers',
-                    op: 'set',
-                    target: { key },
-                    args: value,
-                    ...(envVars.length > 0 && { env: envVars }),
-                });
-            }
-        }
-        // Convert requestQuery (set)
-        if (options.requestQuery) {
-            for (const [key, value] of Object.entries(options.requestQuery)) {
-                const envVars = getEnvVars(value);
-                transforms.push({
-                    type: 'request.query',
-                    op: 'set',
-                    target: { key },
-                    args: value,
-                    ...(envVars.length > 0 && { env: envVars }),
-                });
-            }
-        }
-        // APPEND operations
-        // Convert appendRequestHeaders
-        if (options.appendRequestHeaders) {
-            for (const [key, value] of Object.entries(options.appendRequestHeaders)) {
-                const envVars = getEnvVars(value);
-                transforms.push({
-                    type: 'request.headers',
-                    op: 'append',
-                    target: { key },
-                    args: value,
-                    ...(envVars.length > 0 && { env: envVars }),
-                });
-            }
-        }
-        // Convert appendResponseHeaders
-        if (options.appendResponseHeaders) {
-            for (const [key, value] of Object.entries(options.appendResponseHeaders)) {
-                const envVars = getEnvVars(value);
-                transforms.push({
-                    type: 'response.headers',
-                    op: 'append',
-                    target: { key },
-                    args: value,
-                    ...(envVars.length > 0 && { env: envVars }),
-                });
-            }
-        }
-        // Convert appendRequestQuery
-        if (options.appendRequestQuery) {
-            for (const [key, value] of Object.entries(options.appendRequestQuery)) {
-                const envVars = getEnvVars(value);
-                transforms.push({
-                    type: 'request.query',
-                    op: 'append',
-                    target: { key },
-                    args: value,
-                    ...(envVars.length > 0 && { env: envVars }),
-                });
-            }
-        }
-        // DELETE operations
-        // Convert deleteRequestHeaders
-        if (options.deleteRequestHeaders) {
-            for (const key of options.deleteRequestHeaders) {
-                transforms.push({
-                    type: 'request.headers',
-                    op: 'delete',
-                    target: { key },
-                });
-            }
-        }
-        // Convert deleteResponseHeaders
-        if (options.deleteResponseHeaders) {
-            for (const key of options.deleteResponseHeaders) {
-                transforms.push({
-                    type: 'response.headers',
-                    op: 'delete',
-                    target: { key },
-                });
-            }
-        }
-        // Convert deleteRequestQuery
-        if (options.deleteRequestQuery) {
-            for (const key of options.deleteRequestQuery) {
-                transforms.push({
-                    type: 'request.query',
-                    op: 'delete',
-                    target: { key },
-                });
-            }
-        }
-        return transforms;
-    }
+    // Deprecated: transformOptionsToTransforms method removed after refactor
     /**
-     * Adds a single rewrite rule (synchronous).
-     * Automatically enables rewrite caching by adding the x-vercel-enable-rewrite-caching header.
+     * Creates a rewrite rule. Returns either a Rewrite object (simple case) or Route with transforms.
      *
      * @example
      *    // Simple rewrite
      *    router.rewrite('/api/(.*)', 'https://old-on-prem.com/$1')
      *
-     *    // With transforms using callback
+     *    // With transforms
      *    router.rewrite('/users/:userId', 'https://api.example.com/users/$1', ({userId, env}) => ({
-     *      requestHeaders: {
-     *        'x-user-id': userId,
-     *        'authorization': `Bearer ${env.API_TOKEN}`
-     *      }
-     *    }));
-     *
-     *    // With transforms using object (legacy)
-     *    router.rewrite('/users/:userId', 'https://api.example.com/users/$1', {
-     *      requestHeaders: {
-     *        'x-user-id': param('userId')
-     *      }
-     *    });
+     *      requestHeaders: { 'x-user-id': userId }
+     *    }))
+     * @internal Can return Route with transforms internally
      */
     rewrite(source, destination, optionsOrCallback) {
         this.validateSourcePattern(source);
         (0, validation_1.validateCaptureGroupReferences)(source, destination);
         let options;
-        let trackedEnvVars;
         // Handle callback syntax
         if (typeof optionsOrCallback === 'function') {
             const pathParams = this.extractPathParams(source);
-            const { proxy: envProxy, accessedVars } = this.createEnvProxy();
-            trackedEnvVars = accessedVars;
+            const { proxy: envProxy } = this.createEnvProxy();
             // Create params object with path parameters as $paramName
             const paramsObj = {};
             for (const param of pathParams) {
@@ -304,101 +152,86 @@ class Router {
         else {
             options = optionsOrCallback;
         }
-        // Extract transform options
-        const { methods, status, requestHeaders, responseHeaders, requestQuery, appendRequestHeaders, appendResponseHeaders, appendRequestQuery, deleteRequestHeaders, deleteResponseHeaders, deleteRequestQuery, has, missing } = options || {};
-        const transformOpts = {
-            requestHeaders,
-            responseHeaders,
-            requestQuery,
-            appendRequestHeaders,
-            appendResponseHeaders,
-            appendRequestQuery,
-            deleteRequestHeaders,
-            deleteResponseHeaders,
-            deleteRequestQuery,
-        };
-        // Convert to transforms if any transform options provided
-        const hasTransforms = requestHeaders || responseHeaders || requestQuery ||
-            appendRequestHeaders || appendResponseHeaders || appendRequestQuery ||
-            deleteRequestHeaders || deleteResponseHeaders || deleteRequestQuery;
-        const transforms = hasTransforms
-            ? this.transformOptionsToTransforms(transformOpts, trackedEnvVars)
-            : undefined;
-        this.rewriteRules.push({
+        const { has, missing, requestHeaders, responseHeaders, requestQuery } = options || {};
+        // Check if any transforms were provided
+        const hasTransforms = requestHeaders || responseHeaders || requestQuery;
+        if (hasTransforms) {
+            // Build a Route object with transforms
+            const transforms = [];
+            if (requestHeaders) {
+                for (const [key, value] of Object.entries(requestHeaders)) {
+                    transforms.push({
+                        type: 'request.headers',
+                        op: 'set',
+                        target: { key },
+                        args: value,
+                    });
+                }
+            }
+            if (responseHeaders) {
+                for (const [key, value] of Object.entries(responseHeaders)) {
+                    transforms.push({
+                        type: 'response.headers',
+                        op: 'set',
+                        target: { key },
+                        args: value,
+                    });
+                }
+            }
+            if (requestQuery) {
+                for (const [key, value] of Object.entries(requestQuery)) {
+                    transforms.push({
+                        type: 'request.query',
+                        op: 'set',
+                        target: { key },
+                        args: value,
+                    });
+                }
+            }
+            const route = {
+                src: source,
+                dest: destination,
+                transforms,
+            };
+            if (has)
+                route.has = has;
+            if (missing)
+                route.missing = missing;
+            return route;
+        }
+        // Simple rewrite without transforms
+        const rewrite = {
             source,
             destination,
-            ...(methods && { methods }),
-            ...(status && { status }),
-            has,
-            missing,
-            transforms,
-        });
-        // Only enable rewrite caching for rewrites without transforms
-        // (transforms convert to routes, which don't need the caching header)
-        if (!transforms) {
-            this.headerRules.push({
-                source,
-                headers: [{ key: 'x-vercel-enable-rewrite-caching', value: '1' }],
-                has,
-                missing,
-            });
-        }
-        return this;
+        };
+        if (has)
+            rewrite.has = has;
+        if (missing)
+            rewrite.missing = missing;
+        return rewrite;
     }
     /**
-     * Loads rewrite rules asynchronously and appends them.
-     * Automatically enables rewrite caching for all loaded rules by adding the x-vercel-enable-rewrite-caching header.
+     * Creates a redirect rule. Returns either a Redirect object (simple case) or Route with transforms.
      *
      * @example
-     *    // This will automatically enable caching for all rewrites
-     *    await router.rewrites(() => fetchRewriteRulesFromDB());
-     */
-    async rewrites(provider) {
-        const rules = await provider();
-        this.rewriteRules.push(...rules);
-        // Automatically enable rewrite caching for all rules
-        const headerRules = rules.map((rule) => ({
-            source: rule.source,
-            headers: [{ key: 'x-vercel-enable-rewrite-caching', value: '1' }],
-            has: rule.has,
-            missing: rule.missing,
-        }));
-        this.headerRules.push(...headerRules);
-        return this;
-    }
-    /**
-     * Adds a single redirect rule (synchronous).
-     * @example
      *    // Simple redirect
      *    router.redirect('/old-path', '/new-path', { permanent: true })
      *
-     *    // With transforms using callback
+     *    // With transforms
      *    router.redirect('/users/:userId', '/new-users/$1', ({userId, env}) => ({
      *      permanent: true,
-     *      requestHeaders: {
-     *        'x-user-id': userId,
-     *        'x-api-key': env.API_KEY
-     *      }
+     *      requestHeaders: { 'x-user-id': userId }
      *    }))
-     *
-     *    // With transforms using object (legacy)
-     *    router.redirect('/users/:userId', '/new-users/$1', {
-     *      permanent: true,
-     *      requestHeaders: {
-     *        'x-user-id': param('userId')
-     *      }
-     *    })
+     * @internal Can return Route with transforms internally
      */
     redirect(source, destination, optionsOrCallback) {
         this.validateSourcePattern(source);
         (0, validation_1.validateCaptureGroupReferences)(source, destination);
         let options;
-        let trackedEnvVars;
         // Handle callback syntax
         if (typeof optionsOrCallback === 'function') {
             const pathParams = this.extractPathParams(source);
-            const { proxy: envProxy, accessedVars } = this.createEnvProxy();
-            trackedEnvVars = accessedVars;
+            const { proxy: envProxy } = this.createEnvProxy();
             // Create params object with path parameters as $paramName
             const paramsObj = {};
             for (const param of pathParams) {
@@ -411,92 +244,75 @@ class Router {
         else {
             options = optionsOrCallback;
         }
-        // Extract transform 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 ||
-            deleteRequestHeaders || deleteResponseHeaders || deleteRequestQuery;
-        if (hasTransforms) {
-            const transformOpts = {
-                requestHeaders,
-                responseHeaders,
-                requestQuery,
-                appendRequestHeaders,
-                appendResponseHeaders,
-                appendRequestQuery,
-                deleteRequestHeaders,
-                deleteResponseHeaders,
-                deleteRequestQuery,
-            };
-            const transforms = this.transformOptionsToTransforms(transformOpts, trackedEnvVars);
-            this.routeRules.push({
+        const { permanent, statusCode, has, missing, requestHeaders } = options || {};
+        // Check if transforms were provided
+        if (requestHeaders) {
+            // Build a Route object with transforms
+            const transforms = [];
+            for (const [key, value] of Object.entries(requestHeaders)) {
+                transforms.push({
+                    type: 'request.headers',
+                    op: 'set',
+                    target: { key },
+                    args: value,
+                });
+            }
+            const route = {
                 src: source,
                 dest: destination,
-                ...(methods && { methods }),
-                transforms,
                 redirect: true,
                 status: statusCode || (permanent ? 308 : 307),
-                has,
-                missing,
-            });
-        }
-        else {
-            this.redirectRules.push({
-                source,
-                destination,
-                permanent,
-                statusCode,
-                has,
-                missing,
-            });
+                transforms,
+            };
+            if (has)
+                route.has = has;
+            if (missing)
+                route.missing = missing;
+            return route;
         }
-        return this;
-    }
-    /**
-     * Loads redirect rules asynchronously and appends them.
-     */
-    async redirects(provider) {
-        const rules = await provider();
-        this.redirectRules.push(...rules);
-        return this;
+        // Simple redirect without transforms
+        const redirect = {
+            source,
+            destination,
+        };
+        if (permanent !== undefined)
+            redirect.permanent = permanent;
+        if (statusCode !== undefined)
+            redirect.statusCode = statusCode;
+        if (has)
+            redirect.has = has;
+        if (missing)
+            redirect.missing = missing;
+        return redirect;
     }
     /**
-     * Adds a single header rule (synchronous).
+     * Creates a header rule matching the vercel.json schema.
      * @example
      *    router.header('/api/(.*)', [{ key: 'X-Custom', value: 'HelloWorld' }])
      */
     header(source, headers, options) {
         this.validateSourcePattern(source);
-        this.headerRules.push({ source, headers, ...options });
-        return this;
+        return { source, headers, ...options };
     }
     /**
-     * Loads header rules asynchronously and appends them.
-     */
-    async headers(provider) {
-        const rules = await provider();
-        this.headerRules.push(...rules);
-        return this;
-    }
-    /**
-     * Adds a typed "Cache-Control" header, leveraging `pretty-cache-header`.
-     * This method is purely for convenience, so you can do:
+     * Creates a Cache-Control header rule, leveraging `pretty-cache-header`.
+     * Returns a HeaderRule matching the vercel.json schema.
      *
-     *   router.cacheControl('/my-page', {
-     *     public: true,
-     *     maxAge: '1week',
-     *     staleWhileRevalidate: '1year'
-     *   });
+     * @example
+     *    router.cacheControl('/my-page', {
+     *      public: true,
+     *      maxAge: '1week',
+     *      staleWhileRevalidate: '1year'
+     *    })
      */
     cacheControl(source, cacheOptions, options) {
+        this.validateSourcePattern(source);
         const value = (0, pretty_cache_header_1.cacheHeader)(cacheOptions);
-        this.headerRules.push({
+        return {
             source,
             headers: [{ key: 'Cache-Control', value }],
             ...options,
-        });
-        return this;
+        };
     }
     /**
      * Adds a route with transforms support.

package/dist/types.d.ts

@@ -34,19 +34,67 @@ export interface GithubConfig {
     autoAlias?: boolean;
     autoJobCancelation?: boolean;
 }
+/**
+ * HTTP header key/value pair
+ */
 export interface Header {
     key: string;
     value: string;
 }
+/**
+ * Condition for matching in redirects, rewrites, and headers
+ */
+export interface Condition {
+    type: 'header' | 'cookie' | 'host' | 'query' | 'path';
+    key?: string;
+    value?: string | number;
+    inc?: string[];
+    pre?: string;
+    eq?: string | number;
+    neq?: string;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+}
+/**
+ * Redirect matching vercel.json schema
+ * Returned by router.redirect()
+ */
+export interface Redirect {
+    source: string;
+    destination: string;
+    permanent?: boolean;
+    statusCode?: number;
+    has?: Condition[];
+    missing?: Condition[];
+}
+/**
+ * Rewrite matching vercel.json schema
+ * Returned by router.rewrite()
+ */
+export interface Rewrite {
+    source: string;
+    destination: string;
+    has?: Condition[];
+    missing?: Condition[];
+}
+/**
+ * Header rule matching vercel.json schema
+ * Returned by router.header() and router.cacheControl()
+ */
 export interface HeaderRule {
     source: string;
     headers: Header[];
+    has?: Condition[];
+    missing?: Condition[];
 }
 /**
- * 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.
+ * Union type for all router helper outputs
+ * Can be simple schema objects (Redirect, Rewrite, HeaderRule) or Routes with transforms
+ * Note: Route type is defined in router.ts (uses src/dest instead of source/destination)
  */
-export type RouteType = any;
+export type RouteType = Redirect | Rewrite | HeaderRule | any;
 export interface WildcardDomain {
     domain: string;
     value: string;
@@ -103,6 +151,12 @@ export interface VercelConfig {
      * Can use router.rewrite() helper.
      */
     rewrites?: RouteType[];
+    /**
+     * Routes configuration using the lower-level routes primitive.
+     * Use this if you need transforms or want everything in one place.
+     * Cannot be mixed with headers, redirects, or rewrites.
+     */
+    routes?: RouteType[];
     /**
      * Wildcard domain configuration.
      */

package/dist/utils/validation.d.ts

@@ -41,3 +41,30 @@ export declare function countCaptureGroups(pattern: string): number;
  * that don't exist in the source pattern.
  */
 export declare function validateCaptureGroupReferences(source: string, destination: string): void;
+/**
+ * Validates that a value is a static string literal (not computed, not a function call, etc.)
+ * Used for static fields that must be extracted before build execution.
+ */
+export declare function validateStaticString(value: any, fieldName: string): void;
+/**
+ * Validates that a value is a static boolean literal
+ */
+export declare function validateStaticBoolean(value: any, fieldName: string): void;
+/**
+ * Validates that a value is a static object with primitive values
+ * Used for git.deploymentEnabled and similar objects that need to be static
+ */
+export declare function validateStaticObject(value: any, fieldName: string): void;
+/**
+ * Validates that a value is a static array of strings
+ */
+export declare function validateStaticStringArray(value: any, fieldName: string): void;
+/**
+ * Validates static fields in VercelConfig that must be extracted before build execution.
+ * These fields include:
+ * - buildCommand, devCommand, installCommand, framework, nodeVersion, outputDirectory
+ * - github.enabled, github.autoAlias, github.autoJobCancelation
+ * - git.deploymentEnabled
+ * - relatedProjects
+ */
+export declare function validateStaticFields(config: Record<string, any>): void;