@vercel/fs-detectors 5.7.21 → 5.8.0

package/dist/detect-builders.d.ts

@@ -1,5 +1,5 @@
 import type { Route } from '@vercel/routing-utils';
-import type { PackageJson, Builder, BuilderFunctions, ProjectSettings } from '@vercel/build-utils';
+import type { PackageJson, Builder, BuilderFunctions, ProjectSettings, Service } from '@vercel/build-utils';
 /**
  * Pattern for finding all supported middleware files.
  */
@@ -41,4 +41,5 @@ export declare function detectBuilders(files: string[], pkg?: PackageJson | unde
     redirectRoutes: Route[] | null;
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
+    services?: Service[];
 }>;

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExtensions, type Options as DetectBuildersOptions, } from './detect-builders';
 export { detectServices, generateServicesRoutes, } from './services/detect-services';
+export { autoDetectServices } from './services/auto-detect';
+export type { AutoDetectOptions, AutoDetectResult, } from './services/auto-detect';
+export { isStaticBuild } from './services/utils';
 export { getServicesBuilders } from './services/get-services-builders';
 export type { DetectServicesOptions, DetectServicesResult, ResolvedService, ServicesRoutes, ServiceDetectionError, } from './services/types';
 export { detectFileSystemAPI } from './detect-file-system-api';

package/dist/index.js

