@vercel/fs-detectors 6.5.0 → 6.6.0

package/dist/services/auto-detect.d.ts

@@ -1,7 +1,13 @@
+import type { DetectEntrypointFn } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
 import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface AutoDetectOptions {
     fs: DetectorFilesystem;
+    /**
+     * Optional callback used to enrich runtime services with a normalized
+     * entrypoint (file path or `module:attr` reference).
+     */
+    detectEntrypoint?: DetectEntrypointFn;
 }
 export interface AutoDetectResult {
     services: ExperimentalServices | null;

package/dist/services/auto-detect.js

@@ -30,7 +30,7 @@ const BACKEND_DIR = "backend";
 const SERVICES_DIR = "services";
 const FRONTEND_LOCATIONS = [FRONTEND_DIR, APPS_WEB_DIR];
 async function autoDetectServices(options) {
-  const { fs } = options;
+  const { fs, detectEntrypoint } = options;
   const rootFrameworks = await (0, import_detect_framework.detectFrameworks)({
     fs,
     frameworkList: import_frameworks.frameworkList
@@ -49,7 +49,7 @@ async function autoDetectServices(options) {
     };
   }
   if (rootFrameworks.length === 1) {
-    return detectServicesAtRoot(fs, rootFrameworks[0]);
+    return detectServicesAtRoot(fs, rootFrameworks[0], detectEntrypoint);
   }
   for (const frontendLocation of FRONTEND_LOCATIONS) {
     const hasFrontendDir = await fs.hasPath(frontendLocation);
@@ -78,7 +78,8 @@ async function autoDetectServices(options) {
       return detectServicesFrontendSubdir(
         fs,
         frontendFrameworks[0],
-        frontendLocation
+        frontendLocation,
+        detectEntrypoint
       );
     }
   }
@@ -93,13 +94,13 @@ async function autoDetectServices(options) {
     ]
   };
 }
-async function detectServicesAtRoot(fs, rootFramework) {
+async function detectServicesAtRoot(fs, rootFramework, detectEntrypoint) {
   const services = {};
   services.frontend = {
     framework: rootFramework.slug ?? void 0,
     routePrefix: "/"
   };
-  const backendResult = await detectBackendServices(fs);
+  const backendResult = await detectBackendServices(fs, detectEntrypoint);
   if (backendResult.error) {
     return {
       services: null,
@@ -121,15 +122,15 @@ async function detectServicesAtRoot(fs, rootFramework) {
     errors: []
   };
 }
-async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocation) {
+async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocation, detectEntrypoint) {
   const services = {};
   const serviceName = frontendLocation.split("/").pop() || "frontend";
   services[serviceName] = {
     framework: frontendFramework.slug ?? void 0,
-    entrypoint: frontendLocation,
+    root: frontendLocation,
     routePrefix: "/"
   };
-  const backendResult = await detectBackendServices(fs);
+  const backendResult = await detectBackendServices(fs, detectEntrypoint);
   if (backendResult.error) {
     return {
       services: null,
@@ -156,16 +157,24 @@ async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocat
     errors: []
   };
 }
-async function detectBackendServices(fs) {
+async function detectBackendServices(fs, detectEntrypoint) {
   const services = {};
-  const backendResult = await detectServiceInDir(fs, BACKEND_DIR, "backend");
+  const backendResult = await detectServiceInDir(
+    fs,
+    BACKEND_DIR,
+    "backend",
+    detectEntrypoint
+  );
   if (backendResult.error) {
     return { services: {}, error: backendResult.error };
   }
   if (backendResult.service) {
     services.backend = backendResult.service;
   }
-  const multiServicesResult = await detectServicesDirectory(fs);
+  const multiServicesResult = await detectServicesDirectory(
+    fs,
+    detectEntrypoint
+  );
   if (multiServicesResult.error) {
     return { services: {}, error: multiServicesResult.error };
   }
@@ -184,7 +193,7 @@ async function detectBackendServices(fs) {
   Object.assign(services, multiServicesResult.services);
   return { services };
 }
-async function detectServicesDirectory(fs) {
+async function detectServicesDirectory(fs, detectEntrypoint) {
   const services = {};
   const hasServicesDir = await fs.hasPath(SERVICES_DIR);
   if (!hasServicesDir) {
@@ -198,7 +207,12 @@ async function detectServicesDirectory(fs) {
     }
     const serviceName = entry.name;
     const serviceDir = `${SERVICES_DIR}/${serviceName}`;
-    const result = await detectServiceInDir(fs, serviceDir, serviceName);
+    const result = await detectServiceInDir(
+      fs,
+      serviceDir,
+      serviceName,
+      detectEntrypoint
+    );
     if (result.error) {
       return { services: {}, error: result.error };
     }
@@ -208,7 +222,7 @@ async function detectServicesDirectory(fs) {
   }
   return { services };
 }
-async function detectServiceInDir(fs, dirPath, serviceName) {
+async function detectServiceInDir(fs, dirPath, serviceName, detectEntrypoint) {
   const hasDirPath = await fs.hasPath(dirPath);
   if (!hasDirPath) {
     return {};
@@ -229,17 +243,21 @@ async function detectServiceInDir(fs, dirPath, serviceName) {
       }
     };
   }
-  if (frameworks.length === 1) {
-    const framework = frameworks[0];
-    return {
-      service: {
-        framework: framework.slug ?? void 0,
-        entrypoint: dirPath,
-        routePrefix: `/_/${serviceName}`
-      }
-    };
+  if (frameworks.length !== 1) {
+    return {};
   }
-  return {};
+  const framework = frameworks[0];
+  const slug = framework.slug ?? void 0;
+  const routePrefix = `/_/${serviceName}`;
+  const detected = detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug) ? await detectEntrypoint({ workPath: dirPath, framework: slug }) : null;
+  return {
+    service: {
+      framework: slug,
+      root: dirPath,
+      ...detected ? { entrypoint: detected.entrypoint } : {},
+      routePrefix
+    }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/services/detect-railway.d.ts

@@ -1,3 +1,4 @@
+import type { DetectEntrypointFn } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
 import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface RailwayDetectResult {
@@ -17,4 +18,5 @@ export interface RailwayDetectResult {
  */
 export declare function detectRailwayServices(options: {
     fs: DetectorFilesystem;
+    detectEntrypoint?: DetectEntrypointFn;
 }): Promise<RailwayDetectResult>;

package/dist/services/detect-railway.js

@@ -56,7 +56,7 @@ const SKIP_DIRS = /* @__PURE__ */ new Set([
   "CVS"
 ]);
 async function detectRailwayServices(options) {
-  const { fs } = options;
+  const { fs, detectEntrypoint } = options;
   const { configs, warnings } = await findRailwayConfigs(fs);
   if (configs.length === 0) {
     return { services: null, errors: [], warnings };
@@ -119,10 +119,20 @@ async function detectRailwayServices(options) {
       continue;
     }
     const framework = frameworks[0];
+    const slug = framework.slug ?? void 0;
     let serviceConfig = {};
-    serviceConfig.framework = framework.slug ?? void 0;
+    serviceConfig.framework = slug;
     if (cf.dirPath !== ".") {
-      serviceConfig.entrypoint = cf.dirPath;
+      serviceConfig.root = cf.dirPath;
+      if (detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug)) {
+        const detected = await detectEntrypoint({
+          workPath: cf.dirPath,
+          framework: slug
+        });
+        if (detected) {
+          serviceConfig.entrypoint = detected.entrypoint;
+        }
+      }
     }
     if (cf.config.build?.buildCommand) {
       serviceConfig.buildCommand = cf.config.build.buildCommand;

package/dist/services/detect-services.js

@@ -69,6 +69,9 @@ function toInferredLayoutConfig(services) {
     if (service.type) {
       serviceConfig.type = service.type;
     }
+    if (typeof service.root === "string") {
+      serviceConfig.root = service.root;
+    }
     if (typeof service.entrypoint === "string") {
       serviceConfig.entrypoint = service.entrypoint;
     }
@@ -89,7 +92,7 @@ function toInferredLayoutConfig(services) {
   return inferredConfig;
 }
 async function detectServices(options) {
-  const { fs, workPath } = options;
+  const { fs, workPath, detectEntrypoint } = options;
   const scopedFs = workPath ? fs.chdir(workPath) : fs;
   const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
   if (configError) {
@@ -113,7 +116,7 @@ async function detectServices(options) {
       { detect: import_auto_detect.autoDetectServices, source: "layout" }
     ];
     for (const { detect, source } of detectors) {
-      const detectResult = await detect({ fs: scopedFs });
+      const detectResult = await detect({ fs: scopedFs, detectEntrypoint });
       const match = await tryResolveInferred(detectResult, source, scopedFs);
       if (match)
         return match;

package/dist/services/types.d.ts

@@ -1,7 +1,7 @@
 import type { Route } from '@vercel/routing-utils';
-import type { EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
+import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
+export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
 /**
  * @deprecated Use `Service` instead
  */
@@ -13,6 +13,12 @@ export interface DetectServicesOptions {
      * If provided, vercel.json is read from this path.
      */
     workPath?: string;
+    /**
+     * Optional callback that, given a candidate service directory and its
+     * detected framework, returns a normalized entrypoint (file path or
+     * `module:attr` reference). Used to suggested service configs.
+     */
+    detectEntrypoint?: DetectEntrypointFn;
 }
 export interface ServicesRoutes {
     /** Host-based rewrite routes for subdomain-mounted web services */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "6.5.0",
+  "version": "6.6.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/error-utils": "2.1.0",
-    "@vercel/routing-utils": "6.2.0",
     "@vercel/build-utils": "13.26.0",
-    "@vercel/frameworks": "3.26.1"
+    "@vercel/error-utils": "2.1.0",
+    "@vercel/frameworks": "3.26.1",
+    "@vercel/routing-utils": "6.2.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",