@vercel/fs-detectors 7.6.2 → 7.7.0

package/dist/detect-builders.d.ts

@@ -27,6 +27,13 @@ export interface ProxyConfig {
 export interface Options {
     tag?: string;
     functions?: BuilderFunctions;
+    /**
+     * Source files built by a builder that detection does not create itself
+     * (e.g. schedule entrypoints resolved by the CLI). Detection neither builds
+     * them as `api/` functions nor serves them as static files, and `functions`
+     * patterns that match them count as used.
+     */
+    reservedFunctionFiles?: string[];
     ignoreBuildScript?: boolean;
     projectSettings?: ProjectSettings;
     cleanUrls?: boolean;

package/dist/detect-builders.js

@@ -119,6 +119,80 @@ var require_constants = __commonJS({
   }
 });
 
+// ../../internals/runtimes/dist/entrypoint.js
+var require_entrypoint = __commonJS({
+  "../../internals/runtimes/dist/entrypoint.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var entrypoint_exports = {};
+    __export2(entrypoint_exports, {
+      SCHEDULE_ENTRYPOINT_FORMS_HINT: () => SCHEDULE_ENTRYPOINT_FORMS_HINT,
+      isDockerfileEntrypoint: () => isDockerfileEntrypoint,
+      parsePyModuleAttrEntrypoint: () => parsePyModuleAttrEntrypoint2,
+      parseScheduleEntrypoint: () => parseScheduleEntrypoint,
+      stripTrailingSlash: () => stripTrailingSlash
+    });
+    module2.exports = __toCommonJS2(entrypoint_exports);
+    var import_path2 = require("path");
+    var import_constants2 = require_constants();
+    var PYTHON_MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
+    var NODE_FILE_ENTRYPOINT_RE = /^(?!\/)(?!.*(?:^|\/)\.\.?(?:\/|$))(?:[\w@+.-]+\/)*[\w@+.-]+\.[cm]?[jt]s$/;
+    var NODE_DECLARATION_ENTRYPOINT_RE = /\.d\.[cm]?ts$/;
+    function parsePyModuleAttrEntrypoint2(entrypoint) {
+      const match = PYTHON_MODULE_ATTR_RE.exec(entrypoint);
+      if (!match)
+        return null;
+      const [, modulePart, attrName] = match;
+      if (!modulePart || !attrName)
+        return null;
+      return {
+        attrName,
+        filePath: modulePart.replace(/\./g, "/") + ".py",
+        moduleName: modulePart
+      };
+    }
+    var SCHEDULE_ENTRYPOINT_FORMS_HINT = 'Use a source file path like "jobs/nightly.ts" or a Python "module.path:function" reference.';
+    function parseScheduleEntrypoint(entrypoint) {
+      const python = parsePyModuleAttrEntrypoint2(entrypoint);
+      if (python) {
+        return { runtime: "python", ...python };
+      }
+      if (NODE_FILE_ENTRYPOINT_RE.test(entrypoint) && !NODE_DECLARATION_ENTRYPOINT_RE.test(entrypoint)) {
+        return { runtime: "node", filePath: entrypoint };
+      }
+      return null;
+    }
+    var CONTAINER_ENTRYPOINT_BASENAMES = new Set(
+      import_constants2.CONTAINER_ENTRYPOINT_CANDIDATES.map((name) => name.toLowerCase())
+    );
+    function isDockerfileEntrypoint(entrypoint) {
+      return CONTAINER_ENTRYPOINT_BASENAMES.has(
+        import_path2.posix.basename(entrypoint).toLowerCase()
+      );
+    }
+    function stripTrailingSlash(p) {
+      const stripped = p.replace(/\/+$/, "");
+      return stripped === "" ? "." : stripped;
+    }
+  }
+});
+
 // ../../internals/runtimes/dist/framework.js
 var require_framework = __commonJS({
   "../../internals/runtimes/dist/framework.js"(exports, module2) {
@@ -147,6 +221,7 @@ var require_framework = __commonJS({
       frameworksBySlug: () => frameworksBySlug,
       inferBuilderRuntimeFromFramework: () => inferBuilderRuntimeFromFramework2,
       inferRuntimeFromFramework: () => inferRuntimeFromFramework,
+      inferServerRuntimeFromFramework: () => inferServerRuntimeFromFramework,
       isBFFFramework: () => isBFFFramework,
       isFrontendFramework: () => isFrontendFramework
     });
@@ -177,6 +252,14 @@ var require_framework = __commonJS({
       middleman: "ruby",
       zola: "rust"
     };
+    function inferServerRuntimeFromFramework(framework) {
+      if (!framework || framework === "services")
+        return void 0;
+      const builder = frameworksBySlug.get(framework)?.useRuntime?.use;
+      if (!builder)
+        return void 0;
+      return import_constants2.BUILDER_RUNTIMES[builder] ?? "node";
+    }
     function inferBuilderRuntimeFromFramework2(framework) {
       if (!framework || framework === "container" || framework === "services")
         return void 0;
@@ -229,6 +312,7 @@ __export(detect_builders_exports, {
 });
 module.exports = __toCommonJS(detect_builders_exports);
 var import_minimatch = __toESM(require("minimatch"));
+var import_entrypoint = __toESM(require_entrypoint());
 var import_semver = require("semver");
 var import_path = require("path");
 var import_frameworks = require("@vercel/frameworks");
@@ -381,6 +465,13 @@ async function detectBuilders(files, pkg, options = {}) {
       usedFunctions.add(key);
   };
   const absolutePathCache = /* @__PURE__ */ new Map();
+  const proxyFile = options.proxy ? parseProxyEntrypoint(options.proxy.entrypoint).file : null;
+  const reservedFunctionFiles = options.reservedFunctionFiles ?? [];
+  const claimedFiles = /* @__PURE__ */ new Set([
+    ...proxyFile !== null ? [proxyFile] : [],
+    ...reservedFunctionFiles
+  ]);
+  const hasReservedFunctions = reservedFunctionFiles.length > 0;
   const { buildCommand, outputDirectory } = projectSettings;
   const frameworkConfig = import_framework.frameworksBySlug.get(framework || "");
   const rustStaticOutput = isRustStaticOutput(framework, projectSettings);
@@ -407,7 +498,7 @@ async function detectBuilders(files, pkg, options = {}) {
   const apiRoutes = [];
   const dynamicRoutes = [];
   for (const fileName of sortedFiles) {
-    if (fileName === options.proxy?.entrypoint) {
+    if (claimedFiles.has(fileName)) {
       continue;
     }
     const apiBuilder = await maybeGetApiBuilder(fileName, apiMatches, options);
@@ -471,7 +562,7 @@ async function detectBuilders(files, pkg, options = {}) {
       options
     );
   } else {
-    if (pkg && !makeFrontendStatic && !apiBuilders.length && !options.ignoreBuildScript) {
+    if (pkg && !makeFrontendStatic && !apiBuilders.length && !hasReservedFunctions && !options.ignoreBuildScript) {
       errors.push(getMissingBuildScriptError());
       return {
         errors,
@@ -492,12 +583,10 @@ async function detectBuilders(files, pkg, options = {}) {
           outputDirectory: usedOutputDirectory
         }
       };
-    } else if (apiBuilders.length && hasNoneApiFiles) {
+    } else if ((apiBuilders.length || hasReservedFunctions) && hasNoneApiFiles) {
       frontendBuilder = {
         use: "@vercel/static",
-        src: getStaticFilesPattern(
-          options.proxy ? [options.proxy.entrypoint] : []
-        ),
+        src: getStaticFilesPattern([...claimedFiles]),
         config: {
           zeroConfig: true
         }
@@ -523,6 +612,7 @@ async function detectBuilders(files, pkg, options = {}) {
   const unusedFunctionError = checkUnusedFunctions(
     frontendBuilder,
     usedFunctions,
+    claimedFiles,
     options
   );
   if (unusedFunctionError) {
@@ -659,14 +749,25 @@ function getFunction(fileName, { functions = {} }) {
   const func = keys.find((key) => key === fileName || (0, import_minimatch.default)(fileName, key));
   return func ? { fnPattern: func, func: functions[func] } : { fnPattern: null, func: null };
 }
+function parseProxyEntrypoint(entrypoint) {
+  if (process.env.VERCEL_PYTHON_PROXY) {
+    const parsed = (0, import_entrypoint.parsePyModuleAttrEntrypoint)(entrypoint);
+    if (parsed)
+      return { file: parsed.filePath, variable: parsed.attrName };
+  }
+  return { file: entrypoint };
+}
 function getProxyBuilder(proxy, tag, functions = {}) {
-  const { fnPattern, func } = getFunction(proxy.entrypoint, { functions });
+  const { file, variable } = parseProxyEntrypoint(proxy.entrypoint);
+  const isPython = (0, import_path.extname)(file) === ".py";
+  const { fnPattern, func } = getFunction(file, { functions });
   const runtime = func?.runtime;
   const config = {
     zeroConfig: true,
     middleware: true,
-    ...!runtime ? { middlewareRuntime: "nodejs" } : {},
-    ...proxy.matcher ? { middlewareMatcher: proxy.matcher } : {}
+    ...!runtime && !isPython ? { middlewareRuntime: "nodejs" } : {},
+    ...proxy.matcher ? { middlewareMatcher: proxy.matcher } : {},
+    ...variable ? { handlerFunction: variable } : {}
   };
   if (fnPattern && func) {
     config.functions = { [fnPattern]: func };
@@ -677,9 +778,10 @@ function getProxyBuilder(proxy, tag, functions = {}) {
       config.excludeFiles = func.excludeFiles;
     }
   }
+  const defaultRuntime = isPython ? `@vercel/python${tag ? `@${tag}` : ""}` : `@vercel/node${tag ? `@${tag}` : ""}`;
   return {
-    src: proxy.entrypoint,
-    use: runtime || `@vercel/node${tag ? `@${tag}` : ""}`,
+    src: file,
+    use: runtime || defaultRuntime,
     config
   };
 }
@@ -702,21 +804,29 @@ function validateProxyConfig(proxy) {
   if (typeof proxy !== "object" || typeof proxy.entrypoint !== "string" || !proxy.entrypoint) {
     return {
       code: "invalid_proxy",
-      message: "The `proxy` property must contain an `entrypoint` string that references a `.js` or `.ts` file."
+      message: "The `proxy` property must contain an `entrypoint` string."
     };
   }
-  const entrypoint = proxy.entrypoint;
-  const segments = entrypoint.split("/");
-  if (entrypoint.startsWith("/") || entrypoint.includes("\\") || segments.includes(".") || segments.includes("..") || /[?#\u0000-\u001f]/.test(entrypoint)) {
+  const { file, variable } = parseProxyEntrypoint(proxy.entrypoint);
+  const isPythonForm = (0, import_path.extname)(file) === ".py";
+  const isJsForm = /\.(?:js|ts)$/.test(file) && !file.endsWith(".d.ts");
+  const segments = file.split("/");
+  if (file.startsWith("/") || file.includes("\\") || segments.includes(".") || segments.includes("..") || /[?#\u0000-\u001f]/.test(file)) {
     return {
       code: "invalid_proxy_entrypoint",
       message: "The `proxy.entrypoint` path must be relative to the project root and cannot contain traversal, query, fragment, or control characters."
     };
   }
-  if (!/\.(?:js|ts)$/.test(entrypoint) || entrypoint.endsWith(".d.ts")) {
+  if (!isPythonForm && !isJsForm) {
+    return {
+      code: "invalid_proxy_entrypoint",
+      message: "The `proxy.entrypoint` must be a `.js` or `.ts` file path, or a Python `module:attr`."
+    };
+  }
+  if (isPythonForm && !variable) {
     return {
       code: "invalid_proxy_entrypoint",
-      message: "The `proxy.entrypoint` path must end in `.js` or `.ts` and reference an executable file."
+      message: "Python proxy entrypoints must use `module:attr` syntax, not a plain `.py` path."
     };
   }
   if (proxy.matcher !== void 0) {
@@ -741,10 +851,11 @@ function validateProxy(options, files, framework) {
   if (configError) {
     return configError;
   }
-  if (!files.includes(proxy.entrypoint)) {
+  const { file } = parseProxyEntrypoint(proxy.entrypoint);
+  if (!files.includes(file)) {
     return {
       code: "proxy_entrypoint_not_found",
-      message: `The proxy entrypoint \`${proxy.entrypoint}\` does not exist. Set \`proxy.entrypoint\` to an existing \`.js\` or \`.ts\` file.`
+      message: `The proxy entrypoint \`${proxy.entrypoint}\` does not exist.`
     };
   }
   if (framework === "nextjs" || framework === "astro") {
@@ -754,7 +865,8 @@ function validateProxy(options, files, framework) {
     };
   }
   const appRuntime = (0, import_framework.inferBuilderRuntimeFromFramework)(framework);
-  const proxyRuntime = import_constants.ENTRYPOINT_EXTENSIONS[(0, import_path.extname)(proxy.entrypoint)];
+  const { file: proxyFile } = parseProxyEntrypoint(proxy.entrypoint);
+  const proxyRuntime = import_constants.ENTRYPOINT_EXTENSIONS[(0, import_path.extname)(proxyFile)];
   if (appRuntime !== void 0 && proxyRuntime !== void 0 && appRuntime !== proxyRuntime) {
     return {
       code: "proxy_runtime_mismatch",
@@ -922,10 +1034,18 @@ function validateFunctions({ functions = {} }) {
   }
   return null;
 }
-function checkUnusedFunctions(frontendBuilder, usedFunctions, options) {
+function checkUnusedFunctions(frontendBuilder, usedFunctions, claimedFiles, options) {
   const unusedFunctions = new Set(
     Object.keys(options.functions || {}).filter((key) => !usedFunctions.has(key))
   );
+  for (const fnKey of unusedFunctions) {
+    for (const filePath of claimedFiles) {
+      if (filePath === fnKey || (0, import_minimatch.default)(filePath, fnKey)) {
+        unusedFunctions.delete(fnKey);
+        break;
+      }
+    }
+  }
   if (!unusedFunctions.size) {
     return null;
   }

package/dist/services/resolve-v2.js

@@ -248,7 +248,7 @@ async function resolveConfiguredServiceV2(name, config, fs) {
       }
     };
   }
-  const buildpackRuntime = flaggedBuildpackRuntime && !entrypointFile && !(0, import_framework.isFrontendFramework)(framework) && await (0, import_buildpack_runtimes.hasBuildpackProjectMarker)(
+  const buildpackRuntime = flaggedBuildpackRuntime && (!entrypointFile || flaggedBuildpackRuntime === "ruby" && entrypointFile === "config.ru") && !(0, import_framework.isFrontendFramework)(framework) && await (0, import_buildpack_runtimes.hasBuildpackProjectMarker)(
     flaggedBuildpackRuntime,
     (marker) => (0, import_utils.hasFile)(serviceFs, marker)
   ) ? flaggedBuildpackRuntime : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "7.6.2",
+  "version": "7.7.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,11 +20,11 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/build-utils": "14.10.2",
     "@vercel/error-utils": "2.2.1",
+    "@vercel/build-utils": "14.11.0",
     "@vercel/frameworks": "3.34.0",
-    "@vercel/python-analysis": "0.14.0",
-    "@vercel/routing-utils": "6.6.0"
+    "@vercel/routing-utils": "6.6.0",
+    "@vercel/python-analysis": "0.14.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",
@@ -33,7 +33,7 @@
     "@types/node": "20.11.0",
     "@types/semver": "7.3.10",
     "vitest": "4.1.10",
-    "@vercel-internals/runtimes": "1.1.1"
+    "@vercel-internals/runtimes": "1.1.2"
   },
   "scripts": {
     "build": "node build.mjs",