@vercel/fs-detectors 7.1.7 → 7.2.0

package/dist/services/resolve-v2.js

@@ -0,0 +1,383 @@
+"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 resolve_v2_exports = {};
+__export(resolve_v2_exports, {
+  resolveAllConfiguredServicesV2: () => resolveAllConfiguredServicesV2,
+  resolveConfiguredServiceV2: () => resolveConfiguredServiceV2,
+  validateServiceConfigV2: () => validateServiceConfigV2
+});
+module.exports = __toCommonJS(resolve_v2_exports);
+var import_path = require("path");
+var import_build_utils = require("@vercel/build-utils");
+var import_frameworks = require("@vercel/frameworks");
+var import_constants = require("./runtimes/constants");
+var import_framework = require("./runtimes/framework");
+var import_runtime = require("./runtimes/runtime");
+var import_entrypoint = require("./runtimes/entrypoint");
+var import_resolve = require("./resolve");
+const frameworksBySlug = new Map(import_frameworks.frameworkList.map((f) => [f.slug, f]));
+const MAX_SERVICE_NAME_LENGTH = 64;
+const SERVICE_NAME_REGEX = /^[a-z]([a-z_-]*[a-z])?$/;
+function isValidServiceName(name) {
+  return name.length <= MAX_SERVICE_NAME_LENGTH && SERVICE_NAME_REGEX.test(name);
+}
+function getInvalidServiceNameMessage(name) {
+  return `Service name "${name}" is invalid. Names must be 1-${MAX_SERVICE_NAME_LENGTH} characters, start and end with a lowercase letter, and contain only lowercase letters, hyphens, and underscores.`;
+}
+async function detectContainerEntrypoint(serviceFs) {
+  for (const candidate of import_constants.CONTAINER_ENTRYPOINT_CANDIDATES) {
+    if (await serviceFs.hasPath(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function normalizeContainerCommand(command) {
+  if (command === void 0) {
+    return void 0;
+  }
+  return Array.isArray(command) ? command : [command];
+}
+async function resolveContainerServiceV2(name, config, normalizedRoot, serviceFs) {
+  const isRoot = normalizedRoot === ".";
+  const entrypoint = config.entrypoint;
+  let dockerfile;
+  if (typeof entrypoint === "string") {
+    if (!(0, import_entrypoint.isDockerfileEntrypoint)(entrypoint)) {
+      return {
+        error: {
+          code: "INVALID_SERVICE_CONFIG",
+          message: `Container service "${name}" has invalid "entrypoint" "${entrypoint}". It must name a Dockerfile or Containerfile.`,
+          serviceName: name
+        }
+      };
+    }
+    dockerfile = import_path.posix.normalize(entrypoint);
+  } else {
+    dockerfile = await detectContainerEntrypoint(serviceFs);
+    if (!dockerfile) {
+      return {
+        error: {
+          code: "MISSING_SERVICE_CONFIG",
+          message: `Container service "${name}" has no "entrypoint" and no ${import_constants.CONTAINER_ENTRYPOINT_CANDIDATES.join(
+            ", "
+          )} was found in "${normalizedRoot}".`,
+          serviceName: name
+        }
+      };
+    }
+  }
+  const builderSrc = isRoot ? dockerfile : import_path.posix.join(normalizedRoot, dockerfile);
+  const builderConfig = { zeroConfig: true };
+  if (!isRoot) {
+    builderConfig.workspace = normalizedRoot;
+  }
+  const command = normalizeContainerCommand(config.command);
+  if (command) {
+    builderConfig.command = command;
+  }
+  return {
+    service: {
+      schema: "experimentalServicesV2",
+      name,
+      root: normalizedRoot,
+      runtime: "container",
+      entrypoint: 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 (!isValidServiceName(name)) {
+    return {
+      code: "INVALID_SERVICE_NAME",
+      message: getInvalidServiceNameMessage(name),
+      serviceName: name
+    };
+  }
+  if (!config || typeof config !== "object") {
+    return {
+      code: "INVALID_SERVICE_CONFIG",
+      message: `Service "${name}" has an invalid configuration. Expected an object.`,
+      serviceName: name
+    };
+  }
+  if (typeof config.root !== "string" || config.root.length === 0) {
+    return {
+      code: "MISSING_ROOT",
+      message: `Service "${name}" must specify a "root".`,
+      serviceName: name
+    };
+  }
+  const normalizedRoot = import_path.posix.normalize(config.root);
+  if (normalizedRoot.startsWith("/")) {
+    return {
+      code: "INVALID_ROOT",
+      message: `Service "${name}" has invalid "root" "${config.root}". Must be a relative path.`,
+      serviceName: name
+    };
+  }
+  if (normalizedRoot === ".." || normalizedRoot.startsWith("../")) {
+    return {
+      code: "INVALID_ROOT",
+      message: `Service "${name}" has invalid "root" "${config.root}". Must not escape the project root.`,
+      serviceName: name
+    };
+  }
+  if (config.runtime && !(config.runtime in import_constants.RUNTIME_BUILDERS)) {
+    return {
+      code: "INVALID_RUNTIME",
+      message: `Service "${name}" has invalid runtime "${config.runtime}".`,
+      serviceName: name
+    };
+  }
+  if (config.framework && !frameworksBySlug.has(config.framework)) {
+    return {
+      code: "INVALID_FRAMEWORK",
+      message: `Service "${name}" has invalid framework "${config.framework}".`,
+      serviceName: name
+    };
+  }
+  if (config.runtime && config.framework) {
+    const frameworkRuntime = (0, import_framework.inferRuntimeFromFramework)(config.framework);
+    if (frameworkRuntime && frameworkRuntime !== config.runtime) {
+      return {
+        code: "RUNTIME_FRAMEWORK_MISMATCH",
+        message: `Service "${name}" has conflicting runtime/framework: runtime "${config.runtime}" is incompatible with framework "${config.framework}" (runtime "${frameworkRuntime}").`,
+        serviceName: name
+      };
+    }
+  }
+  return null;
+}
+async function resolveConfiguredServiceV2(name, config, fs) {
+  const normalizedRoot = (0, import_entrypoint.stripTrailingSlash)(import_path.posix.normalize(config.root));
+  const serviceFsResult = normalizedRoot === "." ? { fs } : await (0, import_resolve.getServiceFs)(fs, name, normalizedRoot);
+  if (serviceFsResult.error) {
+    return { error: serviceFsResult.error };
+  }
+  const serviceFs = serviceFsResult.fs;
+  const isContainer = config.runtime === "container" || typeof config.entrypoint === "string" && (0, import_entrypoint.isDockerfileEntrypoint)(config.entrypoint);
+  if (isContainer) {
+    return resolveContainerServiceV2(name, config, normalizedRoot, serviceFs);
+  }
+  const rawEntrypoint = config.entrypoint;
+  const moduleAttr = typeof rawEntrypoint === "string" ? (0, import_entrypoint.parsePyModuleAttrEntrypoint)(rawEntrypoint) : null;
+  let normalizedEntrypoint;
+  let entrypointIsDirectory = false;
+  if (typeof rawEntrypoint === "string") {
+    const entrypointToResolve = moduleAttr ? moduleAttr.filePath : rawEntrypoint;
+    const resolved = await (0, import_resolve.resolveEntrypointPath)({
+      fs: serviceFs,
+      serviceName: name,
+      entrypoint: entrypointToResolve
+    });
+    if (resolved.error) {
+      return { error: resolved.error };
+    }
+    normalizedEntrypoint = resolved.entrypoint?.normalized;
+    entrypointIsDirectory = Boolean(resolved.entrypoint?.isDirectory);
+  }
+  const entrypointFile = entrypointIsDirectory || !normalizedEntrypoint ? void 0 : normalizedEntrypoint;
+  let inferredRuntime = (0, import_runtime.inferRuntime)({
+    runtime: config.runtime,
+    framework: config.framework,
+    entrypoint: entrypointFile
+  });
+  let framework = config.framework;
+  let detectedFramework = false;
+  if (!framework) {
+    const workspace = entrypointIsDirectory && normalizedEntrypoint ? normalizedEntrypoint : ".";
+    const detection = await (0, import_resolve.detectFrameworkFromWorkspace)({
+      fs: serviceFs,
+      workspace,
+      serviceName: name,
+      runtime: inferredRuntime
+    });
+    if (detection.error) {
+      return { error: detection.error };
+    }
+    framework = detection.framework;
+    detectedFramework = Boolean(framework);
+    inferredRuntime = (0, import_runtime.inferRuntime)({
+      runtime: config.runtime,
+      framework,
+      entrypoint: entrypointFile
+    });
+  }
+  if (entrypointIsDirectory && !framework) {
+    return {
+      error: {
+        code: "MISSING_SERVICE_FRAMEWORK",
+        message: `Service "${name}" uses directory entrypoint "${config.entrypoint}" but no framework could be detected. Specify "framework" explicitly or use a file entrypoint.`,
+        serviceName: name
+      }
+    };
+  }
+  const frameworkRuntime = (0, import_framework.inferRuntimeFromFramework)(framework);
+  if (detectedFramework && frameworkRuntime && !entrypointFile) {
+    return {
+      error: {
+        code: "MISSING_SERVICE_CONFIG",
+        message: `Service "${name}" detected framework "${framework}" in "${normalizedRoot}" and must specify an "entrypoint" for runtime "${frameworkRuntime}".`,
+        serviceName: name
+      }
+    };
+  }
+  const frameworkDefinition = framework ? frameworksBySlug.get(framework) : void 0;
+  let builderUse;
+  let builderSrc;
+  if (framework) {
+    builderUse = (0, import_build_utils.isNodeBackendFramework)(framework) ? "@vercel/backends" : frameworkDefinition?.useRuntime?.use || "@vercel/static-build";
+    builderSrc = entrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
+  } else {
+    if (!inferredRuntime) {
+      if (config.buildCommand) {
+        builderUse = "@vercel/static-build";
+        builderSrc = "package.json";
+      } else {
+        builderUse = "@vercel/static";
+        builderSrc = config.outputDirectory ? import_path.posix.join(config.outputDirectory, "**") : "**";
+      }
+    } else {
+      if (!entrypointFile) {
+        return {
+          error: {
+            code: "MISSING_SERVICE_CONFIG",
+            message: `Service "${name}" must specify an "entrypoint" for runtime "${inferredRuntime}".`,
+            serviceName: name
+          }
+        };
+      }
+      builderUse = inferredRuntime === "node" ? "@vercel/backends" : (0, import_runtime.getBuilderForRuntime)(inferredRuntime);
+      builderSrc = entrypointFile;
+    }
+  }
+  const isRoot = normalizedRoot === ".";
+  const projectRelativeSrc = isRoot ? builderSrc : import_path.posix.join(normalizedRoot, builderSrc);
+  const builderConfig = { zeroConfig: true };
+  if (builderUse === "@vercel/backends") {
+    builderConfig.serviceName = name;
+  }
+  if (framework) {
+    builderConfig.framework = framework;
+  }
+  if (config.outputDirectory) {
+    builderConfig.outputDirectory = config.outputDirectory;
+  }
+  if (!isRoot) {
+    builderConfig.workspace = normalizedRoot;
+  }
+  if (moduleAttr) {
+    builderConfig.handlerFunction = moduleAttr.attrName;
+  }
+  const runtime = import_constants.STATIC_BUILDERS.has(builderUse) ? void 0 : inferredRuntime;
+  return {
+    service: {
+      schema: "experimentalServicesV2",
+      name,
+      root: normalizedRoot,
+      framework,
+      runtime,
+      entrypoint: entrypointFile,
+      builder: {
+        src: projectRelativeSrc,
+        use: builderUse,
+        config: builderConfig
+      },
+      installCommand: config.installCommand,
+      buildCommand: config.buildCommand,
+      devCommand: config.devCommand,
+      ignoreCommand: config.ignoreCommand,
+      outputDirectory: config.outputDirectory,
+      bindings: config.bindings,
+      functions: config.functions,
+      headers: config.headers,
+      redirects: config.redirects,
+      rewrites: config.rewrites,
+      routes: config.routes,
+      cleanUrls: config.cleanUrls,
+      trailingSlash: config.trailingSlash
+    }
+  };
+}
+async function resolveAllConfiguredServicesV2(services, fs) {
+  const resolved = [];
+  const errors = [];
+  for (const name of Object.keys(services)) {
+    const config = services[name];
+    const validationError = validateServiceConfigV2(name, config);
+    if (validationError) {
+      errors.push(validationError);
+      continue;
+    }
+    const { service, error } = await resolveConfiguredServiceV2(
+      name,
+      config,
+      fs
+    );
+    if (error) {
+      errors.push(error);
+      continue;
+    }
+    if (service) {
+      resolved.push(service);
+    }
+  }
+  const serviceNames = new Set(Object.keys(services));
+  for (const service of resolved) {
+    for (const binding of service.bindings ?? []) {
+      if (!isValidServiceName(binding.service)) {
+        errors.push({
+          code: "INVALID_SERVICE_BINDING_NAME",
+          message: `Service "${service.name}" declares an invalid binding service name "${binding.service}". ${getInvalidServiceNameMessage(binding.service)}`,
+          serviceName: service.name
+        });
+        continue;
+      }
+      if (!serviceNames.has(binding.service)) {
+        errors.push({
+          code: "UNKNOWN_SERVICE_BINDING",
+          message: `Service "${service.name}" declares a binding to unknown service "${binding.service}".`,
+          serviceName: service.name
+        });
+      }
+    }
+  }
+  return { services: resolved, errors };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAllConfiguredServicesV2,
+  resolveConfiguredServiceV2,
+  validateServiceConfigV2
+});

package/dist/services/resolve.d.ts

@@ -0,0 +1,65 @@
+import type { ExperimentalService, ConfiguredServices, ExperimentalServiceConfig, ServiceDetectionError, ServiceRuntime } from './types';
+import type { DetectorFilesystem } from '../detectors/filesystem';
+type ConfiguredServiceConfig = ExperimentalServiceConfig;
+interface ResolvedEntrypointPath {
+    normalized: string;
+    isDirectory: boolean;
+}
+export declare function getServiceFs(fs: DetectorFilesystem, serviceName: string, root?: string): Promise<{
+    fs: DetectorFilesystem;
+    error?: ServiceDetectionError;
+}>;
+export declare function resolveEntrypointPath({ fs, serviceName, entrypoint, }: {
+    fs: DetectorFilesystem;
+    serviceName: string;
+    entrypoint: string;
+}): Promise<{
+    entrypoint?: ResolvedEntrypointPath;
+    error?: ServiceDetectionError;
+}>;
+type RoutePrefixSource = 'configured' | 'generated';
+interface ResolveConfiguredServiceOptions {
+    name: string;
+    config: ConfiguredServiceConfig;
+    /** Filesystem scoped to the service root (via chdir) when root is set, otherwise the project-level fs. */
+    serviceFs: DetectorFilesystem;
+    root?: string;
+    group?: string;
+    resolvedEntrypoint?: ResolvedEntrypointPath;
+    routePrefixSource?: RoutePrefixSource;
+}
+interface ResolveAllConfiguredServicesOptions {
+    requireFileEntrypointForBackendRuntimes?: boolean;
+}
+export declare function inferWorkspaceFromNearestManifest({ fs, entrypoint, runtime, }: {
+    fs: DetectorFilesystem;
+    entrypoint?: string;
+    runtime?: ServiceRuntime;
+}): Promise<string | undefined>;
+export declare function detectFrameworkFromWorkspace({ fs, workspace, serviceName, runtime, }: {
+    fs: DetectorFilesystem;
+    workspace: string;
+    serviceName: string;
+    runtime?: ServiceRuntime;
+}): Promise<{
+    framework?: string;
+    error?: ServiceDetectionError;
+}>;
+/**
+ * Validate a service configuration from vercel.json services.
+ */
+export declare function validateServiceConfig(name: string, config: ConfiguredServiceConfig, options?: ResolveAllConfiguredServicesOptions): ServiceDetectionError | null;
+export declare function validateServiceEntrypoint(name: string, config: ConfiguredServiceConfig, resolvedEntrypoint: ResolvedEntrypointPath): ServiceDetectionError | null;
+/**
+ * Resolve a single service from user configuration.
+ */
+export declare function resolveConfiguredService(options: ResolveConfiguredServiceOptions): Promise<ExperimentalService>;
+/**
+ * Resolve all services from vercel.json services.
+ * Validates each service configuration.
+ */
+export declare function resolveAllConfiguredServices(services: ConfiguredServices, fs: DetectorFilesystem, routePrefixSource?: RoutePrefixSource, options?: ResolveAllConfiguredServicesOptions): Promise<{
+    services: ExperimentalService[];
+    errors: ServiceDetectionError[];
+}>;
+export {};