@vercel/fs-detectors 5.7.22 → 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,7 @@
 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';

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,
@@ -52,6 +53,7 @@ __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");
@@ -77,6 +79,7 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace,
   WorkspaceType,
+  autoDetectServices,
   detectApiDirectory,
   detectApiExtensions,
   detectBuilders,

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.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: [] },

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.7.22",
+  "version": "5.8.0",
   "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/routing-utils": "5.3.2",
-    "@vercel/frameworks": "3.16.1"
+    "@vercel/frameworks": "3.16.1",
+    "@vercel/routing-utils": "5.3.2"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",
@@ -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",