@vercel/config 0.0.9 → 0.0.12

package/README.md

@@ -1,46 +1,159 @@
-# Vercel Router SDK
+# @vercel/config
 
-This is a prototype of what a Router SDK could look like.
+TypeScript SDK for defining Vercel configuration programmatically.
 
-## Usage
+## Installation
 
-1. Install the package:
-   `npm install @vercel/router`
+```bash
+npm install @vercel/config
+```
 
-2. Create a router configuration file (e.g., `router.config.ts`):
+## Usage
+
+Create a `vercel.ts` file in your project root:
 
 ```typescript
-import { createRouter } from "@vercel/router";
+import { createRouter } from '@vercel/config';
 
 const router = createRouter();
 
-router
-  .rewrite("/api/(.*)", "/api/$1")
-  .redirect("/old-docs", "/docs", { permanent: true })
-  .cacheControl("/static/(.*)", {
-    public: true,
-    maxAge: "1week",
-    immutable: true
-  })
-  .setCleanUrls(true);
+// Basic rewrite
+router.rewrite('/api/(.*)', 'https://backend.com/$1');
+
+// Rewrite with transforms
+router.rewrite('/users/:userId', 'https://api.example.com/users/$1', ({userId, env}) => ({
+  requestHeaders: {
+    'x-user-id': userId,
+    'authorization': `Bearer ${env.API_TOKEN}`
+  }
+}));
+
+// Redirects
+router.redirect('/old-docs', '/docs', { permanent: true });
+
+// Cache control
+router.cacheControl('/static/(.*)', {
+  public: true,
+  maxAge: '1week',
+  immutable: true
+});
+
+// Global settings
+router.cleanUrls = true;
+router.trailingSlash = true;
+
+// Bulk redirects
+router.bulkRedirectsPath = './bulkRedirectsDemo.json';
+
+// Cron jobs
+router.cron('/api/cleanup', '0 0 * * *');
 
 export default router.getConfig();
 ```
 
-3. Add the generate-config script to your package.json:
+## Automatic Compilation
+
+Your `vercel.ts` file is automatically compiled when you run:
+
+```bash
+vercel build   # For local builds
+vercel dev     # For local development  
+vercel deploy  # For deployment
+```
+
+The Vercel CLI automatically compiles `vercel.ts` to `.vercel/vercel.json` before building or deploying.
+
+## API Reference
+
+### `createRouter()`
+
+Creates a new router instance.
+
+### `router.rewrite(source, destination, options?)`
 
-```json
-{
-  "scripts": {
-    "generate-config": "@vercel/router"
+Add a rewrite rule. Options can be an object or a callback function that receives path parameters and environment variables.
+
+```typescript
+// With callback for transforms
+router.rewrite('/users/:userId', 'https://api.example.com/users/$1', ({userId, env}) => ({
+  requestHeaders: {
+    'x-user-id': userId,
+    'authorization': `Bearer ${env.API_TOKEN}`
+  },
+  responseHeaders: {
+    'x-powered-by': 'My API'
+  },
+  requestQuery: {
+    'version': '2.0'
   }
-}
+}));
+
+// Simple rewrite without transforms
+router.rewrite('/api/(.*)', 'https://backend.com/$1');
 ```
 
-4. Run the script to generate your `vercel.json`:
+### `router.redirect(source, destination, options?)`
 
-```bash
-npm run generate-config
+Add a redirect rule. Options include `permanent` and `statusCode`.
+
+```typescript
+router.redirect('/old-page', '/new-page', { permanent: true });
+router.redirect('/temp', '/elsewhere', { statusCode: 302 });
 ```
 
