@vercel/fs-detectors 7.1.6 → 7.2.0

package/dist/services/detect-railway.d.ts

@@ -0,0 +1,22 @@
+import type { DetectEntrypointFn } from '@vercel/build-utils';
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
+export interface RailwayDetectResult {
+    services: InferredServicesConfig | null;
+    errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+/**
+ * Detect Railway service configurations in the project.
+ *
+ * Scans for railway.{json,toml} files, parses them,
+ * tries to detect frameworks in each service directory, and maps to
+ * services format.
+ *
+ * When a Railway config has `deploy.preDeployCommand`, it's added to
+ * `buildCommand` since we don't have a separate pre-deploy yet.
+ */
+export declare function detectRailwayServices(options: {
+    fs: DetectorFilesystem;
+    detectEntrypoint?: DetectEntrypointFn;
+}): Promise<RailwayDetectResult>;

package/dist/services/detect-railway.js

@@ -0,0 +1,242 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detect_railway_exports = {};
+__export(detect_railway_exports, {
+  detectRailwayServices: () => detectRailwayServices
+});
+module.exports = __toCommonJS(detect_railway_exports);
+var import_path = require("path");
+var import_smol_toml = __toESM(require("smol-toml"));
+var import_detect_framework = require("../detect-framework");
+var import_framework = require("./runtimes/framework");
+var import_utils = require("./utils");
+const RAILWAY_JSON = "railway.json";
+const RAILWAY_TOML = "railway.toml";
+const MAX_SCAN_DEPTH = 5;
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".hg",
+  ".git",
+  ".svn",
+  ".cache",
+  ".next",
+  ".now",
+  ".vercel",
+  ".venv",
+  ".yarn",
+  ".turbo",
+  ".output",
+  "node_modules",
+  "__pycache__",
+  "venv",
+  "CVS"
+]);
+async function detectRailwayServices(options) {
+  const { fs, detectEntrypoint } = options;
+  const { configs, warnings } = await findRailwayConfigs(fs);
+  if (configs.length === 0) {
+    return { services: null, errors: [], warnings };
+  }
+  const services = {};
+  const serviceDirs = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const cf of configs) {
+    const serviceFs = cf.dirPath === "." ? fs : fs.chdir(cf.dirPath);
+    const dirLabel = cf.dirPath === "." ? "root" : cf.dirPath;
+    const frameworks = await (0, import_detect_framework.detectFrameworks)({
+      fs: serviceFs,
+      frameworkList: import_framework.DETECTION_FRAMEWORKS,
+      useExperimentalFrameworks: true
+    });
+    if (cf.config.deploy?.cronSchedule) {
+      const schedule = cf.config.deploy.cronSchedule;
+      const runtime = frameworks.length === 1 ? (0, import_framework.inferRuntimeFromFramework)(frameworks[0].slug) : void 0;
+      const hint = {
+        type: "job",
+        trigger: "schedule",
+        schedule,
+        entrypoint: "<path-to-handler>"
+      };
+      if (runtime) {
+        hint.runtime = runtime;
+      }
+      warnings.push({
+        code: "RAILWAY_CRON_HINT",
+        message: `Found Railway cron in ${dirLabel}/ (schedule: "${schedule}"). Vercel crons work with a file entrypoint. You can add the following to define this scheduled job service:
+"${deriveServiceName(cf.dirPath)}": ${JSON.stringify(hint, null, 2)}`
+      });
+      continue;
+    }
+    const serviceName = deriveServiceName(cf.dirPath);
+    const existingDir = serviceDirs.get(serviceName);
+    if (existingDir) {
+      errors.push({
+        code: "DUPLICATE_SERVICE",
+        message: `Duplicate service name "${serviceName}" derived from ${existingDir}/ and ${dirLabel}/. Rename one of the directories to avoid conflicts.`,
+        serviceName
+      });
+      continue;
+    }
+    serviceDirs.set(serviceName, dirLabel);
+    if (frameworks.length === 0) {
+      warnings.push({
+        code: "SERVICE_SKIPPED",
+        message: `Skipped service in ${dirLabel}/: no framework detected. Configure it manually in services.`
+      });
+      continue;
+    }
+    if (frameworks.length > 1) {
+      const names = frameworks.map((f) => f.name).join(", ");
+      errors.push({
+        code: "MULTIPLE_FRAMEWORKS_SERVICE",
+        message: `Multiple frameworks detected in ${dirLabel}/: ${names}. Use explicit services config.`,
+        serviceName
+      });
+      continue;
+    }
+    const framework = frameworks[0];
+    const slug = framework.slug ?? void 0;
+    const serviceConfig = {
+      root: cf.dirPath,
+      framework: slug
+    };
+    if (cf.dirPath !== "." && detectEntrypoint && !(0, import_framework.isFrontendFramework)(slug)) {
+      const detected = await detectEntrypoint({
+        workPath: cf.dirPath,
+        framework: slug
+      });
+      if (detected) {
+        serviceConfig.entrypoint = detected.entrypoint;
+      }
+    }
+    if (cf.config.build?.buildCommand) {
+      serviceConfig.buildCommand = cf.config.build.buildCommand;
+    }
+    const railwayPreDeploy = cf.config.deploy?.preDeployCommand;
+    if (railwayPreDeploy) {
+      serviceConfig.preDeployCommand = Array.isArray(railwayPreDeploy) ? railwayPreDeploy.join(" && ") : railwayPreDeploy;
+    }
+    services[serviceName] = serviceConfig;
+  }
+  if (errors.length > 0) {
+    return { services: null, errors, warnings };
+  }
+  const serviceNames = Object.keys(services);
+  if (serviceNames.length === 0) {
+    return { services: null, errors: [], warnings };
+  }
+  warnings.push(...(0, import_utils.assignMountPaths)(services));
+  return { services, errors: [], warnings };
+}
+async function findRailwayConfigs(fs, dirPath = ".", depth = 0) {
+  const configs = [];
+  const warnings = [];
+  const readResult = await readRailwayConfigRaw(fs, dirPath);
+  warnings.push(...readResult.warnings);
+  const { config, warning } = tryParseRailwayConfig(readResult.raw);
+  if (warning) {
+    warnings.push(warning);
+  }
+  if (config) {
+    configs.push({ dirPath, config });
+  }
+  if (depth >= MAX_SCAN_DEPTH) {
+    return { configs, warnings };
+  }
+  const readPath = dirPath === "." ? "/" : dirPath;
+  let entries;
+  try {
+    entries = await fs.readdir(readPath);
+  } catch {
+    return { configs, warnings };
+  }
+  for (const entry of entries) {
+    if (entry.type !== "dir" || SKIP_DIRS.has(entry.name)) {
+      continue;
+    }
+    const childPath = dirPath === "." ? entry.name : import_path.posix.join(dirPath, entry.name);
+    const child = await findRailwayConfigs(fs, childPath, depth + 1);
+    configs.push(...child.configs);
+    warnings.push(...child.warnings);
+  }
+  return { configs, warnings };
+}
+async function readRailwayConfigRaw(fs, dirPath) {
+  const warnings = [];
+  for (const filename of [RAILWAY_JSON, RAILWAY_TOML]) {
+    const filePath = dirPath === "." ? filename : import_path.posix.join(dirPath, filename);
+    try {
+      const exists = await fs.isFile(filePath);
+      if (!exists)
+        continue;
+    } catch {
+      continue;
+    }
+    try {
+      const buf = await fs.readFile(filePath);
+      return {
+        raw: { path: filePath, content: buf.toString("utf-8") },
+        warnings
+      };
+    } catch (err) {
+      warnings.push({
+        code: "RAILWAY_CONFIG_ERROR",
+        message: `Failed to read ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return { raw: null, warnings };
+}
+function tryParseRailwayConfig(raw) {
+  if (!raw) {
+    return { config: null };
+  }
+  try {
+    const config = raw.path.endsWith(".toml") ? import_smol_toml.default.parse(raw.content) : JSON.parse(raw.content);
+    return { config };
+  } catch (err) {
+    return {
+      config: null,
+      warning: {
+        code: "RAILWAY_PARSE_ERROR",
+        message: `Failed to parse ${raw.path}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
+function deriveServiceName(dirPath) {
+  if (dirPath === ".") {
+    return "web";
+  }
+  const segments = dirPath.split("/");
+  return segments[segments.length - 1];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectRailwayServices
+});

package/dist/services/detect-render.d.ts

@@ -0,0 +1,14 @@
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { DetectEntrypointFn, InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
+export interface RenderDetectResult {
+    services: InferredServicesConfig | null;
+    errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+/**
+ * Detect Render service configurations from render.yaml.
+ */
+export declare function detectRenderServices(options: {
+    fs: DetectorFilesystem;
+    detectEntrypoint?: DetectEntrypointFn;
+}): Promise<RenderDetectResult>;

package/dist/services/detect-render.js

@@ -0,0 +1,231 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detect_render_exports = {};
+__export(detect_render_exports, {
+  detectRenderServices: () => detectRenderServices
+});
+module.exports = __toCommonJS(detect_render_exports);
+var import_js_yaml = __toESM(require("js-yaml"));
+var import_detect_framework = require("../detect-framework");
+var import_constants = require("./runtimes/constants");
+var import_framework = require("./runtimes/framework");
+var import_utils = require("./utils");
+const RENDER_YAML = "render.yaml";
+const SERVICE_TYPE_MAP = {
+  web: "web",
+  static: "web"
+};
+async function detectRenderServices(options) {
+  const { fs, detectEntrypoint } = options;
+  const raw = await readRenderYaml(fs);
+  if (raw.warning) {
+    return { services: null, errors: [], warnings: [raw.warning] };
+  } else if (!raw.content) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const parsed = tryParseRenderConfig(raw.content);
+  if (parsed.warning) {
+    return { services: null, errors: [], warnings: [parsed.warning] };
+  } else if (!parsed.config) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const renderServices = parsed.config.services;
+  if (!Array.isArray(renderServices) || renderServices.length === 0) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const services = {};
+  const serviceNames = /* @__PURE__ */ new Set();
+  const errors = [];
+  const warnings = [];
+  for (const rs of renderServices) {
+    const serviceType = rs.type;
+    if (serviceType === "cron") {
+      const name = rs.name ?? "unnamed";
+      const schedule = rs.schedule;
+      const runtime = rs.runtime && rs.runtime in import_constants.RUNTIME_BUILDERS ? rs.runtime : void 0;
+      const hint = {
+        type: "cron",
+        ...schedule ? { schedule } : {},
+        entrypoint: "<path-to-handler>",
+        ...runtime ? { runtime } : {}
+      };
+      warnings.push({
+        code: "RENDER_CRON_HINT",
+        message: `Found Render cron service "${name}"` + (schedule ? ` (schedule: "${schedule}")` : "") + `. Vercel crons work with a file entrypoint. You can add the following to define this cron service:
+"${name}": ${JSON.stringify(hint, null, 2)}`
+      });
+      continue;
+    }
+    if (serviceType === "worker") {
+      const name = rs.name ?? "unnamed";
+      const runtime = rs.runtime ?? "unknown";
+      if (runtime === "python") {
+        const hint = {
+          type: "worker",
+          entrypoint: "<path-to-celery-app>",
+          runtime: "python"
+        };
+        warnings.push({
+          code: "RENDER_WORKER_HINT",
+          message: `Found Render worker service "${name}". Python workers using Celery are supported. You can add the following to define this worker:
+"${name}": ${JSON.stringify(hint, null, 2)}`
+        });
+      } else {
+        warnings.push({
+          code: "RENDER_WORKER_HINT",
+          message: `Found Render worker service "${name}" with runtime "${runtime}". Only Python workers are currently supported.`
+        });
+      }
+      continue;
+    }
+    if (serviceType === "pserv") {
+      const name = rs.name ?? "unnamed";
+      const hint = {
+        entrypoint: rs.rootDir ?? "<path-to-entrypoint>",
+        mountPath: `/api/${name}`
+      };
+      warnings.push({
+        code: "RENDER_PSERV_HINT",
+        message: `Found Render private service "${name}". Private services are not yet supported. If you'd like to deploy it as a regular web service, you can add the following:
+"${name}": ${JSON.stringify(hint, null, 2)}`
+      });
+      continue;
+    }
+    if (!serviceType || !(serviceType in SERVICE_TYPE_MAP)) {
+      continue;
+    }
+    const serviceName = rs.name;
+    if (!serviceName) {
+      warnings.push({
+        code: "RENDER_CONFIG_ERROR",
+        message: "Skipped a Render service with no name. Each service in render.yaml must have a name."
+      });
+      continue;
+    }
+    if (serviceNames.has(serviceName)) {
+      errors.push({
+        code: "DUPLICATE_SERVICE",
+        message: `Duplicate service name "${serviceName}" in render.yaml.`,
+        serviceName
+      });
+      continue;
+    }
+    serviceNames.add(serviceName);
+    const rootDir = rs.rootDir || ".";
+    const serviceFs = rootDir === "." ? fs : fs.chdir(rootDir);
+    const frameworks = await (0, import_detect_framework.detectFrameworks)({
+      fs: serviceFs,
+      frameworkList: import_framework.DETECTION_FRAMEWORKS,
+      useExperimentalFrameworks: true
+    });
+    if (frameworks.length === 0) {
+      warnings.push({
+        code: "SERVICE_SKIPPED",
+        message: `Skipped Render service "${serviceName}": no framework detected. Configure it manually in services.`
+      });
+      continue;
+    }
+    if (frameworks.length > 1) {
+      const names = frameworks.map((f) => f.name).join(", ");
+      errors.push({
+        code: "MULTIPLE_FRAMEWORKS_SERVICE",
+        message: `Multiple frameworks detected for Render service "${serviceName}": ${names}. Use explicit services config.`,
+        serviceName
+      });
+      continue;
+    }
+    const framework = frameworks[0];
+    const vercelType = SERVICE_TYPE_MAP[serviceType];
+    const serviceConfig = {
+      root: rootDir,
+      type: vercelType,
+      framework: framework.slug ?? void 0
+    };
+    if (rootDir !== "." && detectEntrypoint && !(0, import_framework.isFrontendFramework)(serviceConfig.framework)) {
+      const detected = await detectEntrypoint({
+        workPath: rootDir,
+        framework: serviceConfig.framework
+      });
+      if (detected) {
+        serviceConfig.entrypoint = detected.entrypoint;
+      }
+    }
+    const buildCommand = (0, import_utils.combineBuildCommand)(
+      rs.buildCommand,
+      rs.preDeployCommand
+    );
+    if (buildCommand) {
+      serviceConfig.buildCommand = buildCommand;
+    }
+    services[serviceName] = serviceConfig;
+  }
+  if (errors.length > 0) {
+    return { services: null, errors, warnings };
+  }
+  if (Object.keys(services).length === 0) {
+    return { services: null, errors: [], warnings };
+  }
+  warnings.push(...(0, import_utils.assignMountPaths)(services));
+  return { services, errors: [], warnings };
+}
+async function readRenderYaml(fs) {
+  try {
+    const exists = await fs.isFile(RENDER_YAML);
+    if (!exists)
+      return { content: null };
+    const buf = await fs.readFile(RENDER_YAML);
+    return { content: buf.toString("utf-8") };
+  } catch (err) {
+    return {
+      content: null,
+      warning: {
+        code: "RENDER_CONFIG_ERROR",
+        message: `Failed to read ${RENDER_YAML}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
+function tryParseRenderConfig(content) {
+  try {
+    const config = import_js_yaml.default.load(content);
+    return { config };
+  } catch (err) {
+    return {
+      config: null,
+      warning: {
+        code: "RENDER_PARSE_ERROR",
+        message: `Failed to parse ${RENDER_YAML}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectRenderServices
+});

package/dist/services/detect-services.d.ts

@@ -0,0 +1,48 @@
+import type { Rewrite } from '@vercel/routing-utils';
+import type { DetectServicesOptions, DetectServicesResult, InferredServicesConfig, Service, ServicesRoutes } from './types';
+/**
+ * Detect and resolve services within a project.
+ *
+ * Reads vercel.json and resolves configured services into Service objects.
+ * Returns an error if no services are configured.
+ */
+export declare function detectServices(options: DetectServicesOptions): Promise<DetectServicesResult>;
+/**
+ * Generate top-level service-targeted rewrites from inferred mount paths.
+ *
+ * Produces `Rewrite` objects (same format as vercel.json `rewrites`) that
+ * delegate public traffic into services based on their `mountPath`.
+ *
+ * Rewrites are ordered by mount path length (longest first) so more
+ * specific paths match before broader ones. The root service (`/`) is
+ * always last as a catch-all.
+ */
+export declare function generateServiceRewrites(services: InferredServicesConfig): Rewrite[];
+/**
+ * Generate routing rules for services.
+ *
+ * Routes are ordered by prefix length (longest first) to ensure more specific
+ * routes match before broader ones. For example, `/api/users` must be checked
+ * before `/api`, which must be checked before the catch-all `/`.
+ *
+ * Services routing only generates *synthetic* routes for builders that do not
+ * provide their own route tables:
+ *
+ * - **Static/SPA services** (`@vercel/static-build`, `@vercel/static`):
+ *   SPA fallback routes to index.html under the service prefix.
+ *
+ * - **Runtime services** (`@vercel/python`, `@vercel/go`, `@vercel/ruby`, etc.):
+ *   Prefix rewrites to an internal runtime destination (`/_svc/{name}/index`)
+ *   with `check: true`.
+ *
+ * Builders that provide their own routing (`@vercel/next`, `@vercel/backends`,
+ * Build Output API builders, etc.) are not given synthetic routes here.
+ *
+ * - Worker and queue-triggered job services:
+ *   Use private path routing. The generated function is not publicly accessible.
+ *
+ * - Schedule-triggered job services:
+ *   Internal cron callback routes under `/_svc/{serviceName}/crons/{entry}/{handler}`
+ *   that rewrite to `/_svc/{serviceName}/index`.
+ */
+export declare function generateServicesRoutes(allServices: Service[]): ServicesRoutes;