@vercel/fs-detectors 5.16.0 → 5.17.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/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/package.json

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