@vercel/fs-detectors 5.11.1 → 5.11.3

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { autoDetectServices } from './services/auto-detect';
 export type { AutoDetectOptions, AutoDetectResult, } from './services/auto-detect';
 export { isStaticBuild, isRouteOwningBuilder, INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPath, getInternalServiceCronPathPrefix, getInternalServiceWorkerPath, getInternalServiceWorkerPathPrefix, } from './services/utils';
 export { getServicesBuilders } from './services/get-services-builders';
-export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, ResolvedService, Service, ServicesRoutes, ServiceDetectionError, } from './services/types';
+export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, ServicesConfig, ResolvedServicesResult, InferredServicesResult, ResolvedService, Service, ServicesRoutes, ServiceDetectionError, } from './services/types';
 export { detectFileSystemAPI } from './detect-file-system-api';
 export { detectFramework, detectFrameworks, detectFrameworkRecord, detectFrameworkVersion, } from './detect-framework';
 export { getProjectPaths } from './get-project-paths';

package/dist/services/auto-detect.js

@@ -100,13 +100,22 @@ async function detectServicesAtRoot(fs, rootFramework) {
   };
   const backendResult = await detectBackendServices(fs);
   if (backendResult.error) {
-    return { services: null, errors: [backendResult.error] };
+    return {
+      services: null,
+      errors: [backendResult.error]
+    };
   }
   if (Object.keys(backendResult.services).length === 0) {
-    return { services: null, errors: [] };
+    return {
+      services: null,
+      errors: []
+    };
   }
   Object.assign(services, backendResult.services);
-  return { services, errors: [] };
+  return {
+    services,
+    errors: []
+  };
 }
 async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocation) {
   const services = {};
@@ -118,7 +127,10 @@ async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocat
   };
   const backendResult = await detectBackendServices(fs);
   if (backendResult.error) {
-    return { services: null, errors: [backendResult.error] };
+    return {
+      services: null,
+      errors: [backendResult.error]
+    };
   }
   if (Object.keys(backendResult.services).length === 0) {
     return {
@@ -132,7 +144,10 @@ async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocat
     };
   }
   Object.assign(services, backendResult.services);
