@vercel/config 0.0.18 → 0.0.20

package/dist/router.js

@@ -26,6 +26,30 @@ function runtimeEnv(name) {
     return `$${name}`;
 }
 exports.runtimeEnv = runtimeEnv;
+/**
+ * Extract environment variable names from a string or array of strings
+ * Returns env var names without the $ prefix, excluding path parameters
+ */
+function extractEnvVars(args, pathParams) {
+    if (!args)
+        return [];
+    const envVars = new Set();
+    const argsArray = Array.isArray(args) ? args : [args];
+    for (const arg of argsArray) {
+        // Find all $VAR patterns
+        const matches = arg.match(/\$([A-Z_][A-Z0-9_]*)/g);
+        if (matches) {
+            for (const match of matches) {
+                const varName = match.substring(1); // Remove the $
+                // Only add if it's not a path parameter
+                if (!pathParams.includes(varName)) {
+                    envVars.add(varName);
+                }
+            }
+        }
+    }
+    return Array.from(envVars);
+}
 /**
  * The main Router class for building a Vercel configuration object in code.
  * Supports synchronous or asynchronous addition of rewrites, redirects, headers,
@@ -149,34 +173,50 @@ class Router {
         if (hasTransforms) {
             // Build a Route object with transforms
             const transforms = [];
+            const pathParams = this.extractPathParams(source);
             if (requestHeaders) {
                 for (const [key, value] of Object.entries(requestHeaders)) {
-                    transforms.push({
+                    const transform = {
                         type: 'request.headers',
                         op: 'set',
                         target: { key },
                         args: value,
-                    });
+                    };
+                    const envVars = extractEnvVars(value, pathParams);
+                    if (envVars.length > 0) {
+                        transform.env = envVars;
+                    }
+                    transforms.push(transform);
                 }
             }
             if (responseHeaders) {
                 for (const [key, value] of Object.entries(responseHeaders)) {
-                    transforms.push({
+                    const transform = {
                         type: 'response.headers',
                         op: 'set',
                         target: { key },
                         args: value,
-                    });
+                    };
+                    const envVars = extractEnvVars(value, pathParams);
+                    if (envVars.length > 0) {
+                        transform.env = envVars;
+                    }
+                    transforms.push(transform);
                 }
             }
             if (requestQuery) {
                 for (const [key, value] of Object.entries(requestQuery)) {
-                    transforms.push({
+                    const transform = {
                         type: 'request.query',
                         op: 'set',
                         target: { key },
                         args: value,
-                    });
+                    };
+                    const envVars = extractEnvVars(value, pathParams);
+                    if (envVars.length > 0) {
+                        transform.env = envVars;
+                    }
+                    transforms.push(transform);
                 }
             }
             const route = {
@@ -239,13 +279,19 @@ class Router {
         if (requestHeaders) {
             // Build a Route object with transforms
             const transforms = [];
+            const pathParams = this.extractPathParams(source);
             for (const [key, value] of Object.entries(requestHeaders)) {
-                transforms.push({
+                const transform = {
                     type: 'request.headers',
                     op: 'set',
                     target: { key },
                     args: value,
-                });
+                };
+                const envVars = extractEnvVars(value, pathParams);
+                if (envVars.length > 0) {
+                    transform.env = envVars;
+                }
+                transforms.push(transform);
             }
             const route = {
                 src: source,
@@ -331,6 +377,18 @@ class Router {
      */
     route(config) {
         this.validateSourcePattern(config.src);
+        // Auto-extract env vars from each transform if not already specified
+        if (config.transforms) {
+            const pathParams = this.extractPathParams(config.src);
+            for (const transform of config.transforms) {
+                if (!transform.env && transform.args) {
+                    const envVars = extractEnvVars(transform.args, pathParams);
+                    if (envVars.length > 0) {
+                        transform.env = envVars;
+                    }
+                }
+            }
+        }
         this.routeRules.push(config);
         return this;
     }

package/dist/types.d.ts