-This will generate a `vercel.json` file in your project root with all your routing configurations.
+### `router.header(source, headers, options?)`
+
+Add custom headers for a path pattern.
+
+```typescript
+router.header('/api/(.*)', [
+  { key: 'X-Custom-Header', value: 'value' }
+]);
+```
+
+### `router.cacheControl(source, options)`
+
+Set cache control headers. Options include `public`, `private`, `maxAge`, `sMaxAge`, `immutable`, etc.
+
+```typescript
+router.cacheControl('/static/(.*)', {
+  public: true,
+  maxAge: '1week',
+  immutable: true
+});
+```
+
+### `router.cleanUrls`
+
+Set whether to enable clean URLs (removes file extensions).
+
+```typescript
+router.cleanUrls = true;
+```
+
+### `router.trailingSlash`
+
+Set whether to normalize paths to include trailing slashes.
+
+```typescript
+router.trailingSlash = true;
+```
+
+### `router.bulkRedirectsPath`
+
+Set the path to a bulk redirects JSON file.
+
+```typescript
+router.bulkRedirectsPath = './bulkRedirectsDemo.json';
+```
+
+## Important Notes
+
+- **One config file only**: You cannot have both `vercel.ts` and `vercel.json`. The build will fail if both exist.
+- **Automatic gitignore**: The generated `.vercel/vercel.json` file is automatically ignored by git (in the `.vercel/` directory).
+- **No manual compilation needed**: The Vercel CLI handles compilation automatically - no need to run a separate command.
+
+## Learn More
+
+- [Vercel Configuration Documentation](https://vercel.com/docs/projects/project-configuration)
+- [Routing Documentation](https://vercel.com/docs/edge-network/routing)

package/dist/cli.js

@@ -28,7 +28,22 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const fs_2 = require("fs");
 /**
- * Read the user's vercel.ts file (or fallback to router.config.ts for backwards compatibility)
+ * Named exports that should NOT be auto-converted to config
+ * (these are route-based features that compile into the routes array, or internal module properties)
+ */
+const ROUTE_BASED_EXPORTS = new Set([
+    'default',
+    'routes',
+    'redirects',
+    'rewrites',
+    'headers',
+    'crons',
+    'env',
+    'cacheControl',
+    '__esModule' // ES module metadata
+]);
+/**
+ * Read the user's vercel.ts file and collect both default export and export const declarations
  */
 async function configureRouter() {
     var _a;
@@ -36,8 +51,22 @@ async function configureRouter() {
     const routerConfigPath = (0, path_1.resolve)(process.cwd(), "router.config.ts");
     // Prefer vercel.ts, fallback to router.config.ts
     const configPath = (0, fs_2.existsSync)(vercelTsPath) ? vercelTsPath : routerConfigPath;
-    const routerConfig = (await (_a = configPath, Promise.resolve().then(() => __importStar(require(_a))))).default;
-    return routerConfig;
+    // Import the entire module to get both default and named exports
+    const module = await (_a = configPath, Promise.resolve().then(() => __importStar(require(_a))));
+    // Start with the default export (router.getConfig())
+    const routerConfig = module.default || {};
+    // Auto-collect all export const declarations (except route-based ones)
+    const exportedConstants = {};
+    for (const [key, value] of Object.entries(module)) {
+        if (!ROUTE_BASED_EXPORTS.has(key)) {
+            exportedConstants[key] = value;
+        }
+    }
+    // Merge: export const declarations take precedence over default export
+    return {
+        ...routerConfig,
+        ...exportedConstants
+    };
 }
 /**
  * Read existing vercel.json and extract fields to preserve

package/dist/router.d.ts

@@ -215,27 +215,28 @@ export interface Header {
 export interface TransformOptions {
     /**
      * Headers to set/modify on the incoming request.
-     * Use param() for path parameters and runtimeEnv() for environment variables.
+     * Sets the key and value if missing.
      *
      * @example
      * requestHeaders: {
-     *   'x-user-id': param('userId'),
-     *   'authorization': `Bearer ${runtimeEnv('API_TOKEN')}`
+     *   'x-user-id': userId,
+     *   'authorization': `Bearer ${env.API_TOKEN}`
      * }
      */
     requestHeaders?: Record<string, string | string[]>;
     /**
      * Headers to set/modify on the outgoing response.
-     * Use param() for path parameters and runtimeEnv() for environment variables.
+     * Sets the key and value if missing.
      *
      * @example
      * responseHeaders: {
-     *   'x-post-id': param('postId')
+     *   'x-post-id': postId
      * }
      */
     responseHeaders?: Record<string, string | string[]>;
     /**
      * Query parameters to set/modify on the request.
+     * Sets the key and value if missing.
      *
      * @example
      * requestQuery: {
@@ -243,6 +244,60 @@ export interface TransformOptions {
      * }
      */
     requestQuery?: Record<string, string | string[]>;
+    /**
+     * Headers to append to the incoming request.
+     * Appends args to the value of the key, and will set if missing.
+     *
+     * @example
+     * appendRequestHeaders: {
+     *   'x-custom': 'value'
+     * }
+     */
+    appendRequestHeaders?: Record<string, string | string[]>;
+    /**
+     * Headers to append to the outgoing response.
+     * Appends args to the value of the key, and will set if missing.
+     *
+     * @example
+     * appendResponseHeaders: {
+     *   'x-custom': 'value'
+     * }
+     */
+    appendResponseHeaders?: Record<string, string | string[]>;
+    /**
+     * Query parameters to append to the request.
+     * Appends args to the value of the key, and will set if missing.
+     *
+     * @example
+     * appendRequestQuery: {
+     *   'tag': 'value'
+     * }
+     */
+    appendRequestQuery?: Record<string, string | string[]>;
+    /**
+     * Headers to delete from the incoming request.
+     * Deletes the key entirely if args is not provided; otherwise, it will delete the value of args from the matching key.
+     *
+     * @example
+     * deleteRequestHeaders: ['x-remove-this', 'x-remove-that']
+     */
+    deleteRequestHeaders?: string[];
+    /**
+     * Headers to delete from the outgoing response.
+     * Deletes the key entirely if args is not provided; otherwise, it will delete the value of args from the matching key.
+     *
+     * @example
+     * deleteResponseHeaders: ['x-powered-by']
+     */
+    deleteResponseHeaders?: string[];
+    /**
+     * Query parameters to delete from the request.
+     * Deletes the key entirely if args is not provided; otherwise, it will delete the value of args from the matching key.
+     *
+     * @example
+     * deleteRequestQuery: ['debug', 'trace']
+     */
+    deleteRequestQuery?: string[];
 }
 /**
  * HeaderRule defines one or more headers to set for requests
@@ -352,6 +407,10 @@ export interface RouterConfig {
      * When true, routes are normalized to include a trailing slash.
      */
     trailingSlash?: boolean;
+    /**
+     * Path to a JSON file containing bulk redirect rules.
+     */
+    bulkRedirectsPath?: string;
     /**
      * Array of cron definitions for scheduled invocations.
      */
@@ -378,8 +437,45 @@ export declare class Router {
     private cronRules;
     private cleanUrlsConfig;
     private trailingSlashConfig;
+    private bulkRedirectsPathConfig;
     private buildCommandConfig;
     private installCommandConfig;
+    /**
+     * Property setter for cleanUrls configuration.
+     */
+    set cleanUrls(value: boolean | undefined);
+    /**
+     * Property getter for cleanUrls configuration.
+     */
+    get cleanUrls(): boolean | undefined;
+    /**
+     * Property setter for trailingSlash configuration.
+     */
+    set trailingSlash(value: boolean | undefined);
+    /**
+     * Property getter for trailingSlash configuration.
+     */
+    get trailingSlash(): boolean | undefined;
+    /**
+     * Property setter for bulkRedirectsPath configuration.
+     */
+    set bulkRedirectsPath(value: string | undefined);
+    /**
+     * Property getter for bulkRedirectsPath configuration.
+     */
+    get bulkRedirectsPath(): string | undefined;
+    /**
+     * Helper to extract path parameter names from a source pattern.
+     * Path parameters are identified by :paramName syntax.
+     * @example
+     * extractPathParams('/users/:userId/posts/:postId') // Returns ['userId', 'postId']
+     */
+    private extractPathParams;
+    /**
+     * Creates a Proxy object that tracks environment variable accesses.
+     * Returns both the proxy and a set of accessed environment variable names.
+     */
+    private createEnvProxy;
     /**
      * Helper to extract environment variable names from a string or string array.
      * Environment variables are identified by the pattern $VAR_NAME where VAR_NAME
@@ -388,6 +484,8 @@ export declare class Router {
     private extractEnvVars;
     /**
      * 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
      */
     private transformOptionsToTransforms;
     /**
@@ -395,26 +493,51 @@ export declare class Router {
      * Automatically enables rewrite caching by adding the x-vercel-enable-rewrite-caching header.
      *
      * @example
-     *    // This will automatically enable caching for the rewrite
-     *    import { createRouter, param, runtimeEnv } from '@vercel/router-sdk';
-     *    const router = createRouter();
+     *    // Simple rewrite
      *    router.rewrite('/api/(.*)', 'https://old-on-prem.com/$1')
      *
-     *    // With transforms
+     *    // With transforms using callback
+     *    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'),
-     *        'authorization': `Bearer ${runtimeEnv('API_TOKEN')}`
+     *        'x-user-id': param('userId')
      *      }
      *    });
      */
-    rewrite(source: string, destination: string, options?: {
+    rewrite(source: string, destination: string, optionsOrCallback?: {
         has?: Condition[];
         missing?: Condition[];
         requestHeaders?: Record<string, string | string[]>;
         responseHeaders?: Record<string, string | string[]>;
         requestQuery?: Record<string, string | string[]>;
-    }): this;
+        appendRequestHeaders?: Record<string, string | string[]>;
+        appendResponseHeaders?: Record<string, string | string[]>;
+        appendRequestQuery?: Record<string, string | string[]>;
+        deleteRequestHeaders?: string[];
+        deleteResponseHeaders?: string[];
+        deleteRequestQuery?: string[];
+    } | ((params: Record<string, string> & {
+        env: any;
+    }) => {
+        has?: Condition[];
+        missing?: Condition[];
+        requestHeaders?: Record<string, string | string[]>;
+        responseHeaders?: Record<string, string | string[]>;
+        requestQuery?: Record<string, string | string[]>;
+        appendRequestHeaders?: Record<string, string | string[]>;
+        appendResponseHeaders?: Record<string, string | string[]>;
+        appendRequestQuery?: Record<string, string | string[]>;
+        deleteRequestHeaders?: string[];
+        deleteResponseHeaders?: string[];
+        deleteRequestQuery?: string[];
+    })): this;
     /**
      * Loads rewrite rules asynchronously and appends them.
      * Automatically enables rewrite caching for all loaded rules by adding the x-vercel-enable-rewrite-caching header.
@@ -427,9 +550,19 @@ export declare class Router {
     /**
      * Adds a single redirect rule (synchronous).
      * @example
+     *    // Simple redirect
      *    router.redirect('/old-path', '/new-path', { permanent: true })
      *
-     *    // With transforms
+     *    // With transforms using callback
+     *    router.redirect('/users/:userId', '/new-users/$1', ({userId, env}) => ({
+     *      permanent: true,
+     *      requestHeaders: {
+     *        'x-user-id': userId,
+     *        'x-api-key': env.API_KEY
+     *      }
+     *    }))
+     *
+     *    // With transforms using object (legacy)
      *    router.redirect('/users/:userId', '/new-users/$1', {
      *      permanent: true,
      *      requestHeaders: {
@@ -437,7 +570,7 @@ export declare class Router {
      *      }
      *    })
      */
-    redirect(source: string, destination: string, options?: {
+    redirect(source: string, destination: string, optionsOrCallback?: {
         permanent?: boolean;
         statusCode?: number;
         has?: Condition[];
@@ -445,7 +578,29 @@ export declare class Router {
         requestHeaders?: Record<string, string | string[]>;
         responseHeaders?: Record<string, string | string[]>;
         requestQuery?: Record<string, string | string[]>;
-    }): this;
+        appendRequestHeaders?: Record<string, string | string[]>;
+        appendResponseHeaders?: Record<string, string | string[]>;
+        appendRequestQuery?: Record<string, string | string[]>;
+        deleteRequestHeaders?: string[];
+        deleteResponseHeaders?: string[];
+        deleteRequestQuery?: string[];
+    } | ((params: Record<string, string> & {
+        env: any;
+    }) => {
+        permanent?: boolean;
+        statusCode?: number;
+        has?: Condition[];
+        missing?: Condition[];
+        requestHeaders?: Record<string, string | string[]>;
+        responseHeaders?: Record<string, string | string[]>;
+        requestQuery?: Record<string, string | string[]>;
+        appendRequestHeaders?: Record<string, string | string[]>;
+        appendResponseHeaders?: Record<string, string | string[]>;
+        appendRequestQuery?: Record<string, string | string[]>;
+        deleteRequestHeaders?: string[];
+        deleteResponseHeaders?: string[];
+        deleteRequestQuery?: string[];
+    })): this;
     /**
      * Loads redirect rules asynchronously and appends them.
      */

package/dist/router.js

@@ -40,9 +40,77 @@ class Router {
         this.cronRules = [];
         this.cleanUrlsConfig = undefined;
         this.trailingSlashConfig = undefined;
+        this.bulkRedirectsPathConfig = undefined;
         this.buildCommandConfig = undefined;
         this.installCommandConfig = undefined;
     }
+    /**
+     * Property setter for cleanUrls configuration.
+     */
+    set cleanUrls(value) {
+        this.cleanUrlsConfig = value;
+    }
+    /**
+     * Property getter for cleanUrls configuration.
+     */
+    get cleanUrls() {
+        return this.cleanUrlsConfig;
+    }
+    /**
+     * Property setter for trailingSlash configuration.
+     */
+    set trailingSlash(value) {
+        this.trailingSlashConfig = value;
+    }
+    /**
+     * Property getter for trailingSlash configuration.
+     */
+    get trailingSlash() {
+        return this.trailingSlashConfig;
+    }
+    /**
+     * Property setter for bulkRedirectsPath configuration.
+     */
+    set bulkRedirectsPath(value) {
+        this.bulkRedirectsPathConfig = value;
+    }
+    /**
+     * Property getter for bulkRedirectsPath configuration.
+     */
+    get bulkRedirectsPath() {
+        return this.bulkRedirectsPathConfig;
+    }
+    /**
+     * Helper to extract path parameter names from a source pattern.
+     * Path parameters are identified by :paramName syntax.
+     * @example
+     * extractPathParams('/users/:userId/posts/:postId') // Returns ['userId', 'postId']
+     */
+    extractPathParams(source) {
+        const params = [];
+        const matches = source.matchAll(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
+        for (const match of matches) {
+            params.push(match[1]);
+        }
+        return params;
+    }
+    /**
+     * Creates a Proxy object that tracks environment variable accesses.
+     * Returns both the proxy and a set of accessed environment variable names.
+     */
+    createEnvProxy() {
+        const accessedVars = new Set();
+        const proxy = new Proxy({}, {
+            get(_target, prop) {
+                if (typeof prop === 'string') {
+                    accessedVars.add(prop);
+                    return `$${prop}`;
+                }
+                return undefined;
+            }
+        });
+        return { proxy, accessedVars };
+    }
     /**
      * Helper to extract environment variable names from a string or string array.
      * Environment variables are identified by the pattern $VAR_NAME where VAR_NAME
@@ -63,13 +131,26 @@ class Router {
     }
     /**
      * 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) {
+    transformOptionsToTransforms(options, trackedEnvVars) {
         const transforms = [];
-        // Convert requestHeaders
+        // 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 = this.extractEnvVars(value);
+                const envVars = getEnvVars(value);
                 transforms.push({
                     type: 'request.headers',
                     op: 'set',
@@ -79,10 +160,10 @@ class Router {
                 });
             }
         }
-        // Convert responseHeaders
+        // Convert responseHeaders (set)
         if (options.responseHeaders) {
             for (const [key, value] of Object.entries(options.responseHeaders)) {
-                const envVars = this.extractEnvVars(value);
+                const envVars = getEnvVars(value);
                 transforms.push({
                     type: 'response.headers',
                     op: 'set',
@@ -92,10 +173,10 @@ class Router {
                 });
             }
         }
-        // Convert requestQuery
+        // Convert requestQuery (set)
         if (options.requestQuery) {
             for (const [key, value] of Object.entries(options.requestQuery)) {
-                const envVars = this.extractEnvVars(value);
+                const envVars = getEnvVars(value);
                 transforms.push({
                     type: 'request.query',
                     op: 'set',
@@ -105,6 +186,77 @@ class Router {
                 });
             }
         }
+        // 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;
     }
     /**
@@ -112,32 +264,65 @@ class Router {
      * Automatically enables rewrite caching by adding the x-vercel-enable-rewrite-caching header.
      *
      * @example
-     *    // This will automatically enable caching for the rewrite
-     *    import { createRouter, param, runtimeEnv } from '@vercel/router-sdk';
-     *    const router = createRouter();
+     *    // Simple rewrite
      *    router.rewrite('/api/(.*)', 'https://old-on-prem.com/$1')
      *
-     *    // With transforms
+     *    // With transforms using callback
+     *    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'),
-     *        'authorization': `Bearer ${runtimeEnv('API_TOKEN')}`
+     *        'x-user-id': param('userId')
      *      }
      *    });
      */
-    rewrite(source, destination, options) {
+    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;
+            // Create params object with path parameters as $paramName
+            const paramsObj = {};
+            for (const param of pathParams) {
+                paramsObj[param] = `$${param}`;
+            }
+            paramsObj.env = envProxy;
+            // Call the callback to get options
+            options = optionsOrCallback(paramsObj);
+        }
+        else {
+            options = optionsOrCallback;
+        }
         // Extract transform options
-        const { requestHeaders, responseHeaders, requestQuery, has, missing } = options || {};
+        const { 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 transforms = requestHeaders || responseHeaders || requestQuery
-            ? this.transformOptionsToTransforms(transformOpts)
+        const hasTransforms = requestHeaders || responseHeaders || requestQuery ||
+            appendRequestHeaders || appendResponseHeaders || appendRequestQuery ||
+            deleteRequestHeaders || deleteResponseHeaders || deleteRequestQuery;
+        const transforms = hasTransforms
+            ? this.transformOptionsToTransforms(transformOpts, trackedEnvVars)
             : undefined;
         this.rewriteRules.push({
             source,
@@ -182,9 +367,19 @@ class Router {
     /**
      * Adds a single redirect rule (synchronous).
      * @example
+     *    // Simple redirect
      *    router.redirect('/old-path', '/new-path', { permanent: true })
      *
-     *    // With transforms
+     *    // With transforms using callback
+     *    router.redirect('/users/:userId', '/new-users/$1', ({userId, env}) => ({
+     *      permanent: true,
+     *      requestHeaders: {
+     *        'x-user-id': userId,
+     *        'x-api-key': env.API_KEY
+     *      }
+     *    }))
+     *
+     *    // With transforms using object (legacy)
      *    router.redirect('/users/:userId', '/new-users/$1', {
      *      permanent: true,
      *      requestHeaders: {
@@ -192,19 +387,47 @@ class Router {
      *      }
      *    })
      */
-    redirect(source, destination, options) {
+    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;
+            // Create params object with path parameters as $paramName
+            const paramsObj = {};
+            for (const param of pathParams) {
+                paramsObj[param] = `$${param}`;
+            }
+            paramsObj.env = envProxy;
+            // Call the callback to get options
+            options = optionsOrCallback(paramsObj);
+        }
+        else {
+            options = optionsOrCallback;
+        }
         // Extract transform options
-        const { requestHeaders, responseHeaders, requestQuery, permanent, statusCode, has, missing, } = options || {};
+        const { 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
-        if (requestHeaders || responseHeaders || requestQuery) {
+        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);
+            const transforms = this.transformOptionsToTransforms(transformOpts, trackedEnvVars);
             this.routeRules.push({
                 src: source,
                 dest: destination,
@@ -380,7 +603,10 @@ class Router {
             const config = {
                 routes: allRoutes,
             };
-            // Only include buildCommand/installCommand if they're explicitly set
+            // Only include optional fields if they're explicitly set
+            if (this.bulkRedirectsPathConfig !== undefined) {
+                config.bulkRedirectsPath = this.bulkRedirectsPathConfig;
+            }
             if (this.buildCommandConfig !== undefined) {
                 config.buildCommand = this.buildCommandConfig;
             }
@@ -398,7 +624,10 @@ class Router {
             trailingSlash: this.trailingSlashConfig,
             crons: this.cronRules,
         };
-        // Only include buildCommand/installCommand if they're explicitly set
+        // Only include optional fields if they're explicitly set
+        if (this.bulkRedirectsPathConfig !== undefined) {
+            config.bulkRedirectsPath = this.bulkRedirectsPathConfig;
+        }
         if (this.buildCommandConfig !== undefined) {
             config.buildCommand = this.buildCommandConfig;
         }

package/package.json

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