@vercel/fs-detectors 6.2.2 → 6.4.0

package/dist/detect-builders.d.ts

@@ -47,4 +47,5 @@ export declare function detectBuilders(files: string[], pkg?: PackageJson | unde
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
     services?: Service[];
+    useImplicitEnvInjection?: boolean;
 }>;

package/dist/services/detect-railway.js

@@ -128,12 +128,12 @@ async function detectRailwayServices(options) {
     if (cf.dirPath !== ".") {
       serviceConfig.entrypoint = cf.dirPath;
     }
-    const buildCommand = combineBuildCommand(
-      cf.config.build?.buildCommand,
-      cf.config.deploy?.preDeployCommand
-    );
-    if (buildCommand) {
-      serviceConfig.buildCommand = buildCommand;
+    if (cf.config.build?.buildCommand) {
+      serviceConfig.buildCommand = cf.config.build.buildCommand;
+    }
+    const railwayPreDeploy = cf.config.deploy?.preDeployCommand;
+    if (railwayPreDeploy) {
+      serviceConfig.preDeployCommand = Array.isArray(railwayPreDeploy) ? railwayPreDeploy.join(" && ") : railwayPreDeploy;
     }
     services[serviceName] = serviceConfig;
   }
@@ -230,16 +230,6 @@ function deriveServiceName(dirPath) {
   const segments = dirPath.split("/");
   return segments[segments.length - 1];
 }
-function combineBuildCommand(buildCommand, preDeployCommand) {
-  const preDeploy = Array.isArray(preDeployCommand) ? preDeployCommand.join(" && ") : preDeployCommand;
-  if (preDeploy && buildCommand) {
-    return `${buildCommand} && ${preDeploy}`;
-  } else if (preDeploy) {
-    return preDeploy;
-  } else {
-    return buildCommand;
-  }
-}
 function assignRoutePrefixes(services) {
   const warnings = [];
   const names = Object.keys(services);

package/dist/services/detect-services.js

@@ -42,10 +42,17 @@ function emptyRoutes() {
     workers: []
   };
 }
+function isEnvVars(env) {
+  if (!env)
+    return false;
+  const first = Object.values(env)[0];
+  return typeof first === "object" && first !== null;
+}
 function withResolvedResult(resolved, inferred = null) {
   return {
     services: resolved.services,
     source: resolved.source,
+    useImplicitEnvInjection: resolved.useImplicitEnvInjection,
     routes: resolved.routes,
     errors: resolved.errors,
     warnings: resolved.warnings,
@@ -81,6 +88,7 @@ async function detectServices(options) {
     return withResolvedResult({
       services: [],
       source: "configured",
+      useImplicitEnvInjection: true,
       routes: emptyRoutes(),
       errors: [configError],
       warnings: []
@@ -95,6 +103,7 @@ async function detectServices(options) {
       return withResolvedResult({
         services: [],
         source: "auto-detected",
+        useImplicitEnvInjection: true,
         routes: emptyRoutes(),
         errors: railwayResult.errors,
         warnings: railwayResult.warnings
@@ -116,6 +125,7 @@ async function detectServices(options) {
         {
           services: [],
           source: "auto-detected",
+          useImplicitEnvInjection: true,
           routes: emptyRoutes(),
           errors: result2.errors,
           warnings: railwayResult.warnings
@@ -134,6 +144,7 @@ async function detectServices(options) {
       const resolved = {
         services: result2.services,
         source: "auto-detected",
+        useImplicitEnvInjection: true,
         routes: routes2,
         errors: result2.errors,
         warnings: []
@@ -152,6 +163,7 @@ async function detectServices(options) {
       return withResolvedResult({
         services: [],
         source: "auto-detected",
+        useImplicitEnvInjection: true,
         routes: emptyRoutes(),
         errors: autoResult.errors,
         warnings: []
@@ -160,6 +172,7 @@ async function detectServices(options) {
     return withResolvedResult({
       services: [],
       source: "auto-detected",
+      useImplicitEnvInjection: true,
       routes: emptyRoutes(),
       errors: [
         {
@@ -177,13 +190,17 @@ async function detectServices(options) {
     {
       requireFileEntrypointForBackendRuntimes: Boolean(
         hasNonEmptyPublicServicesConfig
-      )
+      ),
+      rootEnv: isEnvVars(vercelConfig?.env) ? vercelConfig?.env : void 0
     }
   );
   const routes = generateServicesRoutes(result.services);
   return withResolvedResult({
     services: result.services,
     source: "configured",
+    // GA `services` opts into explicit `env`; experimentalServices keeps
+    // the legacy `{NAME}_URL` injection.
+    useImplicitEnvInjection: !hasNonEmptyPublicServicesConfig,
     routes,
     errors: result.errors,
     warnings: []

package/dist/services/get-services-builders.d.ts

@@ -23,6 +23,7 @@ export interface ServicesBuildersResult {
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
     services?: ResolvedService[];
+    useImplicitEnvInjection?: boolean;
 }
 /**
  * Get builders for services - adapter for detectBuilders.

package/dist/services/get-services-builders.js

@@ -121,7 +121,8 @@ async function getServicesBuilders(options) {
       ...result.routes.crons
     ] : null,
     errorRoutes: [],
-    services: result.services
+    services: result.services,
+    useImplicitEnvInjection: result.useImplicitEnvInjection
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/services/resolve.d.ts

@@ -1,4 +1,4 @@
-import type { Service, ConfiguredServices, ExperimentalServiceConfig, ServiceConfig, ServiceDetectionError } from './types';
+import type { EnvVars, Service, ConfiguredServices, ExperimentalServiceConfig, ServiceConfig, ServiceDetectionError } from './types';
 import type { DetectorFilesystem } from '../detectors/filesystem';
 type ConfiguredServiceConfig = (ServiceConfig | ExperimentalServiceConfig) & Partial<ExperimentalServiceConfig>;
 interface ResolvedEntrypointPath {
@@ -18,6 +18,12 @@ interface ResolveConfiguredServiceOptions {
 }
 interface ResolveAllConfiguredServicesOptions {
     requireFileEntrypointForBackendRuntimes?: boolean;
+    /**
+     * Optional top-level `env` (from vercel.json `env`). Per-service `env`
+     * values take precedence; entries here are folded into every service that
+     * doesn't already define the same name.
+     */
+    rootEnv?: EnvVars;
 }
 /**
  * Validate a service configuration from vercel.json services.

package/dist/services/resolve.js

@@ -45,7 +45,7 @@ function parsePyModuleAttrEntrypoint(entrypoint) {
 }
 const SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
 const DNS_LABEL_RE = /^(?!-)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
-const ENV_PREFIX_RE = /^[A-Z][A-Z0-9_]*_$/;
+const ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const ENTRYPOINT_REQUIRED_RUNTIMES = /* @__PURE__ */ new Set([
   "node",
   "python",
@@ -424,14 +424,46 @@ function validateServiceConfig(name, config, options = {}) {
       };
     }
   }
-  if (config.envPrefix !== void 0) {
-    if (!ENV_PREFIX_RE.test(config.envPrefix)) {
+  if (config.env !== void 0) {
+    if (typeof config.env !== "object" || Array.isArray(config.env)) {
       return {
-        code: "INVALID_ENV_PREFIX",
-        message: `Service "${name}" has invalid envPrefix "${config.envPrefix}". Must start with an uppercase letter, contain only uppercase letters, digits, and underscores, and end with "_" (e.g., "MY_SERVICE_").`,
+        code: "INVALID_ENV_VARS",
+        message: `Service "${name}" has invalid "env". Must be an object keyed by environment variable name.`,
         serviceName: name
       };
     }
+    for (const [envVarName, envVar] of Object.entries(config.env)) {
+      if (!ENV_VAR_NAME_RE.test(envVarName)) {
+        return {
+          code: "INVALID_ENV_VAR_NAME",
+          message: `Service "${name}" has invalid env key "${envVarName}". Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,
+          serviceName: name
+        };
+      }
+      if (!envVar || typeof envVar !== "object" || Array.isArray(envVar)) {
+        return {
+          code: "INVALID_ENV_VAR",
+          message: `Service "${name}" has invalid env["${envVarName}"]. Must be an object with a "type" discriminator.`,
+          serviceName: name
+        };
+      }
+      const envVarType = envVar.type;
+      if (envVarType !== "service-ref") {
+        return {
+          code: "INVALID_ENV_VAR_TYPE",
+          message: `Service "${name}" env["${envVarName}"] has unknown type "${envVarType}".`,
+          serviceName: name
+        };
+      }
+      const refService = envVar.service;
+      if (typeof refService !== "string" || refService.length === 0) {
+        return {
+          code: "INVALID_ENV_VAR_REF",
+          message: `Service "${name}" env["${envVarName}"] must specify "service" as a non-empty string.`,
+          serviceName: name
+        };
+      }
+    }
   }
   if (config.runtime && !(config.runtime in import_types.RUNTIME_BUILDERS)) {
     return {
@@ -652,10 +684,11 @@ async function resolveConfiguredService(options) {
     runtime,
     buildCommand: config.buildCommand,
     installCommand: config.installCommand,
+    preDeployCommand: config.preDeployCommand,
     schedule: config.schedule,
     handlerFunction: moduleAttrParsed?.attrName,
     topics,
-    envPrefix: config.envPrefix
+    env: config.env
   };
 }
 async function resolveAllConfiguredServices(services, fs, routePrefixSource = "configured", options = {}) {
@@ -803,8 +836,49 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
     }
     resolved.push(service);
   }
+  const servicesByName = new Map(resolved.map((s) => [s.name, s]));
+  for (const service of resolved) {
+    if (!service.env)
+      continue;
+    validateEnvRefs(
+      service.env,
+      `Service "${service.name}" env`,
+      servicesByName,
+      errors,
+      service.name
+    );
+  }
+  if (options.rootEnv) {
+    validateEnvRefs(options.rootEnv, "env", servicesByName, errors);
+    for (const service of resolved) {
+      service.env = { ...options.rootEnv, ...service.env ?? {} };
+    }
+  }
   return { services: resolved, errors };
 }
+function validateEnvRefs(env, pathPrefix, servicesByName, errors, serviceName) {
+  for (const [envVarName, envVar] of Object.entries(env)) {
+    if (envVar.type !== "service-ref")
+      continue;
+    const refName = envVar.service;
+    const target = servicesByName.get(refName);
+    if (!target) {
+      errors.push({
+        code: "UNKNOWN_SERVICE_REF",
+        message: `${pathPrefix}["${envVarName}"] references unknown service "${refName}".`,
+        ...serviceName ? { serviceName } : {}
+      });
+      continue;
+    }
+    if (target.type !== "web") {
+      errors.push({
+        code: "INVALID_SERVICE_REF_TYPE",
+        message: `${pathPrefix}["${envVarName}"] references service "${refName}" which is a ${target.type} service and has no URL. Only web services can be referenced.`,
+        ...serviceName ? { serviceName } : {}
+      });
+    }
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   resolveAllConfiguredServices,

package/dist/services/types.d.ts

@@ -1,7 +1,7 @@
 import type { Route } from '@vercel/routing-utils';
-import type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, Service, Builder } from '@vercel/build-utils';
+import type { EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, Service, Builder, };
+export type { EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
 /**
  * @deprecated Use `Service` instead
  */
@@ -39,6 +39,7 @@ export type InferredServicesConfig = ExperimentalServices;
 export interface ResolvedServicesResult {
     services: Service[];
     source: DetectServicesSource;
+    useImplicitEnvInjection: boolean;
     routes: ServicesRoutes;
     errors: ServiceDetectionError[];
     warnings: ServiceDetectionWarning[];

package/dist/services/utils.d.ts

@@ -1,6 +1,6 @@
 import { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ServiceRuntime, ExperimentalServices, Services, ServiceDetectionError, ResolvedService } from './types';
+import type { EnvVars, ServiceRuntime, ExperimentalServices, Services, ServiceDetectionError, ResolvedService } from './types';
 export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, };
 export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
 export declare function isPublicServicesEnabled(): boolean;
@@ -59,6 +59,7 @@ export interface ReadVercelConfigResult {
     config: {
         services?: Services;
         experimentalServices?: ExperimentalServices;
+        env?: Record<string, string> | EnvVars;
     } | null;
     error: ServiceDetectionError | null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "6.2.2",
+  "version": "6.4.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,10 +20,10 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/routing-utils": "6.2.0",
-    "@vercel/build-utils": "13.23.0",
+    "@vercel/build-utils": "13.25.0",
+    "@vercel/frameworks": "3.26.1",
     "@vercel/error-utils": "2.1.0",
-    "@vercel/frameworks": "3.26.0"
+    "@vercel/routing-utils": "6.2.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",