@@ -26,6 +26,7 @@ __export(src_exports, {
   REGEX_NON_VERCEL_PLATFORM_FILES: () => import_detect_builders2.REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace: () => import_get_workspaces.Workspace,
   WorkspaceType: () => import_get_workspaces.WorkspaceType,
+  autoDetectServices: () => import_auto_detect.autoDetectServices,
   detectApiDirectory: () => import_detect_builders.detectApiDirectory,
   detectApiExtensions: () => import_detect_builders.detectApiExtensions,
   detectBuilders: () => import_detect_builders.detectBuilders,
@@ -43,6 +44,7 @@ __export(src_exports, {
   getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
   getWorkspaces: () => import_get_workspaces.getWorkspaces,
   isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
+  isStaticBuild: () => import_utils.isStaticBuild,
   isStaticRuntime: () => import_is_official_runtime.isStaticRuntime,
   monorepoManagers: () => import_monorepo_managers.monorepoManagers,
   packageManagers: () => import_package_managers.packageManagers,
@@ -51,6 +53,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_detect_builders = require("./detect-builders");
 var import_detect_services = require("./services/detect-services");
+var import_auto_detect = require("./services/auto-detect");
+var import_utils = require("./services/utils");
 var import_get_services_builders = require("./services/get-services-builders");
 var import_detect_file_system_api = require("./detect-file-system-api");
 var import_detect_framework = require("./detect-framework");
@@ -75,6 +79,7 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace,
   WorkspaceType,
+  autoDetectServices,
   detectApiDirectory,
   detectApiExtensions,
   detectBuilders,
@@ -92,6 +97,7 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   getWorkspacePackagePaths,
   getWorkspaces,
   isOfficialRuntime,
+  isStaticBuild,
   isStaticRuntime,
   monorepoManagers,
   packageManagers,

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

@@ -0,0 +1,39 @@
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { ExperimentalServices, ServiceDetectionError } from './types';
+export interface AutoDetectOptions {
+    fs: DetectorFilesystem;
+}
+export interface AutoDetectResult {
+    services: ExperimentalServices | null;
+    errors: ServiceDetectionError[];
+}
+/**
+ * Auto-detect services when experimentalServices is not configured.
+ *
+ * Scans the project for frameworks, supporting multiple layouts:
+ *
+ * Frontend at root, backend in backend/:
+ *   project/
+ *   ├── package.json
+ *   └── backend/
+ *
+ * Frontend in frontend/, backend in backend/:
+ *   project/
+ *   ├── frontend/
+ *   └── backend/
+ *
+ * Frontend in frontend/, backend in services/{service-name}/:
+ *   project/
+ *   ├── frontend/
+ *   └── services/
+ *       ├── service-a/
+ *       └── service-b/
+ *
+ * Frontend in apps/web/ monorepo, backend in services/{service-name}/:
+ *   project/
+ *   ├── apps/web/
+ *   └── services/
+ *       ├── service-a/
+ *       └── service-b/
+ */
+export declare function autoDetectServices(options: AutoDetectOptions): Promise<AutoDetectResult>;

package/dist/services/auto-detect.js

@@ -0,0 +1,228 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var auto_detect_exports = {};
+__export(auto_detect_exports, {
+  autoDetectServices: () => autoDetectServices
+});
+module.exports = __toCommonJS(auto_detect_exports);
+var import_detect_framework = require("../detect-framework");
+var import_frameworks = __toESM(require("@vercel/frameworks"));
+const FRONTEND_DIR = "frontend";
+const APPS_WEB_DIR = "apps/web";
+const BACKEND_DIR = "backend";
+const SERVICES_DIR = "services";
+const FRONTEND_LOCATIONS = [FRONTEND_DIR, APPS_WEB_DIR];
+async function autoDetectServices(options) {
+  const { fs } = options;
+  const rootFrameworks = await (0, import_detect_framework.detectFrameworks)({
+    fs,
+    frameworkList: import_frameworks.default
+  });
+  if (rootFrameworks.length > 1) {
+    const frameworkNames = rootFrameworks.map((f) => f.name).join(", ");
+    return {
+      services: null,
+      errors: [
+        {
+          code: "MULTIPLE_FRAMEWORKS_ROOT",
+          message: `Multiple frameworks detected at root: ${frameworkNames}. Use explicit experimentalServices config.`
+        }
+      ]
+    };
+  }
+  if (rootFrameworks.length === 1) {
+    return detectServicesAtRoot(fs, rootFrameworks[0]);
+  }
+  for (const frontendLocation of FRONTEND_LOCATIONS) {
+    const hasFrontendDir = await fs.hasPath(frontendLocation);
+    if (!hasFrontendDir) {
+      continue;
+    }
+    const frontendFs = fs.chdir(frontendLocation);
+    const frontendFrameworks = await (0, import_detect_framework.detectFrameworks)({
+      fs: frontendFs,
+      frameworkList: import_frameworks.default
+    });
+    if (frontendFrameworks.length > 1) {
+      const frameworkNames = frontendFrameworks.map((f) => f.name).join(", ");
+      return {
+        services: null,
+        errors: [
+          {
+            code: "MULTIPLE_FRAMEWORKS_SERVICE",
+            message: `Multiple frameworks detected in ${frontendLocation}/: ${frameworkNames}. Use explicit experimentalServices config.`
+          }
+        ]
+      };
+    }
+    if (frontendFrameworks.length === 1) {
+      return detectServicesFrontendSubdir(
+        fs,
+        frontendFrameworks[0],
+        frontendLocation
+      );
+    }
+  }
+  return {
+    services: null,
+    errors: [
+      {
+        code: "NO_SERVICES_CONFIGURED",
+        message: "No services detected. Configure experimentalServices in vercel.json or ensure a framework exists at project root, frontend/, or apps/web/."
+      }
+    ]
+  };
+}
+async function detectServicesAtRoot(fs, rootFramework) {
+  const services = {};
+  services.frontend = {
+    framework: rootFramework.slug ?? void 0,
+    routePrefix: "/"
+  };
+  const backendResult = await detectBackendServices(fs);
+  if (backendResult.error) {
+    return { services: null, errors: [backendResult.error] };
+  }
+  Object.assign(services, backendResult.services);
+  return { services, errors: [] };
+}
+async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocation) {
+  const services = {};
+  const serviceName = frontendLocation.split("/").pop() || "frontend";
+  services[serviceName] = {
+    framework: frontendFramework.slug ?? void 0,
+    workspace: frontendLocation,
+    routePrefix: "/"
+  };
+  const backendResult = await detectBackendServices(fs);
+  if (backendResult.error) {
+    return { services: null, errors: [backendResult.error] };
+  }
+  if (Object.keys(backendResult.services).length === 0) {
+    return {
+      services: null,
+      errors: [
+        {
+          code: "NO_BACKEND_SERVICES",
+          message: `Frontend detected in ${frontendLocation}/ but no backend services found. Add a backend/ or services/ directory with a supported framework.`
+        }
+      ]
+    };
+  }
+  Object.assign(services, backendResult.services);
+  return { services, errors: [] };
+}
+async function detectBackendServices(fs) {
+  const services = {};
+  const backendResult = await detectServiceInDir(fs, BACKEND_DIR, "backend");
+  if (backendResult.error) {
+    return { services: {}, error: backendResult.error };
+  }
+  if (backendResult.service) {
+    services.backend = backendResult.service;
+  }
+  const multiServicesResult = await detectServicesDirectory(fs);
+  if (multiServicesResult.error) {
+    return { services: {}, error: multiServicesResult.error };
+  }
+  for (const serviceName of Object.keys(multiServicesResult.services)) {
+    if (services[serviceName]) {
+      return {
+        services: {},
+        error: {
+          code: "SERVICE_NAME_CONFLICT",
+          message: `Service name conflict: "${serviceName}" exists in both ${BACKEND_DIR}/ and ${SERVICES_DIR}/${serviceName}/. Rename one of the directories or use explicit experimentalServices config.`,
+          serviceName
+        }
+      };
+    }
+  }
+  Object.assign(services, multiServicesResult.services);
+  return { services };
+}
+async function detectServicesDirectory(fs) {
+  const services = {};
+  const hasServicesDir = await fs.hasPath(SERVICES_DIR);
+  if (!hasServicesDir) {
+    return { services };
+  }
+  const servicesFs = fs.chdir(SERVICES_DIR);
+  const entries = await servicesFs.readdir("/");
+  for (const entry of entries) {
+    if (entry.type !== "dir") {
+      continue;
+    }
+    const serviceName = entry.name;
+    const serviceDir = `${SERVICES_DIR}/${serviceName}`;
+    const result = await detectServiceInDir(fs, serviceDir, serviceName);
+    if (result.error) {
+      return { services: {}, error: result.error };
+    }
+    if (result.service) {
+      services[serviceName] = result.service;
+    }
+  }
+  return { services };
+}
+async function detectServiceInDir(fs, dirPath, serviceName) {
+  const hasDirPath = await fs.hasPath(dirPath);
+  if (!hasDirPath) {
+    return {};
+  }
+  const serviceFs = fs.chdir(dirPath);
+  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 ${dirPath}/: ${frameworkNames}. Use explicit experimentalServices config.`,
+        serviceName
+      }
+    };
+  }
+  if (frameworks.length === 1) {
+    const framework = frameworks[0];
+    return {
+      service: {
+        framework: framework.slug ?? void 0,
+        workspace: dirPath,
+        routePrefix: `/_/${serviceName}`
+      }
+    };
+  }
+  return {};
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoDetectServices
+});

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

@@ -9,11 +9,12 @@ export declare function detectServices(options: DetectServicesOptions): Promise<
 /**
  * Generate routing rules for services.
  *
- * Web services: Routes are ordered by prefix length (longest first) to ensure
- * more specific routes match before broader ones. For example, `/api/users`
- * must be checked before `/api`, which must be checked before the catch-all `/`.
+ * Routes are ordered by prefix length (longest first) to ensure more specific
+ * routes match before broader ones. For example, `/api/users` must be checked
+ * before `/api`, which must be checked before the catch-all `/`.
  *
- * Cron/Worker services: TODO
- * Use internal routes under `/_svc/crons` and `/_svc/workers`
+ * - Static/SPA services: SPA fallback routes to index.html
+ * - Serverless services: Rewrite to the function entrypoint
+ * - Cron/Worker services: TODO - internal routes under `/_svc/`
  */
 export declare function generateServicesRoutes(services: ResolvedService[]): ServicesRoutes;

package/dist/services/detect-services.js

@@ -24,6 +24,7 @@ __export(detect_services_exports, {
 module.exports = __toCommonJS(detect_services_exports);
 var import_utils = require("./utils");
 var import_resolve = require("./resolve");
+var import_auto_detect = require("./auto-detect");
 async function detectServices(options) {
   const { fs, workPath } = options;
   const scopedFs = workPath ? fs.chdir(workPath) : fs;
@@ -39,6 +40,25 @@ async function detectServices(options) {
   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 {
+        services: [],
+        routes: { rewrites: [], defaults: [], crons: [], workers: [] },
+        errors: autoResult.errors,
+        warnings: []
+      };
+    }
+    if (autoResult.services) {
+      const result2 = (0, import_resolve.resolveAllConfiguredServices)(autoResult.services);
+      const routes2 = generateServicesRoutes(result2.services);
+      return {
+        services: result2.services,
+        routes: routes2,
+        errors: result2.errors,
+        warnings: []
+      };
+    }
     return {
       services: [],
       routes: { rewrites: [], defaults: [], crons: [], workers: [] },
@@ -65,33 +85,34 @@ function generateServicesRoutes(services) {
   const defaults = [];
   const crons = [];
   const workers = [];
-  const webServices = services.filter(
+  const sortedWebServices = services.filter(
     (s) => s.type === "web" && typeof s.routePrefix === "string"
-  );
-  const sortedWebServices = [...webServices].sort((a, b) => {
-    if (a.routePrefix === "/")
-      return 1;
-    if (b.routePrefix === "/")
-      return -1;
-    return b.routePrefix.length - a.routePrefix.length;
-  });
+  ).sort((a, b) => b.routePrefix.length - a.routePrefix.length);
   for (const service of sortedWebServices) {
-    const { routePrefix, builder } = service;
-    const builderSrc = builder.src || routePrefix;
-    const functionPath = builderSrc.startsWith("/") ? builderSrc : `/${builderSrc}`;
-    if (routePrefix === "/") {
-      defaults.push({
-        src: "^/(.*)$",
-        dest: functionPath,
-        check: true
-      });
+    const { routePrefix } = service;
+    const normalizedPrefix = routePrefix.slice(1);
+    if ((0, import_utils.isStaticBuild)(service)) {
+      if (routePrefix === "/") {
+        defaults.push({ handle: "filesystem" });
+        defaults.push({ src: "/(.*)", dest: "/index.html" });
+      } else {
+        rewrites.push({
+          src: `^/${normalizedPrefix}(?:/.*)?$`,
+          dest: `/${normalizedPrefix}/index.html`
+        });
+      }
     } else {
-      const normalizedPrefix = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
-      rewrites.push({
-        src: `^/${normalizedPrefix}(?:/.*)?$`,
-        dest: functionPath,
-        check: true
-      });
+      const builderSrc = service.builder.src || routePrefix;
+      const functionPath = builderSrc.startsWith("/") ? builderSrc : `/${builderSrc}`;
+      if (routePrefix === "/") {
+        defaults.push({ src: "^/(.*)$", dest: functionPath, check: true });
+      } else {
+        rewrites.push({
+          src: `^/${normalizedPrefix}(?:/.*)?$`,
+          dest: functionPath,
+          check: true
+        });
+      }
     }
   }
   return { rewrites, defaults, crons, workers };

package/dist/services/resolve.js

@@ -131,7 +131,7 @@ function resolveConfiguredService(name, config, group) {
     builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
     builderSrc = config.entrypoint;
   }
-  const routePrefix = type === "web" ? config.routePrefix : void 0;
+  const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
   const isRoot = workspace === ".";
   if (!isRoot && !builderSrc.startsWith(workspace + "/")) {
     builderSrc = import_path.posix.join(workspace, builderSrc);
@@ -147,6 +147,13 @@ function resolveConfiguredService(name, config, group) {
     builderConfig.excludeFiles = config.excludeFiles;
   const isStaticBuild = import_types.STATIC_BUILDERS.has(builderUse);
   const runtime = isStaticBuild ? void 0 : inferredRuntime;
+  if (routePrefix) {
+    const stripped = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
+    builderConfig.routePrefix = stripped || ".";
+  }
+  if (config.framework) {
+    builderConfig.framework = config.framework;
+  }
   return {
     name,
     type,

package/dist/services/types.d.ts

@@ -1,29 +1,11 @@
 import type { Route } from '@vercel/routing-utils';
-import type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, Builder } from '@vercel/build-utils';
+import type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, Service, Builder } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, Builder, };
-export interface ResolvedService {
-    name: string;
-    type: ServiceType;
-    /** Service group name if this service belongs to a group */
-    group?: string;
-    workspace: string;
-    entrypoint?: string;
-    framework?: string;
-    builder: Builder;
-    buildCommand?: string;
-    installCommand?: string;
-    runtime?: string;
-    /**
-     * URL path prefix for routing requests to this service.
-     * Required for web services; requests matching this prefix are routed to this service.
-     * Root services use "/" as the catch-all.
-     */
-    routePrefix?: string;
-    schedule?: string;
-    topic?: string;
-    consumer?: string;
-}
+export type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, Service, Builder, };
+/**
+ * @deprecated Use `Service` instead
+ */
+export type ResolvedService = Service;
 export interface DetectServicesOptions {
     fs: DetectorFilesystem;
     /**

package/dist/services/utils.d.ts

@@ -1,6 +1,7 @@
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ServiceRuntime, ExperimentalServices, ServiceDetectionError } from './types';
+import type { ServiceRuntime, ExperimentalServices, ServiceDetectionError, ResolvedService } from './types';
 export declare function getBuilderForRuntime(runtime: ServiceRuntime): string;
+export declare function isStaticBuild(service: ResolvedService): boolean;
 /**
  * Infer runtime from available service configuration.
  *

package/dist/services/utils.js

@@ -20,6 +20,7 @@ var utils_exports = {};
 __export(utils_exports, {
   getBuilderForRuntime: () => getBuilderForRuntime,
   inferServiceRuntime: () => inferServiceRuntime,
+  isStaticBuild: () => isStaticBuild,
   readVercelConfig: () => readVercelConfig
 });
 module.exports = __toCommonJS(utils_exports);
@@ -32,6 +33,9 @@ function getBuilderForRuntime(runtime) {
   }
   return builder;
 }
+function isStaticBuild(service) {
+  return import_types.STATIC_BUILDERS.has(service.builder.use);
+}
 function inferServiceRuntime(config) {
   if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
     return config.runtime;
@@ -81,5 +85,6 @@ async function readVercelConfig(fs) {
 0 && (module.exports = {
   getBuilderForRuntime,
   inferServiceRuntime,
+  isStaticBuild,
   readVercelConfig
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.7.21",
+  "version": "5.8.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -32,7 +32,7 @@
     "@types/semver": "7.3.10",
     "jest-junit": "16.0.0",
     "typescript": "4.9.5",
-    "@vercel/build-utils": "13.2.17"
+    "@vercel/build-utils": "13.3.0"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",