-  return { services, errors: [] };
+  return {
+    services,
+    errors: []
+  };
 }
 async function detectBackendServices(fs) {
   const services = {};

package/dist/services/detect-services.js

@@ -30,43 +30,68 @@ const PREVIEW_DOMAIN_MISSING = [
   { type: "host", value: { suf: ".vercel.app" } },
   { type: "host", value: { suf: ".vercel.dev" } }
 ];
+function emptyRoutes() {
+  return {
+    hostRewrites: [],
+    rewrites: [],
+    defaults: [],
+    crons: [],
+    workers: []
+  };
+}
+function withResolvedResult(resolved, inferred = null) {
+  return {
+    services: resolved.services,
+    source: resolved.source,
+    routes: resolved.routes,
+    errors: resolved.errors,
+    warnings: resolved.warnings,
+    resolved,
+    inferred
+  };
+}
+function toInferredLayoutConfig(services) {
+  const inferredConfig = {};
+  for (const [name, service] of Object.entries(services)) {
+    const serviceConfig = {};
+    if (typeof service.entrypoint === "string") {
+      serviceConfig.entrypoint = service.entrypoint;
+    }
+    if (typeof service.routePrefix === "string") {
+      serviceConfig.routePrefix = service.routePrefix;
+    }
+    if ((0, import_utils.isFrontendFramework)(service.framework)) {
+      serviceConfig.framework = service.framework;
+    }
+    inferredConfig[name] = serviceConfig;
+  }
+  return inferredConfig;
+}
 async function detectServices(options) {
   const { fs, workPath } = options;
   const scopedFs = workPath ? fs.chdir(workPath) : fs;
   const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
   if (configError) {
-    return {
+    return withResolvedResult({
       services: [],
       source: "configured",
-      routes: {
-        hostRewrites: [],
-        rewrites: [],
-        defaults: [],
-        crons: [],
-        workers: []
-      },
+      routes: emptyRoutes(),
       errors: [configError],
       warnings: []
-    };
+    });
   }
   const configuredServices = vercelConfig?.experimentalServices;
   const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
   if (!hasConfiguredServices) {
     const autoResult = await (0, import_auto_detect.autoDetectServices)({ fs: scopedFs });
     if (autoResult.errors.length > 0) {
-      return {
+      return withResolvedResult({
         services: [],
         source: "auto-detected",
-        routes: {
-          hostRewrites: [],
-          rewrites: [],
-          defaults: [],
-          crons: [],
-          workers: []
-        },
+        routes: emptyRoutes(),
         errors: autoResult.errors,
         warnings: []
-      };
+      });
     }
     if (autoResult.services) {
       const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
@@ -75,24 +100,28 @@ async function detectServices(options) {
         "generated"
       );
       const routes2 = generateServicesRoutes(result2.services);
-      return {
+      const resolved = {
         services: result2.services,
         source: "auto-detected",
         routes: routes2,
         errors: result2.errors,
         warnings: []
       };
+      const rootWebFrameworkServices = result2.services.filter(
+        (service) => service.type === "web" && service.routePrefix === "/" && typeof service.framework === "string"
+      );
+      const inferred = result2.errors.length === 0 && rootWebFrameworkServices.length === 1 && result2.services.length > 1 ? {
+        source: "layout",
+        config: toInferredLayoutConfig(autoResult.services),
+        services: result2.services,
+        warnings: []
+      } : null;
+      return withResolvedResult(resolved, inferred);
     }
-    return {
+    return withResolvedResult({
       services: [],
       source: "auto-detected",
-      routes: {
-        hostRewrites: [],
-        rewrites: [],
-        defaults: [],
-        crons: [],
-        workers: []
-      },
+      routes: emptyRoutes(),
       errors: [
         {
           code: "NO_SERVICES_CONFIGURED",
@@ -100,7 +129,7 @@ async function detectServices(options) {
         }
       ],
       warnings: []
-    };
+    });
   }
   const result = await (0, import_resolve.resolveAllConfiguredServices)(
     configuredServices,
@@ -108,13 +137,13 @@ async function detectServices(options) {
     "configured"
   );
   const routes = generateServicesRoutes(result.services);
-  return {
+  return withResolvedResult({
     services: result.services,
     source: "configured",
     routes,
     errors: result.errors,
     warnings: []
-  };
+  });
 }
 function generateServicesRoutes(services) {
   const hostRewrites = [];
@@ -188,7 +217,6 @@ function generateServicesRoutes(services) {
           check: true
         });
       }
-    } else {
     }
   }
   const workerServices = services.filter((s) => s.type === "worker");

package/dist/services/types.d.ts

@@ -32,18 +32,28 @@ export interface ServicesRoutes {
      */
     workers: Route[];
 }
-export interface DetectServicesResult {
+export type ServicesConfig = ExperimentalServices;
+export interface ResolvedServicesResult {
     services: Service[];
+    source: DetectServicesSource;
+    routes: ServicesRoutes;
+    errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+export interface InferredServicesResult {
+    source: 'layout' | 'procfile';
+    config: ServicesConfig;
+    services: Service[];
+    warnings: ServiceDetectionWarning[];
+}
+export interface DetectServicesResult extends ResolvedServicesResult {
     /**
      * Source of service definitions:
      * - `configured`: loaded from explicit project configuration (currently `vercel.json#experimentalServices`)
      * - `auto-detected`: inferred from project structure
      */
-    source: DetectServicesSource;
-    /** Routing rules derived from services */
-    routes: ServicesRoutes;
-    errors: ServiceDetectionError[];
-    warnings: ServiceDetectionWarning[];
+    resolved: ResolvedServicesResult;
+    inferred: InferredServicesResult | null;
 }
 export type DetectServicesSource = 'configured' | 'auto-detected';
 export interface ServiceDetectionWarning {

package/dist/services/utils.d.ts

@@ -34,6 +34,7 @@ export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
  * - `express` -> `node`
  */
 export declare function inferRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
+export declare function isFrontendFramework(framework: string | null | undefined): boolean;
 export declare function filterFrameworksByRuntime<T extends {
     slug?: string | null;
 }>(frameworks: readonly T[], runtime?: ServiceRuntime): T[];

package/dist/services/utils.js

@@ -30,6 +30,7 @@ __export(utils_exports, {
   hasFile: () => hasFile,
   inferRuntimeFromFramework: () => inferRuntimeFromFramework,
   inferServiceRuntime: () => inferServiceRuntime,
+  isFrontendFramework: () => isFrontendFramework,
   isRouteOwningBuilder: () => isRouteOwningBuilder,
   isStaticBuild: () => isStaticBuild,
   readVercelConfig: () => readVercelConfig
@@ -95,6 +96,12 @@ function inferRuntimeFromFramework(framework) {
   }
   return void 0;
 }
+function isFrontendFramework(framework) {
+  if (!framework) {
+    return false;
+  }
+  return !inferRuntimeFromFramework(framework);
+}
 function filterFrameworksByRuntime(frameworks, runtime) {
   if (!runtime) {
     return [...frameworks];
@@ -160,6 +167,7 @@ async function readVercelConfig(fs) {
   hasFile,
   inferRuntimeFromFramework,
   inferServiceRuntime,
+  isFrontendFramework,
   isRouteOwningBuilder,
   isStaticBuild,
   readVercelConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.11.1",
+  "version": "5.11.3",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,8 +20,9 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/frameworks": "3.21.1",
-    "@vercel/routing-utils": "6.0.2"
+    "@vercel/routing-utils": "6.0.2",
+    "@vercel/build-utils": "13.8.2",
+    "@vercel/frameworks": "3.21.1"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",
@@ -31,8 +32,7 @@
     "@types/node": "20.11.0",
     "@types/semver": "7.3.10",
     "jest-junit": "16.0.0",
-    "typescript": "4.9.5",
-    "@vercel/build-utils": "13.8.1"
+    "typescript": "4.9.5"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",