@@ -28,11 +28,50 @@ export interface GitDeploymentConfig {
 }
 export interface GitConfig {
     deploymentEnabled?: boolean | GitDeploymentConfig;
+    /**
+     * @private
+     */
+    exclusivity?: {
+        teams?: string[];
+    };
 }
 export interface GithubConfig {
     enabled?: boolean;
     autoAlias?: boolean;
     autoJobCancelation?: boolean;
+    /**
+     * @deprecated
+     */
+    silent?: boolean;
+}
+export interface ImageConfig {
+    sizes: number[];
+    domains?: string[];
+    formats?: ('image/avif' | 'image/webp' | 'image/jpeg' | 'image/png')[];
+    minimumCacheTTL?: number;
+    dangerouslyAllowSVG?: boolean;
+    contentSecurityPolicy?: string;
+    contentDispositionType?: 'inline' | 'attachment';
+    qualities?: number[];
+    localPatterns?: Array<{
+        pathname?: string;
+        search?: string;
+    }>;
+    remotePatterns?: Array<{
+        protocol?: 'http' | 'https';
+        hostname: string;
+        port?: string;
+        pathname?: string;
+        search?: string;
+    }>;
+}
+export interface ProbeConfig {
+    path: string;
+    initialDelaySeconds?: number;
+    periodSeconds?: number;
+    timeoutSeconds?: number;
+    successThreshold?: number;
+    failureThreshold?: number;
 }
 /**
  * HTTP header key/value pair
@@ -48,10 +87,13 @@ export interface Condition {
     type: 'header' | 'cookie' | 'host' | 'query' | 'path';
     key?: string;
     value?: string | number;
-    inc?: string[];
-    pre?: string;
     eq?: string | number;
     neq?: string;
+    inc?: string[];
+    ninc?: string[];
+    pre?: string;
+    suf?: string;
+    re?: string;
     gt?: number;
     gte?: number;
     lt?: number;
@@ -99,11 +141,37 @@ export interface WildcardDomain {
     domain: string;
     value: string;
 }
+export interface BuildConfig {
+    env?: Record<string, string>;
+}
+export interface BuildItem {
+    src?: string;
+    use: string;
+    config?: Record<string, any>;
+}
 export interface VercelConfig {
+    /**
+     * JSON schema URL for editor completions and validation.
+     */
+    $schema?: string;
     /**
      * Aliases that will get assigned when the deployment is `READY` and the target is `production`.
      */
     alias?: string | string[];
+    /**
+     * Build configuration (deprecated).
+     * @deprecated
+     */
+    build?: BuildConfig;
+    /**
+     * Build descriptions (deprecated).
+     * @deprecated
+     */
+    builds?: BuildItem[];
+    /**
+     * Path to a JSON file containing bulk redirect rules.
+     */
+    bulkRedirectsPath?: string;
     /**
      * When set to `true`, all HTML files and Serverless Functions will have their extension removed.
      */
@@ -141,11 +209,31 @@ export interface VercelConfig {
      * Can use router.header() and router.cacheControl() helpers.
      */
     headers?: RouteType[];
+    /**
+     * Image optimization configuration.
+     */
+    images?: ImageConfig;
+    /**
+     * A name for the deployment.
+     */
+    name?: string;
+    /**
+     * Probe configuration for health checks.
+     */
+    probes?: ProbeConfig[];
+    /**
+     * When true, the source code is not stored on the platform and only the production output will be deployed.
+     */
+    public?: boolean;
     /**
      * HTTP redirects configuration.
      * Can use router.redirect() helper.
      */
     redirects?: RouteType[];
+    /**
+     * An array of regions where the deployment's Serverless Functions and Edge Functions should be deployed to.
+     */
+    regions?: string[];
     /**
      * HTTP rewrites configuration.
      * Can use router.rewrite() helper.
@@ -157,10 +245,20 @@ export interface VercelConfig {
      * Cannot be mixed with headers, redirects, or rewrites.
      */
     routes?: RouteType[];
+    /**
+     * Scope (user or team) for deployment.
+     * @private
+     */
+    scope?: string;
     /**
      * Wildcard domain configuration.
      */
     wildcard?: WildcardDomain[];
+    /**
+     * Version of the configuration schema.
+     * @private
+     */
+    version?: number;
     /**
      * The build command for this project. When `null`, automatically detected.
      */
@@ -201,10 +299,6 @@ export interface VercelConfig {
      * Enables Bun for the project and specifies the version to use.
      */
     bunVersion?: string;
-    /**
-     * Node.js version for this project.
-     */
-    nodeVersion?: string;
 }
 /**
  * Runtime placeholder for VercelConfig to allow named imports.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/config",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "A TypeScript SDK for programmatically configuring Vercel projects",
   "bugs": {
     "url": "https://github.com/vercel/config/issues"