@vercel/fs-detectors 7.1.7 → 7.2.0

package/dist/services/utils.js

@@ -0,0 +1,157 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  INTERNAL_QUEUES_PREFIX: () => INTERNAL_QUEUES_PREFIX,
+  INTERNAL_SERVICE_PREFIX: () => import_build_utils.INTERNAL_SERVICE_PREFIX,
+  assignMountPaths: () => assignMountPaths,
+  combineBuildCommand: () => combineBuildCommand,
+  getInternalServiceCronPath: () => import_build_utils.getInternalServiceCronPath,
+  getInternalServiceCronPathPrefix: () => import_build_utils.getInternalServiceCronPathPrefix,
+  getInternalServiceFunctionPath: () => import_build_utils.getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath: () => import_build_utils.getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix: () => import_build_utils.getInternalServiceWorkerPathPrefix,
+  hasFile: () => hasFile,
+  isRouteOwningBuilder: () => isRouteOwningBuilder,
+  isStaticBuild: () => isStaticBuild,
+  readVercelConfig: () => readVercelConfig
+});
+module.exports = __toCommonJS(utils_exports);
+var import_build_utils = require("@vercel/build-utils");
+var import_constants = require("./runtimes/constants");
+var import_framework = require("./runtimes/framework");
+async function hasFile(fs, filePath) {
+  try {
+    return await fs.isFile(filePath);
+  } catch {
+    return false;
+  }
+}
+const INTERNAL_QUEUES_PREFIX = "/_svc/_queues";
+function isStaticBuild(service) {
+  return import_constants.STATIC_BUILDERS.has(service.builder.use);
+}
+function isRouteOwningBuilder(service) {
+  return import_constants.ROUTE_OWNING_BUILDERS.has(service.builder.use);
+}
+async function readVercelConfig(fs) {
+  const hasVercelJson = await fs.hasPath("vercel.json");
+  if (hasVercelJson) {
+    try {
+      const content = await fs.readFile("vercel.json");
+      const config = JSON.parse(content.toString());
+      return { config, error: null };
+    } catch {
+      return {
+        config: null,
+        error: {
+          code: "INVALID_VERCEL_JSON",
+          message: "Failed to parse vercel.json. Ensure it contains valid JSON."
+        }
+      };
+    }
+  }
+  const hasVercelToml = await fs.hasPath("vercel.toml");
+  if (hasVercelToml) {
+    try {
+      const { parse: tomlParse } = await import("smol-toml");
+      const content = await fs.readFile("vercel.toml");
+      const config = tomlParse(content.toString());
+      return { config, error: null };
+    } catch {
+      return {
+        config: null,
+        error: {
+          code: "INVALID_VERCEL_TOML",
+          message: "Failed to parse vercel.toml. Ensure it contains valid TOML."
+        }
+      };
+    }
+  }
+  return { config: null, error: null };
+}
+function assignMountPaths(services) {
+  const warnings = [];
+  const names = Object.keys(services);
+  if (names.length === 1) {
+    services[names[0]].mountPath = "/";
+    return warnings;
+  }
+  const frontendNames = names.filter(
+    (name) => (0, import_framework.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 mount path "/". Adjust manually if a different service should be the root.`
+    });
+  }
+  const rootFramework = rootName ? services[rootName].framework : void 0;
+  const isBFF = rootFramework ? (0, import_framework.isBFFFramework)(rootFramework) : false;
+  const nonRootNames = names.filter((n) => n !== rootName);
+  const needsNamespace = isBFF || nonRootNames.length > 1;
+  for (const name of names) {
+    if (name === rootName) {
+      services[name].mountPath = "/";
+    } else {
+      services[name].mountPath = needsNamespace ? `/api/${name}` : "/api";
+    }
+  }
+  return warnings;
+}
+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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTERNAL_QUEUES_PREFIX,
+  INTERNAL_SERVICE_PREFIX,
+  assignMountPaths,
+  combineBuildCommand,
+  getInternalServiceCronPath,
+  getInternalServiceCronPathPrefix,
+  getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix,
+  hasFile,
+  isRouteOwningBuilder,
+  isStaticBuild,
+  readVercelConfig
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "7.1.7",
+  "version": "7.2.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,11 +19,12 @@
     "json5": "2.2.2",
     "minimatch": "3.1.2",
     "semver": "6.3.1",
+    "smol-toml": "1.5.2",
+    "@vercel/build-utils": "14.9.0",
     "@vercel/error-utils": "2.2.1",
     "@vercel/frameworks": "3.34.0",
     "@vercel/python-analysis": "0.14.0",
-    "@vercel/routing-utils": "6.5.0",
-    "@vercel/build-utils": "14.9.0"
+    "@vercel/routing-utils": "6.5.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",