@vercel/fs-detectors 5.8.15 → 5.8.16

package/dist/services/resolve.js

@@ -126,12 +126,14 @@ async function inferWorkspaceFromNearestManifest({
 async function detectFrameworkFromWorkspace({
   fs,
   workspace,
-  serviceName
+  serviceName,
+  runtime
 }) {
   const serviceFs = workspace === "." ? fs : fs.chdir(workspace);
+  const frameworkCandidates = (0, import_utils.filterFrameworksByRuntime)(import_frameworks.default, runtime);
   const frameworks = await (0, import_detect_framework.detectFrameworks)({
     fs: serviceFs,
-    frameworkList: import_frameworks.default
+    frameworkList: frameworkCandidates
   });
   if (frameworks.length > 1) {
     const frameworkNames = frameworks.map((f) => f.name).join(", ");
@@ -212,6 +214,16 @@ function validateServiceConfig(name, config) {
       serviceName: name
     };
   }
+  if (config.runtime && config.framework) {
+    const frameworkRuntime = (0, import_utils.inferRuntimeFromFramework)(config.framework);
+    if (frameworkRuntime && frameworkRuntime !== config.runtime) {
+      return {
+        code: "RUNTIME_FRAMEWORK_MISMATCH",
+        message: `Service "${name}" has conflicting runtime/framework: runtime "${config.runtime}" is incompatible with framework "${config.framework}" (runtime "${frameworkRuntime}").`,
+        serviceName: name
+      };
+    }
+  }
   const hasFramework = Boolean(config.framework);
   const hasBuilderOrRuntime = Boolean(config.builder || config.runtime);
   const hasEntrypoint = Boolean(config.entrypoint);
@@ -395,30 +407,56 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
       }
     }
     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.`,
+    if (!serviceConfig.framework && resolvedEntrypoint) {
+      if (resolvedEntrypoint.isDirectory) {
+        const workspace = resolvedEntrypoint.normalized;
+        const { framework, error } = await detectFrameworkFromWorkspace({
+          fs,
+          workspace,
           serviceName: name
         });
-        continue;
+        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 = {
+          ...resolvedConfig,
+          framework
+        };
+      } else {
+        const inferredRuntime = (0, import_utils.inferServiceRuntime)({
+          ...serviceConfig,
+          entrypoint: resolvedEntrypoint.normalized
+        });
+        if (inferredRuntime) {
+          const inferredWorkspace = await inferWorkspaceFromNearestManifest({
+            fs,
+            entrypoint: resolvedEntrypoint.normalized,
+            runtime: inferredRuntime
+          });
+          const workspace = inferredWorkspace ?? import_path.posix.dirname(resolvedEntrypoint.normalized);
+          const detection = await detectFrameworkFromWorkspace({
+            fs,
+            workspace,
+            serviceName: name,
+            runtime: inferredRuntime
+          });
+          if (detection.framework) {
+            resolvedConfig = {
+              ...resolvedConfig,
+              framework: detection.framework
+            };
+          }
+        }
       }
-      resolvedConfig = {
-        ...serviceConfig,
-        framework
-      };
     }
     const service = await resolveConfiguredService({
       name,

package/dist/services/utils.d.ts

@@ -17,6 +17,18 @@ export declare function isStaticBuild(service: ResolvedService): boolean;
  * rewrites for them — instead, we rely on the builder's own `routes[]`.
  */
 export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
+/**
+ * Infer runtime from a framework slug.
+ *
+ * Examples:
+ * - `python` -> `python`
+ * - `fastapi` -> `python`
+ * - `express` -> `node`
+ */
+export declare function inferRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
+export declare function filterFrameworksByRuntime<T extends {
+    slug?: string | null;
+}>(frameworks: readonly T[], runtime?: ServiceRuntime): T[];
 /**
  * Infer runtime from available service configuration.
  *

package/dist/services/utils.js

@@ -19,9 +19,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   INTERNAL_SERVICE_PREFIX: () => INTERNAL_SERVICE_PREFIX,
+  filterFrameworksByRuntime: () => filterFrameworksByRuntime,
   getBuilderForRuntime: () => getBuilderForRuntime,
   getInternalServiceFunctionPath: () => getInternalServiceFunctionPath,
   hasFile: () => hasFile,
+  inferRuntimeFromFramework: () => inferRuntimeFromFramework,
   inferServiceRuntime: () => inferServiceRuntime,
   isRouteOwningBuilder: () => isRouteOwningBuilder,
   isStaticBuild: () => isStaticBuild,
@@ -54,19 +56,37 @@ function isStaticBuild(service) {
 function isRouteOwningBuilder(service) {
   return import_types.ROUTE_OWNING_BUILDERS.has(service.builder.use);
 }
-function inferServiceRuntime(config) {
-  if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
-    return config.runtime;
+function inferRuntimeFromFramework(framework) {
+  if (!framework) {
+    return void 0;
   }
-  if (config.framework && config.framework in import_types.RUNTIME_BUILDERS) {
-    return config.framework;
+  if (framework in import_types.RUNTIME_BUILDERS) {
+    return framework;
   }
-  if ((0, import_framework_helpers.isPythonFramework)(config.framework)) {
+  if ((0, import_framework_helpers.isPythonFramework)(framework)) {
     return "python";
   }
-  if ((0, import_framework_helpers.isBackendFramework)(config.framework)) {
+  if ((0, import_framework_helpers.isBackendFramework)(framework)) {
     return "node";
   }
+  return void 0;
+}
+function filterFrameworksByRuntime(frameworks, runtime) {
+  if (!runtime) {
+    return [...frameworks];
+  }
+  return frameworks.filter(
+    (framework) => inferRuntimeFromFramework(framework.slug) === runtime
+  );
+}
+function inferServiceRuntime(config) {
+  if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
+    return config.runtime;
+  }
+  const frameworkRuntime = inferRuntimeFromFramework(config.framework);
+  if (frameworkRuntime) {
+    return frameworkRuntime;
+  }
   if (config.builder) {
     for (const [runtime, builderName] of Object.entries(import_types.RUNTIME_BUILDERS)) {
       if (config.builder === builderName) {
@@ -105,9 +125,11 @@ async function readVercelConfig(fs) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   INTERNAL_SERVICE_PREFIX,
+  filterFrameworksByRuntime,
   getBuilderForRuntime,
   getInternalServiceFunctionPath,
   hasFile,
+  inferRuntimeFromFramework,
   inferServiceRuntime,
   isRouteOwningBuilder,
   isStaticBuild,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.8.15",
+  "version": "5.8.16",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,8 +20,8 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/frameworks": "3.19.1",
-    "@vercel/routing-utils": "6.0.1"
+    "@vercel/frameworks": "3.20.0",
+    "@vercel/routing-utils": "6.0.2"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",