@vercel/fs-detectors 5.8.8 → 5.8.10

package/dist/services/auto-detect.js

@@ -38,6 +38,9 @@ const APPS_WEB_DIR = "apps/web";
 const BACKEND_DIR = "backend";
 const SERVICES_DIR = "services";
 const FRONTEND_LOCATIONS = [FRONTEND_DIR, APPS_WEB_DIR];
+const DETECTION_FRAMEWORKS = import_frameworks.default.filter(
+  (framework) => !framework.experimental || framework.runtimeFramework
+);
 async function autoDetectServices(options) {
   const { fs } = options;
   const rootFrameworks = await (0, import_detect_framework.detectFrameworks)({
@@ -117,7 +120,7 @@ async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocat
   const serviceName = frontendLocation.split("/").pop() || "frontend";
   services[serviceName] = {
     framework: frontendFramework.slug ?? void 0,
-    workspace: frontendLocation,
+    entrypoint: frontendLocation,
     routePrefix: "/"
   };
   const backendResult = await detectBackendServices(fs);
@@ -198,7 +201,8 @@ async function detectServiceInDir(fs, dirPath, serviceName) {
   const serviceFs = fs.chdir(dirPath);
   const frameworks = await (0, import_detect_framework.detectFrameworks)({
     fs: serviceFs,
-    frameworkList: import_frameworks.default
+    frameworkList: DETECTION_FRAMEWORKS,
+    useExperimentalFrameworks: true
   });
   if (frameworks.length > 1) {
     const frameworkNames = frameworks.map((f) => f.name).join(", ");
@@ -215,7 +219,7 @@ async function detectServiceInDir(fs, dirPath, serviceName) {
     return {
       service: {
         framework: framework.slug ?? void 0,
-        workspace: dirPath,
+        entrypoint: dirPath,
         routePrefix: `/_/${serviceName}`
       }
     };

package/dist/services/detect-services.js

@@ -53,7 +53,8 @@ async function detectServices(options) {
     if (autoResult.services) {
       const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
         autoResult.services,
-        scopedFs
+        scopedFs,
+        "generated"
       );
       const routes2 = generateServicesRoutes(result2.services);
       return {
@@ -77,7 +78,8 @@ async function detectServices(options) {
   }
   const result = await (0, import_resolve.resolveAllConfiguredServices)(
     configuredServices,
-    scopedFs
+    scopedFs,
+    "configured"
   );
   const routes = generateServicesRoutes(result.services);
   return {

package/dist/services/resolve.d.ts

@@ -1,18 +1,33 @@
 import type { Service, ExperimentalServiceConfig, ExperimentalServices, ServiceDetectionError } from './types';
 import type { DetectorFilesystem } from '../detectors/filesystem';
+interface ResolvedEntrypointPath {
+    normalized: string;
+    isDirectory: boolean;
+}
+type RoutePrefixSource = 'configured' | 'generated';
+interface ResolveConfiguredServiceOptions {
+    name: string;
+    config: ExperimentalServiceConfig;
+    fs: DetectorFilesystem;
+    group?: string;
+    resolvedEntrypoint?: ResolvedEntrypointPath;
+    routePrefixSource?: RoutePrefixSource;
+}
 /**
  * Validate a service configuration from vercel.json experimentalServices.
  */
 export declare function validateServiceConfig(name: string, config: ExperimentalServiceConfig): ServiceDetectionError | null;
+export declare function validateServiceEntrypoint(name: string, config: ExperimentalServiceConfig, resolvedEntrypoint: ResolvedEntrypointPath): ServiceDetectionError | null;
 /**
  * Resolve a single service from user configuration.
  */
-export declare function resolveConfiguredService(name: string, config: ExperimentalServiceConfig, fs: DetectorFilesystem, group?: string): Promise<Service>;
+export declare function resolveConfiguredService(options: ResolveConfiguredServiceOptions): Promise<Service>;
 /**
  * Resolve all services from vercel.json experimentalServices.
  * Validates each service configuration.
  */
-export declare function resolveAllConfiguredServices(services: ExperimentalServices, fs: DetectorFilesystem): Promise<{
+export declare function resolveAllConfiguredServices(services: ExperimentalServices, fs: DetectorFilesystem, routePrefixSource?: RoutePrefixSource): Promise<{
     services: Service[];
     errors: ServiceDetectionError[];
 }>;
+export {};

package/dist/services/resolve.js

@@ -30,16 +30,44 @@ var resolve_exports = {};
 __export(resolve_exports, {
   resolveAllConfiguredServices: () => resolveAllConfiguredServices,
   resolveConfiguredService: () => resolveConfiguredService,
-  validateServiceConfig: () => validateServiceConfig
+  validateServiceConfig: () => validateServiceConfig,
+  validateServiceEntrypoint: () => validateServiceEntrypoint
 });
 module.exports = __toCommonJS(resolve_exports);
 var import_path = require("path");
 var import_types = require("./types");
 var import_utils = require("./utils");
 var import_frameworks = __toESM(require("@vercel/frameworks"));
+var import_detect_framework = require("../detect-framework");
 var import_routing_utils = require("@vercel/routing-utils");
 const frameworksBySlug = new Map(import_frameworks.default.map((f) => [f.slug, f]));
 const SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+function normalizeServiceEntrypoint(entrypoint) {
+  const normalized = import_path.posix.normalize(entrypoint);
+  return normalized === "" ? "." : normalized;
+}
+async function resolveEntrypointPath({
+  fs,
+  serviceName,
+  entrypoint
+}) {
+  const normalized = normalizeServiceEntrypoint(entrypoint);
+  if (!await fs.hasPath(normalized)) {
+    return {
+      error: {
+        code: "ENTRYPOINT_NOT_FOUND",
+        message: `Service "${serviceName}" has entrypoint "${entrypoint}" but that path does not exist.`,
+        serviceName
+      }
+    };
+  }
+  return {
+    entrypoint: {
+      normalized,
+      isDirectory: !await fs.isFile(normalized)
+    }
+  };
+}
 function toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
   const normalizedEntrypoint = import_path.posix.normalize(entrypoint);
   if (workspace === ".") {
@@ -95,6 +123,33 @@ async function inferWorkspaceFromNearestManifest({
   }
   return void 0;
 }
+async function detectFrameworkFromWorkspace({
+  fs,
+  workspace,
+  serviceName
+}) {
+  const serviceFs = workspace === "." ? fs : fs.chdir(workspace);
+  const frameworks = await (0, import_detect_framework.detectFrameworks)({
+    fs: serviceFs,
+    frameworkList: import_frameworks.default
+  });
+  if (frameworks.length > 1) {
+    const frameworkNames = frameworks.map((f) => f.name).join(", ");
+    return {
+      error: {
+        code: "MULTIPLE_FRAMEWORKS_SERVICE",
+        message: `Multiple frameworks detected in ${workspace === "." ? "project root" : `${workspace}/`}: ${frameworkNames}. Specify "framework" explicitly in experimentalServices.`,
+        serviceName
+      }
+    };
+  }
+  if (frameworks.length === 1) {
+    return {
+      framework: frameworks[0].slug ?? void 0
+    };
+  }
+  return {};
+}
 function isReservedServiceRoutePrefix(routePrefix) {
   const normalized = (0, import_routing_utils.normalizeRoutePrefix)(routePrefix);
   return normalized === import_utils.INTERNAL_SERVICE_PREFIX || normalized.startsWith(`${import_utils.INTERNAL_SERVICE_PREFIX}/`);
@@ -174,7 +229,10 @@ function validateServiceConfig(name, config) {
       serviceName: name
     };
   }
-  if (hasEntrypoint && !hasBuilderOrRuntime && !hasFramework) {
+  return null;
+}
+function validateServiceEntrypoint(name, config, resolvedEntrypoint) {
+  if (!resolvedEntrypoint.isDirectory && !config.builder && !config.runtime && !config.framework) {
     const runtime = (0, import_utils.inferServiceRuntime)({ entrypoint: config.entrypoint });
     if (!runtime) {
       const supported = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).join(", ");
@@ -187,22 +245,52 @@ function validateServiceConfig(name, config) {
   }
   return null;
 }
-async function resolveConfiguredService(name, config, fs, group) {
+async function resolveConfiguredService(options) {
+  const {
+    name,
+    config,
+    fs,
+    group,
+    resolvedEntrypoint,
+    routePrefixSource = "configured"
+  } = options;
   const type = config.type || "web";
-  const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
-  let workspace = config.workspace || ".";
-  let resolvedEntrypoint = config.entrypoint;
-  if (!config.workspace) {
+  const rawEntrypoint = config.entrypoint;
+  let resolvedEntrypointPath = resolvedEntrypoint;
+  if (!resolvedEntrypointPath && typeof rawEntrypoint === "string") {
+    const resolved = await resolveEntrypointPath({
+      fs,
+      serviceName: name,
+      entrypoint: rawEntrypoint
+    });
+    resolvedEntrypointPath = resolved.entrypoint;
+  }
+  if (typeof rawEntrypoint === "string" && !resolvedEntrypointPath) {
+    throw new Error(
+      `Failed to resolve entrypoint "${rawEntrypoint}" for service "${name}".`
+    );
+  }
+  const normalizedEntrypoint = resolvedEntrypointPath?.normalized;
+  const entrypointIsDirectory = Boolean(resolvedEntrypointPath?.isDirectory);
+  const inferredRuntime = (0, import_utils.inferServiceRuntime)({
+    ...config,
+    entrypoint: entrypointIsDirectory ? void 0 : normalizedEntrypoint
+  });
+  let workspace = ".";
+  let resolvedEntrypointFile = entrypointIsDirectory || !normalizedEntrypoint ? void 0 : normalizedEntrypoint;
+  if (entrypointIsDirectory && normalizedEntrypoint) {
+    workspace = normalizedEntrypoint;
+  } else {
     const inferredWorkspace = await inferWorkspaceFromNearestManifest({
       fs,
-      entrypoint: resolvedEntrypoint,
+      entrypoint: resolvedEntrypointFile,
       runtime: inferredRuntime
     });
     if (inferredWorkspace) {
       workspace = inferredWorkspace;
-      if (resolvedEntrypoint) {
-        resolvedEntrypoint = toWorkspaceRelativeEntrypoint(
-          resolvedEntrypoint,
+      if (resolvedEntrypointFile) {
+        resolvedEntrypointFile = toWorkspaceRelativeEntrypoint(
+          resolvedEntrypointFile,
           inferredWorkspace
         );
       }
@@ -215,13 +303,13 @@ async function resolveConfiguredService(name, config, fs, group) {
   if (config.framework) {
     const framework = frameworksBySlug.get(config.framework);
     builderUse = framework?.useRuntime?.use || "@vercel/static-build";
-    builderSrc = resolvedEntrypoint || framework?.useRuntime?.src || "package.json";
+    builderSrc = resolvedEntrypointFile || framework?.useRuntime?.src || "package.json";
   } else if (config.builder) {
     builderUse = config.builder;
-    builderSrc = resolvedEntrypoint;
+    builderSrc = resolvedEntrypointFile;
   } else {
     builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
-    builderSrc = resolvedEntrypoint;
+    builderSrc = resolvedEntrypointFile;
   }
   const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
   const isRoot = workspace === ".";
@@ -254,8 +342,9 @@ async function resolveConfiguredService(name, config, fs, group) {
     type,
     group,
     workspace,
-    entrypoint: resolvedEntrypoint,
+    entrypoint: resolvedEntrypointFile,
     routePrefix,
+    routePrefixSource: type === "web" && typeof routePrefix === "string" ? routePrefixSource : void 0,
     framework: config.framework,
     builder: {
       src: builderSrc,
@@ -270,7 +359,7 @@ async function resolveConfiguredService(name, config, fs, group) {
     consumer
   };
 }
-async function resolveAllConfiguredServices(services, fs) {
+async function resolveAllConfiguredServices(services, fs, routePrefixSource = "configured") {
   const resolved = [];
   const errors = [];
   const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
@@ -281,7 +370,63 @@ async function resolveAllConfiguredServices(services, fs) {
       errors.push(validationError);
       continue;
     }
-    const service = await resolveConfiguredService(name, serviceConfig, fs);
+    let resolvedEntrypoint;
+    if (typeof serviceConfig.entrypoint === "string") {
+      const resolvedPath = await resolveEntrypointPath({
+        fs,
+        serviceName: name,
+        entrypoint: serviceConfig.entrypoint
+      });
+      if (resolvedPath.error) {
+        errors.push(resolvedPath.error);
+        continue;
+      }
+      resolvedEntrypoint = resolvedPath.entrypoint;
+    }
+    if (resolvedEntrypoint) {
+      const entrypointError = validateServiceEntrypoint(
+        name,
+        serviceConfig,
+        resolvedEntrypoint
+      );
+      if (entrypointError) {
+        errors.push(entrypointError);
+        continue;
+      }
+    }
+    let resolvedConfig = serviceConfig;
+    const shouldDetectFramework = !serviceConfig.framework && Boolean(resolvedEntrypoint?.isDirectory);
+    if (shouldDetectFramework) {
+      const workspace = resolvedEntrypoint.normalized;
+      const { framework, error } = await detectFrameworkFromWorkspace({
+        fs,
+        workspace,
+        serviceName: name
+      });
+      if (error) {
+        errors.push(error);
+        continue;
+      }
+      if (!framework) {
+        errors.push({
+          code: "MISSING_SERVICE_FRAMEWORK",
+          message: `Service "${name}" uses directory entrypoint "${serviceConfig.entrypoint}" but no framework could be detected in "${workspace}". Specify "framework" explicitly or use a file entrypoint.`,
+          serviceName: name
+        });
+        continue;
+      }
+      resolvedConfig = {
+        ...serviceConfig,
+        framework
+      };
+    }
+    const service = await resolveConfiguredService({
+      name,
+      config: resolvedConfig,
+      fs,
+      resolvedEntrypoint,
+      routePrefixSource
+    });
     if (service.type === "web" && typeof service.routePrefix === "string") {
       const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix);
       const existingServiceName = webServicesByRoutePrefix.get(
@@ -305,5 +450,6 @@ async function resolveAllConfiguredServices(services, fs) {
 0 && (module.exports = {
   resolveAllConfiguredServices,
   resolveConfiguredService,
-  validateServiceConfig
+  validateServiceConfig,
+  validateServiceEntrypoint
 });

package/dist/services/utils.d.ts

@@ -22,9 +22,10 @@ export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
  *
  * Priority (highest to lowest):
  * 1. Explicit runtime (user specified in config)
- * 2. Framework detection (fastapi → python, express → node)
- * 3. Builder detection (@vercel/python → python)
- * 4. Entrypoint extension (.py → python, .ts → node)
+ * 2. Runtime framework slug (ruby → ruby, go → go)
+ * 3. Framework detection (fastapi → python, express → node)
+ * 4. Builder detection (@vercel/python → python)
+ * 5. Entrypoint extension (.py → python, .ts → node)
  *
  * @returns The inferred runtime, or undefined if none can be determined.
  */

package/dist/services/utils.js

@@ -58,6 +58,9 @@ function inferServiceRuntime(config) {
   if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
     return config.runtime;
   }
+  if (config.framework && config.framework in import_types.RUNTIME_BUILDERS) {
+    return config.framework;
+  }
   if ((0, import_framework_helpers.isPythonFramework)(config.framework)) {
     return "python";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.8.8",
+  "version": "5.8.10",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,8 +19,8 @@
     "json5": "2.2.2",
     "minimatch": "3.1.2",
     "semver": "6.3.1",
-    "@vercel/frameworks": "3.18.0",
     "@vercel/error-utils": "2.0.3",
+    "@vercel/frameworks": "3.19.0",
     "@vercel/routing-utils": "5.3.3"
   },
   "devDependencies": {
@@ -32,7 +32,7 @@
     "@types/semver": "7.3.10",
     "jest-junit": "16.0.0",
     "typescript": "4.9.5",
-    "@vercel/build-utils": "13.4.1"
+    "@vercel/build-utils": "13.5.0"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",