@vercel/fs-detectors 6.7.2 → 6.7.4

package/dist/detect-builders.js

@@ -95,11 +95,13 @@ async function detectBuilders(files, pkg, options = {}) {
   const { services, experimentalServices, projectSettings = {} } = options;
   const { framework } = projectSettings;
   const configuredServices = services ?? experimentalServices;
+  const configuredServicesType = services != null ? "services" : "experimentalServices";
   const hasServicesConfig = configuredServices != null && typeof configuredServices === "object";
   if (hasServicesConfig || framework === "services") {
     return (0, import_get_services_builders.getServicesBuilders)({
       workPath: options.workPath,
       configuredServices,
+      configuredServicesType,
       projectFramework: framework
     });
   }

package/dist/services/detect-services.js

@@ -44,12 +44,6 @@ 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,
@@ -92,7 +86,13 @@ function toInferredLayoutConfig(services) {
   return inferredConfig;
 }
 async function detectServices(options) {
-  const { fs, workPath, detectEntrypoint } = options;
+  const {
+    fs,
+    workPath,
+    detectEntrypoint,
+    configuredServices: providedConfiguredServices,
+    configuredServicesType
+  } = options;
   const scopedFs = workPath ? fs.chdir(workPath) : fs;
   const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
   if (configError) {
@@ -105,8 +105,9 @@ async function detectServices(options) {
       warnings: []
     });
   }
-  const hasNonEmptyPublicServicesConfig = vercelConfig?.services && Object.keys(vercelConfig.services).length > 0;
-  const configuredServices = hasNonEmptyPublicServicesConfig ? vercelConfig.services : vercelConfig?.experimentalServices;
+  const hasProvidedConfiguredServices = providedConfiguredServices && Object.keys(providedConfiguredServices).length > 0;
+  const hasNonEmptyPublicServicesConfig = hasProvidedConfiguredServices && configuredServicesType === "services" || !hasProvidedConfiguredServices && vercelConfig?.services && Object.keys(vercelConfig.services).length > 0;
+  const configuredServices = hasProvidedConfiguredServices ? providedConfiguredServices : hasNonEmptyPublicServicesConfig ? vercelConfig?.services : vercelConfig?.experimentalServices;
   const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
   if (!hasConfiguredServices) {
     const detectors = [
@@ -142,8 +143,7 @@ async function detectServices(options) {
     {
       requireFileEntrypointForBackendRuntimes: Boolean(
         hasNonEmptyPublicServicesConfig
-      ),
-      rootEnv: isEnvVars(vercelConfig?.env) ? vercelConfig?.env : void 0
+      )
     }
   );
   const routes = generateServicesRoutes(result.services);

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

@@ -1,6 +1,6 @@
 import type { Route } from '@vercel/routing-utils';
-import type { Builder, ExperimentalServices } from '@vercel/build-utils';
-import type { ResolvedService } from './types';
+import type { Builder } from '@vercel/build-utils';
+import type { ConfiguredServices, ResolvedService } from './types';
 export interface ErrorResponse {
     code: string;
     message: string;
@@ -9,7 +9,8 @@ export interface ErrorResponse {
 }
 export interface GetServicesBuildersOptions {
     workPath?: string;
-    configuredServices?: ExperimentalServices;
+    configuredServices?: ConfiguredServices;
+    configuredServicesType?: 'services' | 'experimentalServices';
     projectFramework?: string | null;
 }
 export interface ServicesBuildersResult {

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

@@ -28,7 +28,12 @@ function isExperimentalServicesAutoDetectionEnabled() {
   return env === "1" || env?.toLowerCase() === "true";
 }
 async function getServicesBuilders(options) {
-  const { workPath, configuredServices, projectFramework } = options;
+  const {
+    workPath,
+    configuredServices,
+    configuredServicesType,
+    projectFramework
+  } = options;
   const hasServiceDefinitions = configuredServices != null && Object.keys(configuredServices).length > 0;
   if (projectFramework === "services" && !hasServiceDefinitions && !isExperimentalServicesAutoDetectionEnabled()) {
     return {
@@ -67,7 +72,11 @@ async function getServicesBuilders(options) {
     };
   }
   const fs = new import_local_file_system_detector.LocalFileSystemDetector(workPath);
-  const result = await (0, import_detect_services.detectServices)({ fs });
+  const result = await (0, import_detect_services.detectServices)({
+    fs,
+    configuredServices,
+    configuredServicesType
+  });
   const warningResponses = result.warnings.map((w) => ({
     code: w.code,
     message: w.message

package/dist/services/resolve.d.ts

@@ -1,4 +1,4 @@
-import type { EnvVars, Service, ConfiguredServices, ExperimentalServiceConfig, ServiceConfig, ServiceDetectionError } from './types';
+import type { Service, ConfiguredServices, ExperimentalServiceConfig, ServiceConfig, ServiceDetectionError } from './types';
 import type { DetectorFilesystem } from '../detectors/filesystem';
 type ConfiguredServiceConfig = (ServiceConfig | ExperimentalServiceConfig) & Partial<ExperimentalServiceConfig>;
 interface ResolvedEntrypointPath {
@@ -18,12 +18,6 @@ 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

@@ -840,23 +840,12 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
   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 ?? {} };
-    }
+    validateEnvRefs(service.env, service.name, servicesByName, errors);
   }
   return { services: resolved, errors };
 }
-function validateEnvRefs(env, pathPrefix, servicesByName, errors, serviceName) {
+function validateEnvRefs(env, serviceName, servicesByName, errors) {
+  const pathPrefix = `Service "${serviceName}" env`;
   for (const [envVarName, envVar] of Object.entries(env)) {
     if (envVar.type !== "service-ref")
       continue;
@@ -866,7 +855,7 @@ function validateEnvRefs(env, pathPrefix, servicesByName, errors, serviceName) {
       errors.push({
         code: "UNKNOWN_SERVICE_REF",
         message: `${pathPrefix}["${envVarName}"] references unknown service "${refName}".`,
-        ...serviceName ? { serviceName } : {}
+        serviceName
       });
       continue;
     }
@@ -874,7 +863,7 @@ function validateEnvRefs(env, pathPrefix, servicesByName, errors, serviceName) {
       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 } : {}
+        serviceName
       });
     }
   }

package/dist/services/types.d.ts

@@ -8,6 +8,8 @@ export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, Ex
 export type ResolvedService = Service;
 export interface DetectServicesOptions {
     fs: DetectorFilesystem;
+    configuredServices?: ConfiguredServices;
+    configuredServicesType?: 'services' | 'experimentalServices';
     /**
      * Working directory path (relative to fs root).
      * If provided, vercel.json is read from this path.

package/dist/services/utils.d.ts

@@ -1,7 +1,7 @@
 import { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath } from '@vercel/build-utils';
 import type { Framework } from '@vercel/frameworks';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { EnvVars, ServiceRuntime, ExperimentalServices, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
+import type { ServiceRuntime, ExperimentalServices, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
 export declare const DETECTION_FRAMEWORKS: Framework[];
 export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, };
 export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
@@ -61,7 +61,6 @@ 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.7.2",
+  "version": "6.7.4",
   "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/build-utils": "13.26.3",
-    "@vercel/routing-utils": "6.2.0",
+    "@vercel/build-utils": "13.26.4",
+    "@vercel/error-utils": "2.1.0",
     "@vercel/frameworks": "3.26.1",
-    "@vercel/error-utils": "2.1.0"
+    "@vercel/routing-utils": "6.2.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",