@vercel/fs-detectors 6.9.3 → 6.10.1

package/dist/detect-builders.d.ts

@@ -1,5 +1,5 @@
 import type { Route } from '@vercel/routing-utils';
-import type { PackageJson, Builder, BuilderFunctions, ExperimentalServices, ExperimentalServicesV2, ProjectSettings, Service } from '@vercel/build-utils';
+import type { PackageJson, Builder, BuilderFunctions, ExperimentalServices, ExperimentalServicesV2, Services, ProjectSettings, Service } from '@vercel/build-utils';
 /**
  * Pattern for finding all supported middleware files.
  */
@@ -23,6 +23,7 @@ export interface Options {
     tag?: string;
     functions?: BuilderFunctions;
     experimentalServices?: ExperimentalServices;
+    services?: Services;
     experimentalServicesV2?: ExperimentalServicesV2;
     ignoreBuildScript?: boolean;
     projectSettings?: ProjectSettings;

package/dist/detect-builders.js

@@ -94,12 +94,30 @@ function detectOutputDirectory(builders) {
 async function detectBuilders(files, pkg, options = {}) {
   const {
     experimentalServices: experimentalServicesV1,
+    services,
     experimentalServicesV2,
     projectSettings = {}
   } = options;
+  if (services != null && experimentalServicesV2 != null) {
+    return {
+      builders: null,
+      errors: [
+        {
+          code: "SERVICES_AND_EXPERIMENTAL_SERVICES_V2",
+          message: "The `services` option cannot be used in conjunction with its deprecated alias `experimentalServicesV2`. Please use only `services`."
+        }
+      ],
+      warnings: [],
+      defaultRoutes: null,
+      redirectRoutes: null,
+      rewriteRoutes: null,
+      errorRoutes: null
+    };
+  }
   const { framework } = projectSettings;
-  const configuredServices = experimentalServicesV2 ?? experimentalServicesV1;
-  const configuredServicesType = experimentalServicesV2 ? "experimentalServicesV2" : "experimentalServices";
+  const servicesConfig = services ?? experimentalServicesV2;
+  const configuredServices = servicesConfig ?? experimentalServicesV1;
+  const configuredServicesType = servicesConfig ? services ? "services" : "experimentalServicesV2" : "experimentalServices";
   const hasServicesConfig = configuredServices != null && typeof configuredServices === "object";
   if (hasServicesConfig || framework === "services") {
     const result = await (0, import_get_services_builders.getServicesBuilders)({

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { autoDetectServices } from './services/auto-detect';
 export type { AutoDetectOptions, AutoDetectResult, } from './services/auto-detect';
 export { isStaticBuild, isRouteOwningBuilder, INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPath, getInternalServiceCronPathPrefix, getInternalServiceWorkerPath, getInternalServiceWorkerPathPrefix, } from './services/utils';
 export { getServicesBuilders } from './services/get-services-builders';
-export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, InferredServicesConfig, ResolvedServicesResult, InferredServicesResult, ResolvedService, Service, ExperimentalService, ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServicesRoutes, ServiceDetectionError, } from './services/types';
+export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, InferredServicesConfig, ResolvedServicesResult, InferredServicesResult, ResolvedService, Service, ExperimentalService, ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ServicesRoutes, ServiceDetectionError, } from './services/types';
 export { detectFileSystemAPI } from './detect-file-system-api';
 export { detectFramework, detectFrameworks, detectFrameworkRecord, detectFrameworkVersion, } from './detect-framework';
 export { getProjectPaths } from './get-project-paths';

package/dist/services/detect-services.js

@@ -106,8 +106,23 @@ async function detectServices(options) {
       warnings: []
     });
   }
+  if (vercelConfig?.services != null && vercelConfig.experimentalServicesV2 != null) {
+    return withResolvedResult({
+      services: [],
+      source: "configured",
+      useImplicitEnvInjection: false,
+      routes: emptyRoutes(),
+      errors: [
+        {
+          code: "SERVICES_AND_EXPERIMENTAL_SERVICES_V2",
+          message: "The `services` property cannot be used in conjunction with its deprecated alias `experimentalServicesV2`. Please use only `services`."
+        }
+      ],
+      warnings: []
+    });
+  }
   const hasProvidedConfiguredServices = providedConfiguredServices && Object.keys(providedConfiguredServices).length > 0;
-  const experimentalServicesV2 = hasProvidedConfiguredServices && providedConfiguredServicesType === "experimentalServicesV2" ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.experimentalServicesV2;
+  const experimentalServicesV2 = hasProvidedConfiguredServices && (providedConfiguredServicesType === "services" || providedConfiguredServicesType === "experimentalServicesV2") ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.services ?? vercelConfig?.experimentalServicesV2;
   if (experimentalServicesV2 && Object.keys(experimentalServicesV2).length > 0) {
     const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
       experimentalServicesV2,
@@ -286,11 +301,12 @@ function generateServicesRoutes(allServices) {
       }
     } else if (service.runtime) {
       const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
+      const check = service.runtime === "container" ? void 0 : true;
       if (routePrefix === "/") {
         defaults.push({
           src: (0, import_routing_utils.scopeRouteSourceToOwnership)("^/(.*)$", ownershipGuard),
           dest: functionPath,
-          check: true
+          ...check ? { check } : {}
         });
       } else {
         rewrites.push({
@@ -299,7 +315,7 @@ function generateServicesRoutes(allServices) {
             ownershipGuard
           ),
           dest: functionPath,
-          check: true
+          ...check ? { check } : {}
         });
       }
     }

package/dist/services/resolve-v2.js

@@ -31,6 +31,67 @@ var import_resolve = require("./resolve");
 var import_utils = require("./utils");
 const frameworksBySlug = new Map(import_frameworks.frameworkList.map((f) => [f.slug, f]));
 const SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+function isDockerfileEntrypoint(entrypoint) {
+  const base = import_path.posix.basename(entrypoint).toLowerCase();
+  return base === "dockerfile" || base === "containerfile" || base.endsWith(".dockerfile");
+}
+function normalizeContainerCommand(command) {
+  if (command === void 0) {
+    return void 0;
+  }
+  return Array.isArray(command) ? command : [command];
+}
+function resolveContainerServiceV2(name, config, normalizedRoot) {
+  const isRoot = normalizedRoot === ".";
+  const entrypoint = config.entrypoint;
+  const dockerfile = typeof entrypoint === "string" && isDockerfileEntrypoint(entrypoint) ? import_path.posix.normalize(entrypoint) : void 0;
+  const image = typeof entrypoint === "string" && !dockerfile ? entrypoint : void 0;
+  if (!dockerfile && !image) {
+    return {
+      error: {
+        code: "MISSING_SERVICE_CONFIG",
+        message: `Container service "${name}" must specify an "entrypoint": a Dockerfile path to build, or a prebuilt OCI image reference.`,
+        serviceName: name
+      }
+    };
+  }
+  const localSrc = dockerfile ?? image ?? "Dockerfile";
+  const builderSrc = isRoot ? localSrc : import_path.posix.join(normalizedRoot, localSrc);
+  const builderConfig = { zeroConfig: true };
+  if (!isRoot) {
+    builderConfig.workspace = normalizedRoot;
+  }
+  if (image) {
+    builderConfig.handler = image;
+  }
+  const command = normalizeContainerCommand(config.command);
+  if (command) {
+    builderConfig.command = command;
+  }
+  return {
+    service: {
+      schema: "experimentalServicesV2",
+      name,
+      root: normalizedRoot,
+      runtime: "container",
+      entrypoint: image ?? dockerfile,
+      command,
+      builder: {
+        src: builderSrc,
+        use: "@vercel/container",
+        config: builderConfig
+      },
+      bindings: config.bindings,
+      functions: config.functions,
+      headers: config.headers,
+      redirects: config.redirects,
+      rewrites: config.rewrites,
+      routes: config.routes,
+      cleanUrls: config.cleanUrls,
+      trailingSlash: config.trailingSlash
+    }
+  };
+}
 function validateServiceConfigV2(name, config) {
   if (!SERVICE_NAME_REGEX.test(name)) {
     return {
@@ -92,7 +153,8 @@ function validateServiceConfigV2(name, config) {
       };
     }
   }
-  if (!config.framework && !config.entrypoint) {
+  const isContainer = config.runtime === "container";
+  if (!config.framework && !config.entrypoint && !isContainer) {
     return {
       code: "MISSING_SERVICE_CONFIG",
       message: `Service "${name}" must specify "framework" or "entrypoint".`,
@@ -103,6 +165,10 @@ function validateServiceConfigV2(name, config) {
 }
 async function resolveConfiguredServiceV2(name, config, fs) {
   const normalizedRoot = (0, import_utils.stripTrailingSlash)(import_path.posix.normalize(config.root));
+  const isContainer = config.runtime === "container" || typeof config.entrypoint === "string" && isDockerfileEntrypoint(config.entrypoint);
+  if (isContainer) {
+    return resolveContainerServiceV2(name, config, normalizedRoot);
+  }
   const serviceFsResult = normalizedRoot === "." ? { fs } : await (0, import_resolve.getServiceFs)(fs, name, normalizedRoot);
   if (serviceFsResult.error) {
     return { error: serviceFsResult.error };

package/dist/services/resolve.js

@@ -56,6 +56,12 @@ const ENTRYPOINT_REQUIRED_RUNTIMES = /* @__PURE__ */ new Set([
   "python",
   "go"
 ]);
+function isContainerRuntime(config) {
+  return config.runtime === "container";
+}
+function normalizeContainerCommand(command) {
+  return Array.isArray(command) ? command : [command];
+}
 async function getServiceFs(fs, serviceName, root) {
   if (!root) {
     return { fs };
@@ -141,6 +147,10 @@ async function resolveEntrypointPath({
     }
   };
 }
+function isDockerfileEntrypoint(entrypoint) {
+  const base = import_path.posix.basename(entrypoint).toLowerCase();
+  return base === "dockerfile" || base === "containerfile" || base.endsWith(".dockerfile");
+}
 function toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
   const normalizedEntrypoint = import_path.posix.normalize(entrypoint);
   if (workspace === ".") {
@@ -519,6 +529,13 @@ function validateServiceConfig(name, config, options = {}) {
       serviceName: name
     };
   }
+  if (config.command !== void 0 && !isContainerRuntime(config)) {
+    return {
+      code: "INVALID_COMMAND",
+      message: `Service "${name}" can only specify "command" when using runtime "container".`,
+      serviceName: name
+    };
+  }
   return null;
 }
 function validateServiceEntrypoint(name, config, resolvedEntrypoint) {
@@ -559,8 +576,11 @@ async function resolveConfiguredService(options) {
   const configuredRoutePrefix = routingResult.routing?.routePrefix;
   const configuredSubdomain = routingResult.routing?.subdomain;
   const routePrefixWasConfigured = routingResult.routing?.routePrefixConfigured ?? false;
+  const containerEntrypoint = isContainerRuntime(config) && typeof rawEntrypoint === "string" ? rawEntrypoint : void 0;
+  const containerDockerfile = containerEntrypoint && isDockerfileEntrypoint(containerEntrypoint) ? import_path.posix.normalize(containerEntrypoint) : void 0;
+  const containerImage = containerEntrypoint && !containerDockerfile ? containerEntrypoint : void 0;
   let resolvedEntrypointPath = resolvedEntrypoint;
-  if (!resolvedEntrypointPath && typeof rawEntrypoint === "string") {
+  if (!containerEntrypoint && !resolvedEntrypointPath && typeof rawEntrypoint === "string") {
     const entrypointToResolve = moduleAttrParsed ? moduleAttrParsed.filePath : rawEntrypoint;
     const resolved = await resolveEntrypointPath({
       fs: serviceFs,
@@ -569,7 +589,7 @@ async function resolveConfiguredService(options) {
     });
     resolvedEntrypointPath = resolved.entrypoint;
   }
-  if (typeof rawEntrypoint === "string" && !resolvedEntrypointPath) {
+  if (!containerEntrypoint && typeof rawEntrypoint === "string" && !resolvedEntrypointPath) {
     throw new Error(
       `Failed to resolve entrypoint "${rawEntrypoint}" for service "${name}".`
     );
@@ -633,7 +653,7 @@ async function resolveConfiguredService(options) {
     } else {
       builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
     }
-    builderSrc = resolvedEntrypointFile;
+    builderSrc = inferredRuntime === "container" && typeof containerEntrypoint === "string" ? containerEntrypoint : resolvedEntrypointFile;
   }
   const normalizedSubdomain = type === "web" && typeof configuredSubdomain === "string" ? configuredSubdomain.toLowerCase() : void 0;
   const defaultRoutePrefix = type === "web" && normalizedSubdomain ? `/_/${name}` : void 0;
@@ -667,6 +687,12 @@ async function resolveConfiguredService(options) {
   if (config.framework) {
     builderConfig.framework = config.framework;
   }
+  if (containerImage) {
+    builderConfig.handler = containerImage;
+  }
+  if (config.command !== void 0) {
+    builderConfig.command = normalizeContainerCommand(config.command);
+  }
   if (moduleAttrParsed) {
     builderConfig.handlerFunction = moduleAttrParsed.attrName;
   }
@@ -677,7 +703,7 @@ async function resolveConfiguredService(options) {
     trigger,
     group,
     workspace,
-    entrypoint: resolvedEntrypointFile,
+    entrypoint: containerImage ?? containerDockerfile ?? resolvedEntrypointFile,
     routePrefix,
     routePrefixSource: resolvedRoutePrefixSource,
     subdomain: normalizedSubdomain,
@@ -716,7 +742,7 @@ async function resolveAllConfiguredServices(services, fs, routePrefixSource = "c
     }
     const serviceFs = serviceFsResult.fs;
     let resolvedEntrypoint;
-    if (typeof serviceConfig.entrypoint === "string") {
+    if (typeof serviceConfig.entrypoint === "string" && !isContainerRuntime(serviceConfig)) {
       const moduleAttr = parsePyModuleAttrEntrypoint(serviceConfig.entrypoint);
       const entrypointToResolve = moduleAttr?.filePath ?? serviceConfig.entrypoint;
       const resolvedPath = await resolveEntrypointPath({

package/dist/services/types.d.ts

@@ -1,7 +1,7 @@
 import type { Route } from '@vercel/routing-utils';
-import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceV2Config, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServicesV2, ExperimentalServiceV2Binding, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
+import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceV2Config, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
+export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
 /**
  * @deprecated Use `Service` instead
  */
@@ -42,8 +42,8 @@ export interface ServicesRoutes {
      */
     workers: Route[];
 }
-export type ConfiguredServicesType = 'experimentalServices' | 'experimentalServicesV2';
-export type ConfiguredServices = ExperimentalServices | ExperimentalServicesV2;
+export type ConfiguredServicesType = 'experimentalServices' | 'services' | 'experimentalServicesV2';
+export type ConfiguredServices = ExperimentalServices | Services;
 export type InferredServicesConfig = ExperimentalServices;
 export interface ResolvedServicesResult {
     services: Service[];
@@ -62,7 +62,7 @@ export interface InferredServicesResult {
 export interface DetectServicesResult extends ResolvedServicesResult {
     /**
      * Source of service definitions:
-     * - `configured`: loaded from explicit project configuration (`vercel.json#experimentalServices` or `vercel.json#experimentalServicesV2`)
+     * - `configured`: loaded from explicit project configuration (`vercel.json#experimentalServices`, `vercel.json#services`, or the deprecated `vercel.json#experimentalServicesV2` alias)
      * - `auto-detected`: inferred from project structure
      */
     resolved: ResolvedServicesResult;

package/dist/services/types.js

@@ -30,7 +30,8 @@ const RUNTIME_BUILDERS = {
   python: "@vercel/python",
   go: "@vercel/go",
   rust: "@vercel/rust",
-  ruby: "@vercel/ruby"
+  ruby: "@vercel/ruby",
+  container: "@vercel/container"
 };
 const RUNTIME_MANIFESTS = {
   node: ["package.json"],

package/dist/services/utils.d.ts

@@ -1,7 +1,7 @@
 import { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath } from '@vercel/build-utils';
 import type { Framework } from '@vercel/frameworks';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ServiceRuntime, ExperimentalServices, ExperimentalServicesV2, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
+import type { ServiceRuntime, ExperimentalServices, ExperimentalServicesV2, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
 export declare const DETECTION_FRAMEWORKS: Framework[];
 export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, };
 /**
@@ -66,6 +66,7 @@ export declare function inferServiceRuntime(config: {
 export interface ReadVercelConfigResult {
     config: {
         experimentalServices?: ExperimentalServices;
+        services?: Services;
         experimentalServicesV2?: ExperimentalServicesV2;
     } | null;
     error: ServiceDetectionError | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "6.9.3",
+  "version": "6.10.1",
   "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.31.1",
+    "@vercel/build-utils": "13.32.1",
+    "@vercel/frameworks": "3.30.0",
     "@vercel/routing-utils": "6.3.1",
-    "@vercel/error-utils": "2.2.0",
-    "@vercel/frameworks": "3.29.1"
+    "@vercel/error-utils": "2.2.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",