@vercel/fs-detectors 5.13.1 → 5.14.0

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

@@ -0,0 +1,20 @@
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
+export interface RailwayDetectResult {
+    services: ExperimentalServices | 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;
+}): Promise<RailwayDetectResult>;

package/dist/services/detect-railway.js

@@ -0,0 +1,270 @@
+"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_frameworks = require("@vercel/frameworks");
+var import_detect_framework = require("../detect-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"
+]);
+const DETECTION_FRAMEWORKS = import_frameworks.frameworkList.filter(
+  (framework) => !framework.experimental || framework.runtimeFramework
+);
+async function detectRailwayServices(options) {
+  const { fs } = 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: DETECTION_FRAMEWORKS,
+      useExperimentalFrameworks: true
+    });
+    if (cf.config.deploy?.cronSchedule) {
+      const schedule = cf.config.deploy.cronSchedule;
+      const runtime = frameworks.length === 1 ? (0, import_utils.inferRuntimeFromFramework)(frameworks[0].slug) : void 0;
+      const hint = {
+        type: "cron",
+        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 cron 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 experimentalServices.`
+      });
+      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 experimentalServices config.`,
+        serviceName
+      });
+      continue;
+    }
+    const framework = frameworks[0];
+    let serviceConfig = {};
+    serviceConfig.framework = framework.slug ?? void 0;
+    if (cf.dirPath !== ".") {
+      serviceConfig.entrypoint = cf.dirPath;
+    }
+    const buildCommand = combineBuildCommand(
+      cf.config.build?.buildCommand,
+      cf.config.deploy?.preDeployCommand
+    );
+    if (buildCommand) {
+      serviceConfig.buildCommand = buildCommand;
+    }
+    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(...assignRoutePrefixes(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];
+}
+function combineBuildCommand(buildCommand, preDeployCommand) {
+  const preDeploy = Array.isArray(preDeployCommand) ? preDeployCommand.join(" && ") : preDeployCommand;
+  if (preDeploy && buildCommand) {
+    return `${buildCommand} && ${preDeploy}`;
+  } else if (preDeploy) {
+    return preDeploy;
+  } else {
+    return buildCommand;
+  }
+}
+function assignRoutePrefixes(services) {
+  const warnings = [];
+  const names = Object.keys(services);
+  if (names.length === 1) {
+    services[names[0]].routePrefix = "/";
+    return warnings;
+  }
+  const frontendNames = names.filter(
+    (name) => (0, import_utils.isFrontendFramework)(services[name].framework)
+  );
+  let rootName = null;
+  if (frontendNames.length === 1) {
+    rootName = frontendNames[0];
+  } else if (frontendNames.length > 1) {
+    rootName = frontendNames.find((n) => n === "frontend" || n === "web") ?? frontendNames.sort()[0];
+    warnings.push({
+      code: "MULTIPLE_FRONTENDS",
+      message: `Multiple frontend services detected (${frontendNames.join(", ")}). "${rootName}" was assigned routePrefix "/". Adjust manually if a different service should be the root.`
+    });
+  }
+  for (const name of names) {
+    services[name].routePrefix = name === rootName ? "/" : `/_/${name}`;
+  }
+  return warnings;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectRailwayServices
+});

package/dist/services/detect-services.js

@@ -26,6 +26,7 @@ var import_routing_utils = require("@vercel/routing-utils");
 var import_utils = require("./utils");
 var import_resolve = require("./resolve");
 var import_auto_detect = require("./auto-detect");
+var import_detect_railway = require("./detect-railway");
 const PREVIEW_DOMAIN_MISSING = [
   { type: "host", value: { suf: ".vercel.app" } },
   { type: "host", value: { suf: ".vercel.dev" } }
@@ -63,6 +64,9 @@ function toInferredLayoutConfig(services) {
     if ((0, import_utils.isFrontendFramework)(service.framework)) {
       serviceConfig.framework = service.framework;
     }
+    if (typeof service.buildCommand === "string") {
+      serviceConfig.buildCommand = service.buildCommand;
+    }
     inferredConfig[name] = serviceConfig;
   }
   return inferredConfig;
@@ -83,17 +87,41 @@ async function detectServices(options) {
   const configuredServices = vercelConfig?.experimentalServices;
   const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
   if (!hasConfiguredServices) {
-    const autoResult = await (0, import_auto_detect.autoDetectServices)({ fs: scopedFs });
-    if (autoResult.errors.length > 0) {
+    const railwayResult = await (0, import_detect_railway.detectRailwayServices)({ fs: scopedFs });
+    if (railwayResult.errors.length > 0) {
       return withResolvedResult({
         services: [],
         source: "auto-detected",
         routes: emptyRoutes(),
-        errors: autoResult.errors,
-        warnings: []
+        errors: railwayResult.errors,
+        warnings: railwayResult.warnings
       });
     }
-    if (autoResult.services) {
+    if (railwayResult.services) {
+      const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
+        railwayResult.services,
+        scopedFs,
+        "generated"
+      );
+      const inferred = result2.errors.length === 0 && result2.services.length > 0 ? {
+        source: "railway",
+        config: toInferredLayoutConfig(railwayResult.services),
+        services: result2.services,
+        warnings: railwayResult.warnings
+      } : null;
+      return withResolvedResult(
+        {
+          services: [],
+          source: "auto-detected",
+          routes: emptyRoutes(),
+          errors: result2.errors,
+          warnings: railwayResult.warnings
+        },
+        inferred
+      );
+    }
+    const autoResult = await (0, import_auto_detect.autoDetectServices)({ fs: scopedFs });
+    if (autoResult.services && autoResult.errors.length === 0) {
       const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
         autoResult.services,
         scopedFs,
@@ -117,6 +145,14 @@ async function detectServices(options) {
         warnings: []
       } : null;
       return withResolvedResult(resolved, inferred);
+    } else if (autoResult.errors.length > 0) {
+      return withResolvedResult({
+        services: [],
+        source: "auto-detected",
+        routes: emptyRoutes(),
+        errors: autoResult.errors,
+        warnings: []
+      });
     }
     return withResolvedResult({
       services: [],

package/dist/services/types.d.ts

@@ -41,7 +41,7 @@ export interface ResolvedServicesResult {
     warnings: ServiceDetectionWarning[];
 }
 export interface InferredServicesResult {
-    source: 'layout' | 'procfile';
+    source: 'layout' | 'procfile' | 'railway';
     config: ServicesConfig;
     services: Service[];
     warnings: ServiceDetectionWarning[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.13.1",
+  "version": "5.14.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,10 +19,11 @@
     "json5": "2.2.2",
     "minimatch": "3.1.2",
     "semver": "6.3.1",
+    "smol-toml": "1.5.2",
     "@vercel/build-utils": "13.12.2",
-    "@vercel/routing-utils": "6.1.1",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/frameworks": "3.22.0"
+    "@vercel/frameworks": "3.22.0",
+    "@vercel/routing-utils": "6.1.1"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",