@vercel/fs-detectors 7.1.7 → 7.2.0

package/dist/services/detect-services.js

@@ -0,0 +1,424 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detect_services_exports = {};
+__export(detect_services_exports, {
+  detectServices: () => detectServices,
+  generateServiceRewrites: () => generateServiceRewrites,
+  generateServicesRoutes: () => generateServicesRoutes
+});
+module.exports = __toCommonJS(detect_services_exports);
+var import_build_utils = require("@vercel/build-utils");
+var import_routing_utils = require("@vercel/routing-utils");
+var import_framework = require("./runtimes/framework");
+var import_utils = require("./utils");
+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");
+var import_detect_procfile = require("./detect-procfile");
+const PREVIEW_DOMAIN_MISSING = [
+  { type: "host", value: { suf: ".vercel.app" } },
+  { type: "host", value: { suf: ".vercel.dev" } }
+];
+function emptyRoutes() {
+  return {
+    hostRewrites: [],
+    rewrites: [],
+    defaults: [],
+    fallbacks: [],
+    crons: [],
+    workers: []
+  };
+}
+function withResolvedResult(resolved, inferred = null) {
+  return {
+    services: resolved.services,
+    source: resolved.source,
+    useImplicitEnvInjection: resolved.useImplicitEnvInjection,
+    routes: resolved.routes,
+    rewrites: resolved.rewrites,
+    errors: resolved.errors,
+    warnings: resolved.warnings,
+    resolved,
+    inferred
+  };
+}
+function toInferredLayoutConfig(services) {
+  const inferredConfig = {};
+  for (const [name, service] of Object.entries(services)) {
+    const serviceConfig = {
+      root: service.root
+    };
+    if (service.type) {
+      serviceConfig.type = service.type;
+    }
+    if (typeof service.entrypoint === "string") {
+      serviceConfig.entrypoint = service.entrypoint;
+    }
+    if (typeof service.mountPath === "string") {
+      serviceConfig.mountPath = service.mountPath;
+    }
+    if ((0, import_framework.isFrontendFramework)(service.framework)) {
+      serviceConfig.framework = service.framework;
+    }
+    if (typeof service.buildCommand === "string") {
+      serviceConfig.buildCommand = service.buildCommand;
+    }
+    if (typeof service.runtime === "string") {
+      serviceConfig.runtime = service.runtime;
+    }
+    inferredConfig[name] = serviceConfig;
+  }
+  return inferredConfig;
+}
+async function detectServices(options) {
+  const {
+    fs,
+    workPath,
+    detectEntrypoint,
+    configuredServices: providedConfiguredServices,
+    configuredServicesType: providedConfiguredServicesType
+  } = options;
+  const scopedFs = workPath ? fs.chdir(workPath) : fs;
+  const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
+  if (configError) {
+    return withResolvedResult({
+      services: [],
+      source: "configured",
+      useImplicitEnvInjection: true,
+      routes: emptyRoutes(),
+      rewrites: [],
+      errors: [configError],
+      warnings: []
+    });
+  }
+  if (vercelConfig?.services != null && vercelConfig.experimentalServicesV2 != null) {
+    return withResolvedResult({
+      services: [],
+      source: "configured",
+      useImplicitEnvInjection: false,
+      routes: emptyRoutes(),
+      rewrites: [],
+      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 === "services" || providedConfiguredServicesType === "experimentalServicesV2") ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.services ?? vercelConfig?.experimentalServicesV2;
+  if (experimentalServicesV2 && Object.keys(experimentalServicesV2).length > 0) {
+    const result = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
+      experimentalServicesV2,
+      scopedFs
+    );
+    return withResolvedResult({
+      services: result.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(),
+      rewrites: [],
+      errors: result.errors,
+      warnings: []
+    });
+  }
+  const experimentalServicesV1 = hasProvidedConfiguredServices ? providedConfiguredServices : vercelConfig?.experimentalServices;
+  const hasExperimentalServicesV1 = experimentalServicesV1 && Object.keys(experimentalServicesV1).length > 0;
+  if (hasExperimentalServicesV1) {
+    const result = await (0, import_resolve.resolveAllConfiguredServices)(
+      experimentalServicesV1,
+      scopedFs,
+      "configured"
+    );
+    const routes = generateServicesRoutes(result.services);
+    return withResolvedResult({
+      services: result.services,
+      source: "configured",
+      // experimentalServices uses the legacy `{NAME}_URL` injection.
+      useImplicitEnvInjection: true,
+      routes,
+      rewrites: [],
+      errors: result.errors,
+      warnings: []
+    });
+  }
+  const detectors = [
+    { detect: import_detect_railway.detectRailwayServices, source: "railway" },
+    { detect: import_detect_render.detectRenderServices, source: "render" },
+    { detect: import_detect_procfile.detectProcfileServices, source: "procfile" },
+    { detect: import_auto_detect.autoDetectServices, source: "layout" }
+  ];
+  for (const { detect, source } of detectors) {
+    const detectResult = await detect({ fs: scopedFs, detectEntrypoint });
+    const match = await tryResolveInferred(detectResult, source, scopedFs);
+    if (match)
+      return match;
+  }
+  return withResolvedResult({
+    services: [],
+    source: "auto-detected",
+    useImplicitEnvInjection: true,
+    routes: emptyRoutes(),
+    rewrites: [],
+    errors: [
+      {
+        code: "NO_SERVICES_CONFIGURED",
+        message: "No services configured. Add `services` to vercel.json."
+      }
+    ],
+    warnings: []
+  });
+}
+async function tryResolveInferred(detectResult, source, scopedFs) {
+  if (detectResult.errors.length > 0) {
+    return withResolvedResult({
+      services: [],
+      source: "auto-detected",
+      useImplicitEnvInjection: source !== "layout",
+      routes: emptyRoutes(),
+      rewrites: [],
+      errors: detectResult.errors,
+      warnings: detectResult.warnings
+    });
+  }
+  if (!detectResult.services) {
+    return null;
+  }
+  if (source === "layout") {
+    const v2Services = {};
+    for (const [name, svc] of Object.entries(detectResult.services)) {
+      v2Services[name] = {
+        root: svc.root,
+        ...svc.framework ? { framework: svc.framework } : {},
+        ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {}
+      };
+    }
+    const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(v2Services, scopedFs);
+    const rootServices = Object.values(detectResult.services).filter(
+      (svc) => svc.mountPath === "/" && typeof svc.framework === "string"
+    );
+    const shouldInfer2 = result2.errors.length === 0 && rootServices.length === 1 && result2.services.length > 1;
+    const inferred2 = shouldInfer2 ? {
+      source,
+      config: toInferredLayoutConfig(detectResult.services),
+      services: result2.services,
+      warnings: detectResult.warnings
+    } : null;
+    return withResolvedResult(
+      {
+        services: shouldInfer2 ? result2.services : [],
+        source: "auto-detected",
+        useImplicitEnvInjection: false,
+        routes: emptyRoutes(),
+        rewrites: shouldInfer2 ? generateServiceRewrites(detectResult.services) : [],
+        experimentalServicesV2: shouldInfer2 ? v2Services : void 0,
+        errors: result2.errors,
+        warnings: detectResult.warnings
+      },
+      inferred2
+    );
+  }
+  const v1Services = {};
+  for (const [name, svc] of Object.entries(detectResult.services)) {
+    v1Services[name] = {
+      root: svc.root === "." ? void 0 : svc.root,
+      ...svc.framework ? { framework: svc.framework } : {},
+      ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {},
+      ...svc.type ? { type: svc.type } : {},
+      ...svc.buildCommand ? { buildCommand: svc.buildCommand } : {},
+      ...svc.preDeployCommand ? { preDeployCommand: svc.preDeployCommand } : {},
+      ...svc.mountPath ? { routePrefix: svc.mountPath } : {}
+    };
+  }
+  const result = await (0, import_resolve.resolveAllConfiguredServices)(
+    v1Services,
+    scopedFs,
+    "generated"
+  );
+  const shouldInfer = result.errors.length === 0 && result.services.length > 0;
+  const inferred = shouldInfer ? {
+    source,
+    config: toInferredLayoutConfig(detectResult.services),
+    services: result.services,
+    warnings: detectResult.warnings
+  } : null;
+  return withResolvedResult(
+    {
+      services: [],
+      source: "auto-detected",
+      useImplicitEnvInjection: true,
+      routes: emptyRoutes(),
+      rewrites: [],
+      errors: result.errors,
+      warnings: detectResult.warnings
+    },
+    inferred
+  );
+}
+function generateServiceRewrites(services) {
+  const entries = Object.entries(services).filter(
+    ([, svc]) => typeof svc.mountPath === "string" && (!svc.type || svc.type === "web")
+  ).sort(([, a], [, b]) => b.mountPath.length - a.mountPath.length);
+  return entries.map(([name, svc]) => {
+    const mountPath = svc.mountPath;
+    if (mountPath === "/") {
+      return {
+        source: "/(.*)",
+        destination: { type: "service", service: name }
+      };
+    }
+    const prefix = mountPath.startsWith("/") ? mountPath.slice(1) : mountPath;
+    return {
+      source: `/${prefix}(/.*)?`,
+      destination: { type: "service", service: name }
+    };
+  });
+}
+function generateServicesRoutes(allServices) {
+  const services = allServices.filter(import_build_utils.isExperimentalService);
+  const hostRewrites = [];
+  const rewrites = [];
+  const defaults = [];
+  const fallbacks = [];
+  const crons = [];
+  const workers = [];
+  const sortedWebServices = services.filter(
+    (s) => s.type === "web" && typeof s.routePrefix === "string"
+  ).sort((a, b) => b.routePrefix.length - a.routePrefix.length);
+  const allWebPrefixes = getWebRoutePrefixes(sortedWebServices);
+  const explicitHostPrefixGuard = getExplicitHostPrefixNegativeLookahead(allWebPrefixes);
+  for (const service of sortedWebServices) {
+    const { routePrefix } = service;
+    const normalizedPrefix = routePrefix.slice(1);
+    const ownershipGuard = (0, import_routing_utils.getOwnershipGuard)(routePrefix, allWebPrefixes);
+    const hostCondition = getHostCondition(service);
+    if (hostCondition && routePrefix !== "/") {
+      const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(routePrefix);
+      hostRewrites.push({
+        src: "^/$",
+        dest: normalizedRoutePrefix,
+        has: hostCondition,
+        missing: PREVIEW_DOMAIN_MISSING,
+        check: true
+      });
+      hostRewrites.push({
+        // Preserve explicit service prefixes so canonical paths like /_/api
+        // keep routing to their target service even on another service's host.
+        src: `^/${explicitHostPrefixGuard}(.*)$`,
+        dest: `${normalizedRoutePrefix}/$1`,
+        has: hostCondition,
+        missing: PREVIEW_DOMAIN_MISSING,
+        check: true
+      });
+    }
+    if ((0, import_utils.isRouteOwningBuilder)(service)) {
+      continue;
+    }
+    if ((0, import_utils.isStaticBuild)(service)) {
+      if (routePrefix === "/") {
+        fallbacks.push({
+          src: (0, import_routing_utils.scopeRouteSourceToOwnership)("/(.*)", ownershipGuard),
+          dest: "/index.html"
+        });
+      } else {
+        fallbacks.push({
+          src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
+            `^/${normalizedPrefix}(?:/.*)?$`,
+            ownershipGuard
+          ),
+          dest: `/${normalizedPrefix}/index.html`
+        });
+      }
+    } 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 ? { check } : {}
+        });
+      } else {
+        rewrites.push({
+          src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
+            `^/${normalizedPrefix}(?:/.*)?$`,
+            ownershipGuard
+          ),
+          dest: functionPath,
+          ...check ? { check } : {}
+        });
+      }
+    }
+  }
+  const cronServices = services.filter(import_build_utils.isScheduleTriggeredService);
+  for (const service of cronServices) {
+    const cronPrefix = (0, import_utils.getInternalServiceCronPathPrefix)(service.name);
+    const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
+    crons.push({
+      src: `^${escapeRegex(cronPrefix)}/.*$`,
+      dest: functionPath,
+      check: true
+    });
+  }
+  return { hostRewrites, rewrites, defaults, fallbacks, crons, workers };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getWebRoutePrefixes(services) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const service of services) {
+    if (service.type !== "web" || typeof service.routePrefix !== "string") {
+      continue;
+    }
+    unique.add((0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix));
+  }
+  return Array.from(unique);
+}
+function getExplicitHostPrefixNegativeLookahead(routePrefixes) {
+  const explicitPrefixes = routePrefixes.map(import_routing_utils.normalizeRoutePrefix).filter((prefix) => prefix !== "/").sort((a, b) => b.length - a.length).map((prefix) => escapeRegex(prefix.slice(1)));
+  if (explicitPrefixes.length === 0) {
+    return "";
+  }
+  if (explicitPrefixes.length === 1) {
+    return `(?!${explicitPrefixes[0]}(?:/|$))`;
+  }
+  return `(?!(?:${explicitPrefixes.join("|")})(?:/|$))`;
+}
+function getHostCondition(service) {
+  if (service.type !== "web") {
+    return void 0;
+  }
+  if (typeof service.subdomain === "string" && service.subdomain.length > 0) {
+    return [{ type: "host", value: { pre: `${service.subdomain}.` } }];
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectServices,
+  generateServiceRewrites,
+  generateServicesRoutes
+});

package/dist/services/resolve-v2.d.ts

@@ -0,0 +1,11 @@
+import type { ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ServiceDetectionError } from './types';
+import type { DetectorFilesystem } from '../detectors/filesystem';
+export declare function validateServiceConfigV2(name: string, config: ExperimentalServiceV2Config): ServiceDetectionError | null;
+export declare function resolveConfiguredServiceV2(name: string, config: ExperimentalServiceV2Config, fs: DetectorFilesystem): Promise<{
+    service?: ExperimentalServiceV2;
+    error?: ServiceDetectionError;
+}>;
+export declare function resolveAllConfiguredServicesV2(services: ExperimentalServicesV2, fs: DetectorFilesystem): Promise<{
+    services: ExperimentalServiceV2[];
+    errors: ServiceDetectionError[];
+}>;