@vercel/fs-detectors 5.16.0 → 5.18.0

package/dist/detect-builders.js

@@ -311,7 +311,7 @@ async function maybeGetApiBuilder(fileName, apiMatches, options) {
     }
   }
   const nodeExtensions = [".js", ".mjs", ".ts", ".tsx"];
-  if (process.env.VERCEL_NODE_FILTER_ENTRYPOINTS === "1" && nodeExtensions.some((ext) => fileName.endsWith(ext)) && options.workPath) {
+  if (fileName.startsWith("api/") && process.env.VERCEL_NODE_FILTER_ENTRYPOINTS === "1" && nodeExtensions.some((ext) => fileName.endsWith(ext)) && options.workPath) {
     const fsPath = (0, import_path.join)(options.workPath, fileName);
     const isEntrypoint = await (0, import_build_utils.isNodeEntrypoint)({ fsPath });
     if (!isEntrypoint) {

package/dist/services/detect-services.js

@@ -271,15 +271,10 @@ function generateServicesRoutes(services) {
   }
   const cronServices = services.filter((s) => s.type === "cron");
   for (const service of cronServices) {
-    const cronEntrypoint = service.entrypoint || service.builder.src || "index";
-    const cronPath = (0, import_utils.getInternalServiceCronPath)(
-      service.name,
-      cronEntrypoint,
-      service.handlerFunction || "cron"
-    );
+    const cronPrefix = (0, import_utils.getInternalServiceCronPathPrefix)(service.name);
     const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
     crons.push({
-      src: `^${escapeRegex(cronPath)}$`,
+      src: `^${escapeRegex(cronPrefix)}/.*$`,
       dest: functionPath,
       check: true
     });

package/dist/services/resolve.d.ts

@@ -8,7 +8,9 @@ type RoutePrefixSource = 'configured' | 'generated';
 interface ResolveConfiguredServiceOptions {
     name: string;
     config: ExperimentalServiceConfig;
-    fs: DetectorFilesystem;
+    /** Filesystem scoped to the service root (via chdir) when root is set, otherwise the project-level fs. */
+    serviceFs: DetectorFilesystem;
+    root?: string;
     group?: string;
     resolvedEntrypoint?: ResolvedEntrypointPath;
     routePrefixSource?: RoutePrefixSource;

package/dist/services/resolve.js

@@ -46,6 +46,33 @@ function parsePyModuleAttrEntrypoint(entrypoint) {
 const SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
 const DNS_LABEL_RE = /^(?!-)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
 const ENV_PREFIX_RE = /^[A-Z][A-Z0-9_]*_$/;
+async function getServiceFs(fs, serviceName, root) {
+  if (!root) {
+    return { fs };
+  }
+  const normalizedRoot = import_path.posix.normalize(root);
+  if (!await fs.hasPath(normalizedRoot)) {
+    return {
+      fs,
+      error: {
+        code: "ROOT_NOT_FOUND",
+        message: `Service "${serviceName}" has root "${root}" but that directory does not exist.`,
+        serviceName
+      }
+    };
+  }
+  if (await fs.isFile(normalizedRoot)) {
+    return {
+      fs,
+      error: {
+        code: "ROOT_NOT_DIRECTORY",
+        message: `Service "${serviceName}" has root "${root}" but that path is a file, not a directory.`,
+        serviceName
+      }
+    };
+  }
+  return { fs: fs.chdir(normalizedRoot) };
+}
 function normalizeServiceEntrypoint(entrypoint) {
   const normalized = import_path.posix.normalize(entrypoint);
   return normalized === "" ? "." : normalized;
@@ -304,6 +331,23 @@ function validateServiceConfig(name, config) {
       serviceName: name
     };
   }
+  if (config.root !== void 0) {
+    const normalizedRoot = import_path.posix.normalize(config.root);
+    if (normalizedRoot.startsWith("/")) {
+      return {
+        code: "INVALID_ROOT",
+        message: `Service "${name}" has invalid "root" "${config.root}". Must be a relative path.`,
+        serviceName: name
+      };
+    }
+    if (normalizedRoot === ".." || normalizedRoot.startsWith("../")) {
+      return {
+        code: "INVALID_ROOT",
+        message: `Service "${name}" has invalid "root" "${config.root}". Must not escape the project root.`,
+        serviceName: name
+      };
+    }
+  }
   if (config.envPrefix !== void 0) {
     if (!ENV_PREFIX_RE.test(config.envPrefix)) {
       return {
@@ -377,7 +421,8 @@ async function resolveConfiguredService(options) {
   const {
     name,
     config,
-    fs,
+    serviceFs,
+    root,
     group,
     resolvedEntrypoint,
     routePrefixSource = "configured"
@@ -396,7 +441,7 @@ async function resolveConfiguredService(options) {
   if (!resolvedEntrypointPath && typeof rawEntrypoint === "string") {
     const entrypointToResolve = moduleAttrParsed ? moduleAttrParsed.filePath : rawEntrypoint;
     const resolved = await resolveEntrypointPath({
-      fs,
+      fs: serviceFs,
       serviceName: name,
       entrypoint: entrypointToResolve
     });
@@ -419,7 +464,7 @@ async function resolveConfiguredService(options) {
     workspace = normalizedEntrypoint;
   } else {
     const inferredWorkspace = await inferWorkspaceFromNearestManifest({
-      fs,
+      fs: serviceFs,
       entrypoint: resolvedEntrypointFile,
       runtime: inferredRuntime
     });
@@ -433,6 +478,12 @@ async function resolveConfiguredService(options) {
       }
     }
   }
+  if (root) {
+    const normalizedRoot = import_path.posix.normalize(root);
+    if (normalizedRoot !== ".") {
+      workspace = workspace === "." ? normalizedRoot : import_path.posix.join(normalizedRoot, workspace);
+    }
+  }
   const topics = type === "worker" ? (0, import_build_utils.getWorkerTopics)(config) : config.topics;
   const consumer = type === "worker" ? config.consumer || "default" : config.consumer;
   let builderUse;
@@ -532,12 +583,19 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
       errors.push(validationError);
       continue;
     }
+    const root = serviceConfig.root;
+    const serviceFsResult = await getServiceFs(fs, name, root);
+    if (serviceFsResult.error) {
+      errors.push(serviceFsResult.error);
+      continue;
+    }
+    const serviceFs = serviceFsResult.fs;
     let resolvedEntrypoint;
     if (typeof serviceConfig.entrypoint === "string") {
       const moduleAttr = parsePyModuleAttrEntrypoint(serviceConfig.entrypoint);
       const entrypointToResolve = moduleAttr?.filePath ?? serviceConfig.entrypoint;
       const resolvedPath = await resolveEntrypointPath({
-        fs,
+        fs: serviceFs,
         serviceName: name,
         entrypoint: entrypointToResolve
       });
@@ -566,7 +624,7 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
         });
         const workspace = resolvedEntrypoint.normalized;
         const { framework, error } = await detectFrameworkFromWorkspace({
-          fs,
+          fs: serviceFs,
           workspace,
           runtime: inferredRuntime,
           serviceName: name
@@ -594,13 +652,13 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
         });
         if (inferredRuntime) {
           const inferredWorkspace = await inferWorkspaceFromNearestManifest({
-            fs,
+            fs: serviceFs,
             entrypoint: resolvedEntrypoint.normalized,
             runtime: inferredRuntime
           });
           const workspace = inferredWorkspace ?? import_path.posix.dirname(resolvedEntrypoint.normalized);
           const detection = await detectFrameworkFromWorkspace({
-            fs,
+            fs: serviceFs,
             workspace,
             serviceName: name,
             runtime: inferredRuntime
@@ -617,7 +675,8 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
     const service = await resolveConfiguredService({
       name,
       config: resolvedConfig,
-      fs,
+      serviceFs,
+      root,
       resolvedEntrypoint,
       routePrefixSource
     });

package/dist/services/utils.d.ts

@@ -1,19 +1,14 @@
+import { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
 import type { ServiceRuntime, ExperimentalServices, ServiceDetectionError, ResolvedService } from './types';
+export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, };
 export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
-/**
- * Reserved internal namespace used by services routing/runtime plumbing.
- */
-export declare const INTERNAL_SERVICE_PREFIX = "/_svc";
 /**
  * Reserved internal namespace used by the dev queue proxy.
  */
 export declare const INTERNAL_QUEUES_PREFIX = "/_svc/_queues";
-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 getInternalServiceCronPath(serviceName: string, entrypoint: string, handler?: string): string;
 export declare function getBuilderForRuntime(runtime: ServiceRuntime): string;
 export declare function isStaticBuild(service: ResolvedService): boolean;
 /**

package/dist/services/utils.js

@@ -29,12 +29,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   INTERNAL_QUEUES_PREFIX: () => INTERNAL_QUEUES_PREFIX,
-  INTERNAL_SERVICE_PREFIX: () => INTERNAL_SERVICE_PREFIX,
+  INTERNAL_SERVICE_PREFIX: () => import_build_utils.INTERNAL_SERVICE_PREFIX,
   filterFrameworksByRuntime: () => filterFrameworksByRuntime,
   getBuilderForRuntime: () => getBuilderForRuntime,
-  getInternalServiceCronPath: () => getInternalServiceCronPath,
-  getInternalServiceCronPathPrefix: () => getInternalServiceCronPathPrefix,
-  getInternalServiceFunctionPath: () => getInternalServiceFunctionPath,
+  getInternalServiceCronPath: () => import_build_utils.getInternalServiceCronPath,
+  getInternalServiceCronPathPrefix: () => import_build_utils.getInternalServiceCronPathPrefix,
+  getInternalServiceFunctionPath: () => import_build_utils.getInternalServiceFunctionPath,
   getInternalServiceWorkerPath: () => getInternalServiceWorkerPath,
   getInternalServiceWorkerPathPrefix: () => getInternalServiceWorkerPathPrefix,
   hasFile: () => hasFile,
@@ -47,6 +47,7 @@ __export(utils_exports, {
 });
 module.exports = __toCommonJS(utils_exports);
 var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
+var import_build_utils = require("@vercel/build-utils");
 var import_types = require("./types");
 async function hasFile(fs, filePath) {
   try {
@@ -55,29 +56,18 @@ async function hasFile(fs, filePath) {
     return false;
   }
 }
-const INTERNAL_SERVICE_PREFIX = "/_svc";
 const INTERNAL_QUEUES_PREFIX = "/_svc/_queues";
-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`;
+  return `${import_build_utils.INTERNAL_SERVICE_PREFIX}/${serviceName}/workers`;
 }
 function getInternalServiceWorkerPath(serviceName, entrypoint, handler = "worker") {
   const normalizedEntrypoint = normalizeInternalServiceEntrypoint(entrypoint);
   return `${getInternalServiceWorkerPathPrefix(serviceName)}/${normalizedEntrypoint}/${handler}`;
 }
-function getInternalServiceCronPath(serviceName, entrypoint, handler = "cron") {
-  const normalizedEntrypoint = normalizeInternalServiceEntrypoint(entrypoint);
-  return `${getInternalServiceCronPathPrefix(serviceName)}/${normalizedEntrypoint}/${handler}`;
-}
 function getBuilderForRuntime(runtime) {
   const builder = import_types.RUNTIME_BUILDERS[runtime];
   if (!builder) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.16.0",
+  "version": "5.18.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,9 +20,9 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/build-utils": "13.15.0",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/frameworks": "3.24.0",
+    "@vercel/frameworks": "3.24.1",
+    "@vercel/build-utils": "13.17.0",
     "@vercel/routing-utils": "6.1.1"
   },
   "devDependencies": {