@vercel/fs-detectors 5.8.6 → 5.8.7

package/dist/services/detect-services.js

@@ -51,7 +51,10 @@ async function detectServices(options) {
       };
     }
     if (autoResult.services) {
-      const result2 = (0, import_resolve.resolveAllConfiguredServices)(autoResult.services);
+      const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
+        autoResult.services,
+        scopedFs
+      );
       const routes2 = generateServicesRoutes(result2.services);
       return {
         services: result2.services,
@@ -72,7 +75,10 @@ async function detectServices(options) {
       warnings: []
     };
   }
-  const result = (0, import_resolve.resolveAllConfiguredServices)(configuredServices);
+  const result = await (0, import_resolve.resolveAllConfiguredServices)(
+    configuredServices,
+    scopedFs
+  );
   const routes = generateServicesRoutes(result.services);
   return {
     services: result.services,

package/dist/services/resolve.d.ts

@@ -1,4 +1,5 @@
-import type { ResolvedService, ExperimentalServiceConfig, ExperimentalServices, ServiceDetectionError } from './types';
+import type { Service, ExperimentalServiceConfig, ExperimentalServices, ServiceDetectionError } from './types';
+import type { DetectorFilesystem } from '../detectors/filesystem';
 /**
  * Validate a service configuration from vercel.json experimentalServices.
  */
@@ -6,12 +7,12 @@ export declare function validateServiceConfig(name: string, config: Experimental
 /**
  * Resolve a single service from user configuration.
  */
-export declare function resolveConfiguredService(name: string, config: ExperimentalServiceConfig, group?: string): ResolvedService;
+export declare function resolveConfiguredService(name: string, config: ExperimentalServiceConfig, fs: DetectorFilesystem, group?: string): Promise<Service>;
 /**
  * Resolve all services from vercel.json experimentalServices.
  * Validates each service configuration.
  */
-export declare function resolveAllConfiguredServices(services: ExperimentalServices): {
-    services: ResolvedService[];
+export declare function resolveAllConfiguredServices(services: ExperimentalServices, fs: DetectorFilesystem): Promise<{
+    services: Service[];
     errors: ServiceDetectionError[];
-};
+}>;

package/dist/services/resolve.js

@@ -40,6 +40,61 @@ var import_frameworks = __toESM(require("@vercel/frameworks"));
 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 toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
+  const normalizedEntrypoint = import_path.posix.normalize(entrypoint);
+  if (workspace === ".") {
+    return normalizedEntrypoint;
+  }
+  const workspacePrefix = `${workspace}/`;
+  if (normalizedEntrypoint.startsWith(workspacePrefix)) {
+    return normalizedEntrypoint.slice(workspacePrefix.length);
+  }
+  const relativeEntrypoint = import_path.posix.relative(
+    workspace,
+    normalizedEntrypoint
+  );
+  if (relativeEntrypoint === "" || relativeEntrypoint.startsWith("..")) {
+    return normalizedEntrypoint;
+  }
+  return relativeEntrypoint;
+}
+async function inferWorkspaceFromNearestManifest({
+  fs,
+  entrypoint,
+  runtime
+}) {
+  if (!entrypoint || !runtime) {
+    return void 0;
+  }
+  const manifests = import_types.RUNTIME_MANIFESTS[runtime];
+  if (!manifests || manifests.length === 0) {
+    return void 0;
+  }
+  let dir = import_path.posix.dirname(import_path.posix.normalize(entrypoint)) || ".";
+  if (dir === "") {
+    dir = ".";
+  }
+  let reachedRoot = false;
+  while (!reachedRoot) {
+    for (const manifest of manifests) {
+      const manifestPath = dir === "." ? manifest : import_path.posix.join(dir, manifest);
+      if (await (0, import_utils.hasFile)(fs, manifestPath)) {
+        return dir;
+      }
+    }
+    if (dir === "." || dir === "/") {
+      reachedRoot = true;
+    } else {
+      const parent = import_path.posix.dirname(dir);
+      if (!parent || parent === dir) {
+        reachedRoot = true;
+      } else {
+        dir = parent;
+      }
+    }
+  }
+  return void 0;
+}
 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}/`);
@@ -132,24 +187,41 @@ function validateServiceConfig(name, config) {
   }
   return null;
 }
-function resolveConfiguredService(name, config, group) {
+async function resolveConfiguredService(name, config, fs, group) {
   const type = config.type || "web";
-  const workspace = config.workspace || ".";
+  const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
+  let workspace = config.workspace || ".";
+  let resolvedEntrypoint = config.entrypoint;
+  if (!config.workspace) {
+    const inferredWorkspace = await inferWorkspaceFromNearestManifest({
+      fs,
+      entrypoint: resolvedEntrypoint,
+      runtime: inferredRuntime
+    });
+    if (inferredWorkspace) {
+      workspace = inferredWorkspace;
+      if (resolvedEntrypoint) {
+        resolvedEntrypoint = toWorkspaceRelativeEntrypoint(
+          resolvedEntrypoint,
+          inferredWorkspace
+        );
+      }
+    }
+  }
   const topic = type === "worker" ? config.topic || "default" : config.topic;
   const consumer = type === "worker" ? config.consumer || "default" : config.consumer;
-  const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
   let builderUse;
   let builderSrc;
   if (config.framework) {
     const framework = frameworksBySlug.get(config.framework);
     builderUse = framework?.useRuntime?.use || "@vercel/static-build";
-    builderSrc = config.entrypoint || framework?.useRuntime?.src || "package.json";
+    builderSrc = resolvedEntrypoint || framework?.useRuntime?.src || "package.json";
   } else if (config.builder) {
     builderUse = config.builder;
-    builderSrc = config.entrypoint;
+    builderSrc = resolvedEntrypoint;
   } else {
     builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
-    builderSrc = config.entrypoint;
+    builderSrc = resolvedEntrypoint;
   }
   const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
   const isRoot = workspace === ".";
@@ -182,7 +254,7 @@ function resolveConfiguredService(name, config, group) {
     type,
     group,
     workspace,
-    entrypoint: config.entrypoint,
+    entrypoint: resolvedEntrypoint,
     routePrefix,
     framework: config.framework,
     builder: {
@@ -198,7 +270,7 @@ function resolveConfiguredService(name, config, group) {
     consumer
   };
 }
-function resolveAllConfiguredServices(services) {
+async function resolveAllConfiguredServices(services, fs) {
   const resolved = [];
   const errors = [];
   const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
@@ -209,7 +281,7 @@ function resolveAllConfiguredServices(services) {
       errors.push(validationError);
       continue;
     }
-    const service = resolveConfiguredService(name, serviceConfig);
+    const service = await resolveConfiguredService(name, serviceConfig, fs);
     if (service.type === "web" && typeof service.routePrefix === "string") {
       const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix);
       const existingServiceName = webServicesByRoutePrefix.get(

package/dist/services/types.d.ts

@@ -33,7 +33,7 @@ export interface ServicesRoutes {
     workers: Route[];
 }
 export interface DetectServicesResult {
-    services: ResolvedService[];
+    services: Service[];
     /** Routing rules derived from services */
     routes: ServicesRoutes;
     errors: ServiceDetectionError[];
@@ -50,6 +50,7 @@ export interface ServiceDetectionError {
     serviceName?: string;
 }
 export declare const RUNTIME_BUILDERS: Record<ServiceRuntime, string>;
+export declare const RUNTIME_MANIFESTS: Partial<Record<ServiceRuntime, string[]>>;
 export declare const ENTRYPOINT_EXTENSIONS: Record<string, ServiceRuntime>;
 /**
  * Builders that produce static output (SPAs, static sites).

package/dist/services/types.js

@@ -21,6 +21,7 @@ __export(types_exports, {
   ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
   ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
   RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
+  RUNTIME_MANIFESTS: () => RUNTIME_MANIFESTS,
   STATIC_BUILDERS: () => STATIC_BUILDERS
 });
 module.exports = __toCommonJS(types_exports);
@@ -31,6 +32,20 @@ const RUNTIME_BUILDERS = {
   rust: "@vercel/rust",
   ruby: "@vercel/ruby"
 };
+const RUNTIME_MANIFESTS = {
+  node: ["package.json"],
+  python: [
+    "pyproject.toml",
+    "requirements.txt",
+    "Pipfile",
+    "pylock.yml",
+    "uv.lock",
+    "setup.py"
+  ],
+  go: ["go.mod"],
+  ruby: ["Gemfile"],
+  rust: ["Cargo.toml"]
+};
 const ENTRYPOINT_EXTENSIONS = {
   ".ts": "node",
   ".mts": "node",
@@ -56,5 +71,6 @@ const ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
   ENTRYPOINT_EXTENSIONS,
   ROUTE_OWNING_BUILDERS,
   RUNTIME_BUILDERS,
+  RUNTIME_MANIFESTS,
   STATIC_BUILDERS
 });

package/dist/services/utils.d.ts

@@ -1,5 +1,6 @@
 import type { DetectorFilesystem } from '../detectors/filesystem';
 import type { ServiceRuntime, ExperimentalServices, ServiceDetectionError, ResolvedService } from './types';
+export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
 /**
  * Reserved internal namespace used by services routing/runtime plumbing.
  */

package/dist/services/utils.js

@@ -21,6 +21,7 @@ __export(utils_exports, {
   INTERNAL_SERVICE_PREFIX: () => INTERNAL_SERVICE_PREFIX,
   getBuilderForRuntime: () => getBuilderForRuntime,
   getInternalServiceFunctionPath: () => getInternalServiceFunctionPath,
+  hasFile: () => hasFile,
   inferServiceRuntime: () => inferServiceRuntime,
   isRouteOwningBuilder: () => isRouteOwningBuilder,
   isStaticBuild: () => isStaticBuild,
@@ -29,6 +30,13 @@ __export(utils_exports, {
 module.exports = __toCommonJS(utils_exports);
 var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
 var import_types = require("./types");
+async function hasFile(fs, filePath) {
+  try {
+    return await fs.isFile(filePath);
+  } catch {
+    return false;
+  }
+}
 const INTERNAL_SERVICE_PREFIX = "/_svc";
 function getInternalServiceFunctionPath(serviceName) {
   return `${INTERNAL_SERVICE_PREFIX}/${serviceName}/index`;
@@ -96,6 +104,7 @@ async function readVercelConfig(fs) {
   INTERNAL_SERVICE_PREFIX,
   getBuilderForRuntime,
   getInternalServiceFunctionPath,
+  hasFile,
   inferServiceRuntime,
   isRouteOwningBuilder,
   isStaticBuild,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.8.6",
+  "version": "5.8.7",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,9 +19,9 @@
     "json5": "2.2.2",
     "minimatch": "3.1.2",
     "semver": "6.3.1",
-    "@vercel/routing-utils": "5.3.3",
+    "@vercel/error-utils": "2.0.3",
     "@vercel/frameworks": "3.17.1",
-    "@vercel/error-utils": "2.0.3"
+    "@vercel/routing-utils": "5.3.3"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",