@vercel/static-build 2.9.36 → 2.9.37

package/dist/index.js

@@ -22855,8 +22855,13 @@ var require_resolve = __commonJS({
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var resolve_exports = {};
     __export2(resolve_exports, {
+      detectFrameworkFromWorkspace: () => detectFrameworkFromWorkspace,
+      getServiceFs: () => getServiceFs,
+      inferWorkspaceFromNearestManifest: () => inferWorkspaceFromNearestManifest,
+      parsePyModuleAttrEntrypoint: () => parsePyModuleAttrEntrypoint,
       resolveAllConfiguredServices: () => resolveAllConfiguredServices,
       resolveConfiguredService: () => resolveConfiguredService,
+      resolveEntrypointPath: () => resolveEntrypointPath,
       validateServiceConfig: () => validateServiceConfig,
       validateServiceEntrypoint: () => validateServiceEntrypoint
     });
@@ -23503,6 +23508,7 @@ var require_resolve = __commonJS({
         builderConfig.handlerFunction = moduleAttrParsed.attrName;
       }
       return {
+        schema: "experimentalServices",
         name,
         type,
         trigger,
@@ -23708,6 +23714,270 @@ var require_resolve = __commonJS({
   }
 });
 
+// ../fs-detectors/dist/services/resolve-v2.js
+var require_resolve_v2 = __commonJS({
+  "../fs-detectors/dist/services/resolve-v2.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 resolve_v2_exports = {};
+    __export2(resolve_v2_exports, {
+      resolveAllConfiguredServicesV2: () => resolveAllConfiguredServicesV22,
+      resolveConfiguredServiceV2: () => resolveConfiguredServiceV22,
+      validateServiceConfigV2: () => validateServiceConfigV22
+    });
+    module2.exports = __toCommonJS2(resolve_v2_exports);
+    var import_path7 = require("path");
+    var import_build_utils5 = require("@vercel/build-utils");
+    var import_frameworks2 = require_frameworks();
+    var import_types = require_types3();
+    var import_resolve = require_resolve();
+    var import_utils = require_utils4();
+    var frameworksBySlug = new Map(import_frameworks2.frameworkList.map((f) => [f.slug, f]));
+    var SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+    function validateServiceConfigV22(name, config) {
+      if (!SERVICE_NAME_REGEX.test(name)) {
+        return {
+          code: "INVALID_SERVICE_NAME",
+          message: `Service name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores.`,
+          serviceName: name
+        };
+      }
+      if (!config || typeof config !== "object") {
+        return {
+          code: "INVALID_SERVICE_CONFIG",
+          message: `Service "${name}" has an invalid configuration. Expected an object.`,
+          serviceName: name
+        };
+      }
+      if (typeof config.root !== "string" || config.root.length === 0) {
+        return {
+          code: "MISSING_ROOT",
+          message: `Service "${name}" must specify a "root".`,
+          serviceName: name
+        };
+      }
+      const normalizedRoot = import_path7.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.runtime && !(config.runtime in import_types.RUNTIME_BUILDERS)) {
+        return {
+          code: "INVALID_RUNTIME",
+          message: `Service "${name}" has invalid runtime "${config.runtime}".`,
+          serviceName: name
+        };
+      }
+      if (config.framework && !frameworksBySlug.has(config.framework)) {
+        return {
+          code: "INVALID_FRAMEWORK",
+          message: `Service "${name}" has invalid framework "${config.framework}".`,
+          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
+          };
+        }
+      }
+      if (!config.framework && !config.entrypoint) {
+        return {
+          code: "MISSING_SERVICE_CONFIG",
+          message: `Service "${name}" must specify "framework" or "entrypoint".`,
+          serviceName: name
+        };
+      }
+      return null;
+    }
+    async function resolveConfiguredServiceV22(name, config, fs5) {
+      const root = config.root;
+      const normalizedRoot = import_path7.posix.normalize(root);
+      const serviceFsResult = normalizedRoot === "." ? { fs: fs5 } : await (0, import_resolve.getServiceFs)(fs5, name, root);
+      if (serviceFsResult.error) {
+        return { error: serviceFsResult.error };
+      }
+      const serviceFs = serviceFsResult.fs;
+      const rawEntrypoint = config.entrypoint;
+      const moduleAttr = typeof rawEntrypoint === "string" ? (0, import_resolve.parsePyModuleAttrEntrypoint)(rawEntrypoint) : null;
+      let normalizedEntrypoint;
+      let entrypointIsDirectory = false;
+      if (typeof rawEntrypoint === "string") {
+        const entrypointToResolve = moduleAttr ? moduleAttr.filePath : rawEntrypoint;
+        const resolved = await (0, import_resolve.resolveEntrypointPath)({
+          fs: serviceFs,
+          serviceName: name,
+          entrypoint: entrypointToResolve
+        });
+        if (resolved.error) {
+          return { error: resolved.error };
+        }
+        normalizedEntrypoint = resolved.entrypoint?.normalized;
+        entrypointIsDirectory = Boolean(resolved.entrypoint?.isDirectory);
+      }
+      const entrypointFile = entrypointIsDirectory || !normalizedEntrypoint ? void 0 : normalizedEntrypoint;
+      const inferredRuntime = (0, import_utils.inferServiceRuntime)({
+        runtime: config.runtime,
+        framework: config.framework,
+        entrypoint: entrypointFile
+      });
+      let framework = config.framework;
+      if (!framework && normalizedEntrypoint) {
+        const workspace = entrypointIsDirectory ? normalizedEntrypoint : import_path7.posix.dirname(normalizedEntrypoint) || ".";
+        const detection = await (0, import_resolve.detectFrameworkFromWorkspace)({
+          fs: serviceFs,
+          workspace,
+          serviceName: name,
+          runtime: inferredRuntime
+        });
+        if (detection.error) {
+          return { error: detection.error };
+        }
+        framework = detection.framework;
+      }
+      if (entrypointIsDirectory && !framework) {
+        return {
+          error: {
+            code: "MISSING_SERVICE_FRAMEWORK",
+            message: `Service "${name}" uses directory entrypoint "${config.entrypoint}" but no framework could be detected. Specify "framework" explicitly or use a file entrypoint.`,
+            serviceName: name
+          }
+        };
+      }
+      const frameworkDefinition = framework ? frameworksBySlug.get(framework) : void 0;
+      let builderUse;
+      let builderSrc;
+      if (framework) {
+        builderUse = (0, import_build_utils5.isNodeBackendFramework)(framework) ? "@vercel/backends" : frameworkDefinition?.useRuntime?.use || "@vercel/static-build";
+        builderSrc = entrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
+      } else {
+        if (!inferredRuntime) {
+          return {
+            error: {
+              code: "MISSING_SERVICE_CONFIG",
+              message: `Service "${name}" must specify "framework" or a runtime-resolvable "entrypoint".`,
+              serviceName: name
+            }
+          };
+        }
+        builderUse = inferredRuntime === "node" ? "@vercel/backends" : (0, import_utils.getBuilderForRuntime)(inferredRuntime);
+        builderSrc = entrypointFile;
+      }
+      const isRoot = normalizedRoot === ".";
+      const projectRelativeSrc = isRoot ? builderSrc : import_path7.posix.join(normalizedRoot, builderSrc);
+      const builderConfig = { zeroConfig: true };
+      if (builderUse === "@vercel/backends") {
+        builderConfig.serviceName = name;
+      }
+      if (framework) {
+        builderConfig.framework = framework;
+      }
+      if (!isRoot) {
+        builderConfig.workspace = normalizedRoot;
+      }
+      if (moduleAttr) {
+        builderConfig.handlerFunction = moduleAttr.attrName;
+      }
+      const runtime = import_types.STATIC_BUILDERS.has(builderUse) ? void 0 : inferredRuntime;
+      return {
+        service: {
+          schema: "experimentalServicesV2",
+          name,
+          root,
+          framework,
+          runtime,
+          entrypoint: entrypointFile,
+          builder: {
+            src: projectRelativeSrc,
+            use: builderUse,
+            config: builderConfig
+          },
+          installCommand: config.installCommand,
+          buildCommand: config.buildCommand,
+          devCommand: config.devCommand,
+          ignoreCommand: config.ignoreCommand,
+          outputDirectory: config.outputDirectory,
+          bindings: config.bindings,
+          functions: config.functions,
+          headers: config.headers,
+          redirects: config.redirects,
+          rewrites: config.rewrites,
+          routes: config.routes,
+          cleanUrls: config.cleanUrls,
+          trailingSlash: config.trailingSlash
+        }
+      };
+    }
+    async function resolveAllConfiguredServicesV22(services, fs5) {
+      const resolved = [];
+      const errors = [];
+      for (const name of Object.keys(services)) {
+        const config = services[name];
+        const validationError = validateServiceConfigV22(name, config);
+        if (validationError) {
+          errors.push(validationError);
+          continue;
+        }
+        const { service, error } = await resolveConfiguredServiceV22(
+          name,
+          config,
+          fs5
+        );
+        if (error) {
+          errors.push(error);
+          continue;
+        }
+        if (service) {
+          resolved.push(service);
+        }
+      }
+      const serviceNames = new Set(Object.keys(services));
+      for (const service of resolved) {
+        for (const binding of service.bindings ?? []) {
+          if (!serviceNames.has(binding.service)) {
+            errors.push({
+              code: "UNKNOWN_SERVICE_BINDING",
+              message: `Service "${service.name}" declares a binding to unknown service "${binding.service}".`,
+              serviceName: service.name
+            });
+          }
+        }
+      }
+      return { services: resolved, errors };
+    }
+  }
+});
+
 // ../fs-detectors/dist/services/auto-detect.js
 var require_auto_detect = __commonJS({
   "../fs-detectors/dist/services/auto-detect.js"(exports, module2) {
@@ -27599,6 +27869,7 @@ var require_detect_services = __commonJS({
     var import_routing_utils = require_dist7();
     var import_utils = require_utils4();
     var import_resolve = require_resolve();
+    var import_resolve_v2 = require_resolve_v2();
     var import_auto_detect = require_auto_detect();
     var import_detect_railway = require_detect_railway();
     var import_detect_render = require_detect_render();
@@ -27663,7 +27934,8 @@ var require_detect_services = __commonJS({
         fs: fs5,
         workPath,
         detectEntrypoint,
-        configuredServices: providedConfiguredServices
+        configuredServices: providedConfiguredServices,
+        configuredServicesType
       } = options;
       const scopedFs = workPath ? fs5.chdir(workPath) : fs5;
       const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
@@ -27678,6 +27950,23 @@ var require_detect_services = __commonJS({
         });
       }
       const hasProvidedConfiguredServices = providedConfiguredServices && Object.keys(providedConfiguredServices).length > 0;
+      const experimentalServicesV2 = hasProvidedConfiguredServices && configuredServicesType === "experimentalServicesV2" ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.experimentalServicesV2;
+      if (experimentalServicesV2 && Object.keys(experimentalServicesV2).length > 0) {
+        const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
+          experimentalServicesV2,
+          scopedFs
+        );
+        return withResolvedResult({
+          services: result2.services,
+          source: "configured",
+          // V2 uses explicit `bindings`, so no implicit `{NAME}_URL` injection.
+          useImplicitEnvInjection: false,
+          // V2 routes are explicitly carried per-service to output them separately.
+          routes: emptyRoutes(),
+          errors: result2.errors,
+          warnings: []
+        });
+      }
       const configuredServices = hasProvidedConfiguredServices ? providedConfiguredServices : vercelConfig?.experimentalServices;
       const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
       if (!hasConfiguredServices) {
@@ -27783,7 +28072,8 @@ var require_detect_services = __commonJS({
         inferred
       );
     }
-    function generateServicesRoutes2(services) {
+    function generateServicesRoutes2(allServices) {
+      const services = allServices.filter(import_build_utils5.isExperimentalService);
       const hostRewrites = [];
       const rewrites = [];
       const defaults = [];
@@ -28340,10 +28630,14 @@ var require_detect_builders = __commonJS({
       return publicBuilder ? publicBuilder.src.replace("/**/*", "") : null;
     }
     async function detectBuilders2(files, pkg, options = {}) {
-      const { experimentalServices, projectSettings = {} } = options;
+      const {
+        experimentalServices,
+        experimentalServicesV2,
+        projectSettings = {}
+      } = options;
       const { framework } = projectSettings;
-      const configuredServices = experimentalServices;
-      const configuredServicesType = "experimentalServices";
+      const configuredServices = experimentalServices ?? experimentalServicesV2;
+      const configuredServicesType = experimentalServices ? "experimentalServices" : "experimentalServicesV2";
       const hasServicesConfig = configuredServices != null && typeof configuredServices === "object";
       if (hasServicesConfig || framework === "services") {
         return (0, import_get_services_builders.getServicesBuilders)({
@@ -33671,17 +33965,24 @@ var require_dist8 = __commonJS({
       getServicesBuilders: () => import_get_services_builders.getServicesBuilders,
       getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
       getWorkspaces: () => import_get_workspaces.getWorkspaces,
+      isExperimentalService: () => import_build_utils5.isExperimentalService,
+      isExperimentalServiceV2: () => import_build_utils5.isExperimentalServiceV2,
       isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
       isRouteOwningBuilder: () => import_utils.isRouteOwningBuilder,
       isStaticBuild: () => import_utils.isStaticBuild,
       isStaticRuntime: () => import_is_official_runtime.isStaticRuntime,
       monorepoManagers: () => import_monorepo_managers.monorepoManagers,
       packageManagers: () => import_package_managers.packageManagers,
+      resolveAllConfiguredServicesV2: () => import_resolve_v2.resolveAllConfiguredServicesV2,
+      resolveConfiguredServiceV2: () => import_resolve_v2.resolveConfiguredServiceV2,
+      validateServiceConfigV2: () => import_resolve_v2.validateServiceConfigV2,
       workspaceManagers: () => import_workspace_managers.workspaceManagers
     });
     module2.exports = __toCommonJS2(src_exports2);
     var import_detect_builders = require_detect_builders();
     var import_detect_services = require_detect_services();
+    var import_resolve_v2 = require_resolve_v2();
+    var import_build_utils5 = require("@vercel/build-utils");
     var import_auto_detect = require_auto_detect();
     var import_utils = require_utils4();
     var import_get_services_builders = require_get_services_builders();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "2.9.36",
+  "version": "2.9.37",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/build-step",
@@ -14,8 +14,8 @@
   },
   "dependencies": {
     "ts-morph": "12.0.0",
+    "@vercel/gatsby-plugin-vercel-builder": "2.2.14",
     "@vercel/gatsby-plugin-vercel-analytics": "1.0.11",
-    "@vercel/gatsby-plugin-vercel-builder": "2.2.13",
     "@vercel/static-config": "3.4.0"
   },
   "devDependencies": {
@@ -37,10 +37,10 @@
     "semver": "7.5.2",
     "tree-kill": "1.2.2",
     "vitest": "2.0.3",
-    "@vercel/build-utils": "13.27.0",
+    "@vercel/build-utils": "13.27.1",
     "@vercel/error-utils": "2.2.0",
+    "@vercel/fs-detectors": "6.7.8",
     "@vercel/frameworks": "3.27.0",
-    "@vercel/fs-detectors": "6.7.7",
     "@vercel/routing-utils": "6.2.0"
   },
   "scripts": {