@vercel/fs-detectors 5.8.15 → 5.8.17

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExt
 export { detectServices, generateServicesRoutes, } from './services/detect-services';
 export { autoDetectServices } from './services/auto-detect';
 export type { AutoDetectOptions, AutoDetectResult, } from './services/auto-detect';
-export { isStaticBuild, isRouteOwningBuilder, INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, } from './services/utils';
+export { isStaticBuild, isRouteOwningBuilder, INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, 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 { detectFileSystemAPI } from './detect-file-system-api';

package/dist/index.js

@@ -40,7 +40,10 @@ __export(src_exports, {
   detectOutputDirectory: () => import_detect_builders.detectOutputDirectory,
   detectServices: () => import_detect_services.detectServices,
   generateServicesRoutes: () => import_detect_services.generateServicesRoutes,
+  getInternalServiceCronPathPrefix: () => import_utils.getInternalServiceCronPathPrefix,
   getInternalServiceFunctionPath: () => import_utils.getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath: () => import_utils.getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix: () => import_utils.getInternalServiceWorkerPathPrefix,
   getProjectPaths: () => import_get_project_paths.getProjectPaths,
   getServicesBuilders: () => import_get_services_builders.getServicesBuilders,
   getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
@@ -96,7 +99,10 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   detectOutputDirectory,
   detectServices,
   generateServicesRoutes,
+  getInternalServiceCronPathPrefix,
   getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix,
   getProjectPaths,
   getServicesBuilders,
   getWorkspacePackagePaths,

package/dist/services/auto-detect.js

@@ -112,6 +112,9 @@ async function detectServicesAtRoot(fs, rootFramework) {
   if (backendResult.error) {
     return { services: null, errors: [backendResult.error] };
   }
+  if (Object.keys(backendResult.services).length === 0) {
+    return { services: null, errors: [] };
+  }
   Object.assign(services, backendResult.services);
   return { services, errors: [] };
 }

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

@@ -26,6 +26,10 @@ export declare function detectServices(options: DetectServicesOptions): Promise<
  * Builders that provide their own routing (`@vercel/next`, `@vercel/backends`,
  * Build Output API builders, etc.) are not given synthetic routes here.
  *
- * - Cron/Worker services: TODO - internal routes under `/_svc/`
+ * - Worker services:
+ *   Internal queue callback routes under `/_svc/{serviceName}/workers/{entry}/{handler}`
+ *   that rewrite to `/_svc/{serviceName}/index`.
+ *
+ * - Cron services: TODO - internal routes under `/_svc/`
  */
 export declare function generateServicesRoutes(services: ResolvedService[]): ServicesRoutes;

package/dist/services/detect-services.js

@@ -148,8 +148,25 @@ function generateServicesRoutes(services) {
       continue;
     }
   }
+  const workerServices = services.filter((s) => s.type === "worker");
+  for (const service of workerServices) {
+    const workerEntrypoint = service.entrypoint || service.builder.src || "index";
+    const workerPath = (0, import_utils.getInternalServiceWorkerPath)(
+      service.name,
+      workerEntrypoint
+    );
+    const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
+    workers.push({
+      src: `^${escapeRegex(workerPath)}$`,
+      dest: functionPath,
+      check: true
+    });
+  }
   return { rewrites, defaults, crons, workers };
 }
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function getWebRoutePrefixes(services) {
   const unique = /* @__PURE__ */ new Set();
   for (const service of services) {

package/dist/services/get-services-builders.js

@@ -84,7 +84,11 @@ async function getServicesBuilders(options) {
     warnings: warningResponses,
     defaultRoutes: result.routes.defaults.length > 0 ? result.routes.defaults : null,
     redirectRoutes: [],
-    rewriteRoutes: result.routes.rewrites.length > 0 ? result.routes.rewrites : null,
+    rewriteRoutes: result.routes.rewrites.length > 0 || result.routes.workers.length > 0 || result.routes.crons.length > 0 ? [
+      ...result.routes.rewrites,
+      ...result.routes.workers,
+      ...result.routes.crons
+    ] : null,
     errorRoutes: [],
     services: result.services
   };

package/dist/services/resolve.js

@@ -126,12 +126,14 @@ async function inferWorkspaceFromNearestManifest({
 async function detectFrameworkFromWorkspace({
   fs,
   workspace,
-  serviceName
+  serviceName,
+  runtime
 }) {
   const serviceFs = workspace === "." ? fs : fs.chdir(workspace);
+  const frameworkCandidates = (0, import_utils.filterFrameworksByRuntime)(import_frameworks.default, runtime);
   const frameworks = await (0, import_detect_framework.detectFrameworks)({
     fs: serviceFs,
-    frameworkList: import_frameworks.default
+    frameworkList: frameworkCandidates
   });
   if (frameworks.length > 1) {
     const frameworkNames = frameworks.map((f) => f.name).join(", ");
@@ -212,6 +214,16 @@ function validateServiceConfig(name, config) {
       serviceName: name
     };
   }
+  if (config.runtime && config.framework) {
+    const frameworkRuntime = (0, import_utils.inferRuntimeFromFramework)(config.framework);
+    if (frameworkRuntime && frameworkRuntime !== config.runtime) {
+      return {
+        code: "RUNTIME_FRAMEWORK_MISMATCH",
+        message: `Service "${name}" has conflicting runtime/framework: runtime "${config.runtime}" is incompatible with framework "${config.framework}" (runtime "${frameworkRuntime}").`,
+        serviceName: name
+      };
+    }
+  }
   const hasFramework = Boolean(config.framework);
   const hasBuilderOrRuntime = Boolean(config.builder || config.runtime);
   const hasEntrypoint = Boolean(config.entrypoint);
@@ -395,30 +407,56 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
       }
     }
     let resolvedConfig = serviceConfig;
-    const shouldDetectFramework = !serviceConfig.framework && Boolean(resolvedEntrypoint?.isDirectory);
-    if (shouldDetectFramework) {
-      const workspace = resolvedEntrypoint.normalized;
-      const { framework, error } = await detectFrameworkFromWorkspace({
-        fs,
-        workspace,
-        serviceName: name
-      });
-      if (error) {
-        errors.push(error);
-        continue;
-      }
-      if (!framework) {
-        errors.push({
-          code: "MISSING_SERVICE_FRAMEWORK",
-          message: `Service "${name}" uses directory entrypoint "${serviceConfig.entrypoint}" but no framework could be detected in "${workspace}". Specify "framework" explicitly or use a file entrypoint.`,
+    if (!serviceConfig.framework && resolvedEntrypoint) {
+      if (resolvedEntrypoint.isDirectory) {
+        const workspace = resolvedEntrypoint.normalized;
+        const { framework, error } = await detectFrameworkFromWorkspace({
+          fs,
+          workspace,
           serviceName: name
         });
-        continue;
+        if (error) {
+          errors.push(error);
+          continue;
+        }
+        if (!framework) {
+          errors.push({
+            code: "MISSING_SERVICE_FRAMEWORK",
+            message: `Service "${name}" uses directory entrypoint "${serviceConfig.entrypoint}" but no framework could be detected in "${workspace}". Specify "framework" explicitly or use a file entrypoint.`,
+            serviceName: name
+          });
+          continue;
+        }
+        resolvedConfig = {
+          ...resolvedConfig,
+          framework
+        };
+      } else {
+        const inferredRuntime = (0, import_utils.inferServiceRuntime)({
+          ...serviceConfig,
+          entrypoint: resolvedEntrypoint.normalized
+        });
+        if (inferredRuntime) {
+          const inferredWorkspace = await inferWorkspaceFromNearestManifest({
+            fs,
+            entrypoint: resolvedEntrypoint.normalized,
+            runtime: inferredRuntime
+          });
+          const workspace = inferredWorkspace ?? import_path.posix.dirname(resolvedEntrypoint.normalized);
+          const detection = await detectFrameworkFromWorkspace({
+            fs,
+            workspace,
+            serviceName: name,
+            runtime: inferredRuntime
+          });
+          if (detection.framework) {
+            resolvedConfig = {
+              ...resolvedConfig,
+              framework: detection.framework
+            };
+          }
+        }
       }
-      resolvedConfig = {
-        ...serviceConfig,
-        framework
-      };
     }
     const service = await resolveConfiguredService({
       name,

package/dist/services/types.d.ts

@@ -28,7 +28,6 @@ export interface ServicesRoutes {
     /**
      * Internal routes for worker services.
      * These route `/_svc/{serviceName}/workers/{entry}/{handler}` to the worker function.
-     * TODO: Implement
      */
     workers: Route[];
 }

package/dist/services/utils.d.ts

@@ -6,6 +6,9 @@ export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promi
  */
 export declare const INTERNAL_SERVICE_PREFIX = "/_svc";
 export declare function getInternalServiceFunctionPath(serviceName: string): string;
+export declare function getInternalServiceWorkerPathPrefix(serviceName: string): string;
+export declare function getInternalServiceCronPathPrefix(serviceName: string): string;
+export declare function getInternalServiceWorkerPath(serviceName: string, entrypoint: string, handler?: string): string;
 export declare function getBuilderForRuntime(runtime: ServiceRuntime): string;
 export declare function isStaticBuild(service: ResolvedService): boolean;
 /**
@@ -17,6 +20,18 @@ export declare function isStaticBuild(service: ResolvedService): boolean;
  * rewrites for them — instead, we rely on the builder's own `routes[]`.
  */
 export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
+/**
+ * Infer runtime from a framework slug.
+ *
+ * Examples:
+ * - `python` -> `python`
+ * - `fastapi` -> `python`
+ * - `express` -> `node`
+ */
+export declare function inferRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
+export declare function filterFrameworksByRuntime<T extends {
+    slug?: string | null;
+}>(frameworks: readonly T[], runtime?: ServiceRuntime): T[];
 /**
  * Infer runtime from available service configuration.
  *

package/dist/services/utils.js

@@ -19,9 +19,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   INTERNAL_SERVICE_PREFIX: () => INTERNAL_SERVICE_PREFIX,
+  filterFrameworksByRuntime: () => filterFrameworksByRuntime,
   getBuilderForRuntime: () => getBuilderForRuntime,
+  getInternalServiceCronPathPrefix: () => getInternalServiceCronPathPrefix,
   getInternalServiceFunctionPath: () => getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath: () => getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix: () => getInternalServiceWorkerPathPrefix,
   hasFile: () => hasFile,
+  inferRuntimeFromFramework: () => inferRuntimeFromFramework,
   inferServiceRuntime: () => inferServiceRuntime,
   isRouteOwningBuilder: () => isRouteOwningBuilder,
   isStaticBuild: () => isStaticBuild,
@@ -41,6 +46,20 @@ const INTERNAL_SERVICE_PREFIX = "/_svc";
 function getInternalServiceFunctionPath(serviceName) {
   return `${INTERNAL_SERVICE_PREFIX}/${serviceName}/index`;
 }
+function normalizeInternalServiceEntrypoint(entrypoint) {
+  const normalized = entrypoint.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\.[^/.]+$/, "");
+  return normalized || "index";
+}
+function getInternalServiceWorkerPathPrefix(serviceName) {
+  return `${INTERNAL_SERVICE_PREFIX}/${serviceName}/workers`;
+}
+function getInternalServiceCronPathPrefix(serviceName) {
+  return `${INTERNAL_SERVICE_PREFIX}/${serviceName}/crons`;
+}
+function getInternalServiceWorkerPath(serviceName, entrypoint, handler = "worker") {
+  const normalizedEntrypoint = normalizeInternalServiceEntrypoint(entrypoint);
+  return `${getInternalServiceWorkerPathPrefix(serviceName)}/${normalizedEntrypoint}/${handler}`;
+}
 function getBuilderForRuntime(runtime) {
   const builder = import_types.RUNTIME_BUILDERS[runtime];
   if (!builder) {
@@ -54,19 +73,37 @@ function isStaticBuild(service) {
 function isRouteOwningBuilder(service) {
   return import_types.ROUTE_OWNING_BUILDERS.has(service.builder.use);
 }
-function inferServiceRuntime(config) {
-  if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
-    return config.runtime;
+function inferRuntimeFromFramework(framework) {
+  if (!framework) {
+    return void 0;
   }
-  if (config.framework && config.framework in import_types.RUNTIME_BUILDERS) {
-    return config.framework;
+  if (framework in import_types.RUNTIME_BUILDERS) {
+    return framework;
   }
-  if ((0, import_framework_helpers.isPythonFramework)(config.framework)) {
+  if ((0, import_framework_helpers.isPythonFramework)(framework)) {
     return "python";
   }
-  if ((0, import_framework_helpers.isBackendFramework)(config.framework)) {
+  if ((0, import_framework_helpers.isBackendFramework)(framework)) {
     return "node";
   }
+  return void 0;
+}
+function filterFrameworksByRuntime(frameworks, runtime) {
+  if (!runtime) {
+    return [...frameworks];
+  }
+  return frameworks.filter(
+    (framework) => inferRuntimeFromFramework(framework.slug) === runtime
+  );
+}
+function inferServiceRuntime(config) {
+  if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
+    return config.runtime;
+  }
+  const frameworkRuntime = inferRuntimeFromFramework(config.framework);
+  if (frameworkRuntime) {
+    return frameworkRuntime;
+  }
   if (config.builder) {
     for (const [runtime, builderName] of Object.entries(import_types.RUNTIME_BUILDERS)) {
       if (config.builder === builderName) {
@@ -105,9 +142,14 @@ async function readVercelConfig(fs) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   INTERNAL_SERVICE_PREFIX,
+  filterFrameworksByRuntime,
   getBuilderForRuntime,
+  getInternalServiceCronPathPrefix,
   getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix,
   hasFile,
+  inferRuntimeFromFramework,
   inferServiceRuntime,
   isRouteOwningBuilder,
   isStaticBuild,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.8.15",
+  "version": "5.8.17",
   "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": "6.0.2",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/frameworks": "3.19.1",
-    "@vercel/routing-utils": "6.0.1"
+    "@vercel/frameworks": "3.20.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",