@vercel/config 0.0.13 → 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.
@@ -607,11 +423,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;
@@ -631,7 +503,7 @@ class Router {
             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) {