@vercel/ruby 2.3.1 → 2.3.2

package/dist/index.js

@@ -7232,10 +7232,14 @@ function createDevRubyShim(workPath, entrypoint) {
     const vercelRubyDir = (0, import_path2.join)(workPath, ".vercel", "ruby");
     (0, import_fs.mkdirSync)(vercelRubyDir, { recursive: true });
     const shimPath = (0, import_path2.join)(vercelRubyDir, `vc_init_dev.rb`);
+    const utilsPath = (0, import_path2.join)(vercelRubyDir, "vc__utils__ruby.rb");
     const templatePath = (0, import_path2.join)(__dirname, "..", "vc_init_dev.rb");
+    const utilsTemplatePath = (0, import_path2.join)(__dirname, "..", "vc_utils.rb");
     const template = (0, import_fs.readFileSync)(templatePath, "utf8");
+    const utilsTemplate = (0, import_fs.readFileSync)(utilsTemplatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_ENTRYPOINT__/g, entrypoint);
     (0, import_fs.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_fs.writeFileSync)(utilsPath, utilsTemplate, "utf8");
     (0, import_build_utils2.debug)(`Prepared Ruby dev shim at ${shimPath}`);
     return shimPath;
   } catch (err) {
@@ -7616,6 +7620,8 @@ var build = async ({
   }
   const originalRbPath = (0, import_path3.join)(__dirname, "..", "vc_init.rb");
   const originalHandlerRbContents = await (0, import_fs_extra.readFile)(originalRbPath, "utf8");
+  const originalUtilsRbPath = (0, import_path3.join)(__dirname, "..", "vc_utils.rb");
+  const originalUtilsRbContents = await (0, import_fs_extra.readFile)(originalUtilsRbPath, "utf8");
   (0, import_build_utils3.debug)("entrypoint is", entrypoint);
   const userHandlerFilePath = entrypoint.replace(/\.rb$/, "");
   const nowHandlerRbContents = originalHandlerRbContents.replace(
@@ -7623,6 +7629,7 @@ var build = async ({
     userHandlerFilePath
   );
   const handlerRbFilename = "vc__handler__ruby";
+  const utilsRbFilename = "vc__utils__ruby.rb";
   const predefinedExcludes = [
     ".git/**",
     ".gitignore",
@@ -7640,6 +7647,9 @@ var build = async ({
   outputFiles[`${handlerRbFilename}.rb`] = new import_build_utils3.FileBlob({
     data: nowHandlerRbContents
   });
+  outputFiles[utilsRbFilename] = new import_build_utils3.FileBlob({
+    data: originalUtilsRbContents
+  });
   if (config && (config.includeFiles || config.excludeFiles)) {
     const includedPaths = await matchPaths(config.includeFiles, workPath);
     const excludedPaths = await matchPaths(
@@ -7650,7 +7660,7 @@ var build = async ({
       if (includedPaths.includes(excludedPaths[i])) {
         continue;
       }
-      if (excludedPaths[i] === `${handlerRbFilename}.rb`) {
+      if (excludedPaths[i] === `${handlerRbFilename}.rb` || excludedPaths[i] === utilsRbFilename) {
         continue;
       }
       if (excludedPaths[i].startsWith(vendorPath)) {

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@vercel/ruby",
   "author": "Nathan Cahill <nathan@nathancahill.com>",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/ruby",
   "files": [
     "dist",
     "vc_init.rb",
-    "vc_init_dev.rb"
+    "vc_init_dev.rb",
+    "vc_utils.rb"
   ],
   "repository": {
     "type": "git",
@@ -24,7 +25,7 @@
     "jest-junit": "16.0.0",
     "semver": "6.3.1",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.4.0"
+    "@vercel/build-utils": "13.5.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/vc_init.rb

@@ -3,6 +3,7 @@ require 'webrick'
 require 'net/http'
 require 'base64'
 require 'json'
+require_relative 'vc__utils__ruby'
 
 $entrypoint = '__VC_HANDLER_FILENAME'
 
@@ -10,13 +11,17 @@ ENV['RAILS_ENV'] ||= 'production'
 ENV['RACK_ENV'] ||= 'production'
 ENV['RAILS_LOG_TO_STDOUT'] ||= '1'
 
-def rack_handler(httpMethod, path, body, headers)
+
+$service_route_prefix = resolve_service_route_prefix
+
+def rack_handler(httpMethod, path, body, headers, script_name = '')
   require 'rack'
 
   app, _ = Rack::Builder.parse_file($entrypoint)
   server = Rack::MockRequest.new app
 
   env = headers.transform_keys { |k| k.split('-').join('_').prepend('HTTP_').upcase }
+  env['SCRIPT_NAME'] = script_name unless script_name.empty?
   res = server.request(httpMethod, path, env.merge({ :input => body }))
 
   {
@@ -96,8 +101,13 @@ def vc__handler(event:, context:)
     body = Base64.decode64(body)
   end
 
+  path, script_name = apply_service_route_prefix_to_target(
+    path,
+    $service_route_prefix
+  )
+
   if $entrypoint.end_with? '.ru'
-    return rack_handler(httpMethod, path, body, headers)
+    return rack_handler(httpMethod, path, body, headers, script_name)
   end
 
   return webrick_handler(httpMethod, path, body, headers)

package/vc_init_dev.rb

@@ -10,12 +10,14 @@ require 'rack'
 require 'rack/handler/webrick'
 require 'webrick'
 require 'socket'
+require_relative 'vc__utils__ruby'
 
 $stdout.sync = true
 $stderr.sync = true
 
 USER_ENTRYPOINT = "__VC_DEV_ENTRYPOINT__"
 PUBLIC_DIR = 'public'
+SERVICE_ROUTE_PREFIX = resolve_service_route_prefix
 
 def build_user_app
   if USER_ENTRYPOINT.end_with?('.ru')
@@ -36,17 +38,33 @@ class StaticThenApp
   end
 
   def call(env)
-    req_path = env['PATH_INFO'] || '/'
+    effective_env = env.dup
+    req_path, matched_prefix = strip_service_route_prefix(
+      effective_env['PATH_INFO'] || '/',
+      SERVICE_ROUTE_PREFIX
+    )
+    effective_env['PATH_INFO'] = req_path
+
+    unless matched_prefix.empty?
+      script_name = effective_env['SCRIPT_NAME'] || ''
+      if !script_name.empty? && script_name != '/'
+        script_name = script_name.sub(%r{/+\z}, '')
+      else
+        script_name = ''
+      end
+      effective_env['SCRIPT_NAME'] = "#{script_name}#{matched_prefix}"
+    end
+
     # Normalize path and guard against traversal
     safe = req_path.sub(/^\//, '')
     full = File.expand_path(safe, @base)
 
     if full.start_with?(@base + File::SEPARATOR) && File.file?(full)
       # Delegate to Rack::File which handles HEAD/GET correctly
-      return @file_server.call(env)
+      return @file_server.call(effective_env)
     end
 
-    @app.call(env)
+    @app.call(effective_env)
   end
 end
 

package/vc_utils.rb

@@ -0,0 +1,101 @@
+require 'uri'
+
+# Normalize a configured service prefix into canonical mount-path form.
+#
+# Returns an empty string when unset/blank/root ("/"), otherwise:
+# - always starts with "/"
+# - has no trailing slash
+def normalize_service_route_prefix(raw_prefix)
+  return '' if raw_prefix.nil?
+
+  prefix = raw_prefix.strip
+  return '' if prefix.empty?
+
+  prefix = "/#{prefix}" unless prefix.start_with?('/')
+
+  if prefix != '/'
+    prefix = prefix.sub(%r{/+\z}, '')
+    prefix = '/' if prefix.empty?
+  end
+
+  prefix == '/' ? '' : prefix
+end
+
+# Return whether service-prefix stripping is explicitly enabled.
+#
+# Stripping is gated behind a dedicated env var so manually configured
+# route prefixes can be preserved by default.
+def service_route_prefix_strip_enabled?
+  raw = ENV['VERCEL_SERVICE_ROUTE_PREFIX_STRIP']
+  return false if raw.nil? || raw.empty?
+
+  %w[1 true].include?(raw.downcase)
+end
+
+def resolve_service_route_prefix
+  return '' unless service_route_prefix_strip_enabled?
+
+  normalize_service_route_prefix(ENV['VERCEL_SERVICE_ROUTE_PREFIX'])
+end
+
+# Split an HTTP request-target into [path, query].
+#
+# Supports:
+# - origin-form: "/a/b?x=1"
+# - absolute-form: "https://example.com/a/b?x=1"
+# - asterisk-form: "*"
+def split_request_target(target)
+  return ['/', ''] if target.nil? || target.empty?
+
+  begin
+    parsed = URI.parse(target)
+    if parsed.scheme && parsed.host
+      path = parsed.path.nil? || parsed.path.empty? ? '/' : parsed.path
+      return [path, parsed.query.to_s]
+    end
+  rescue URI::InvalidURIError
+  end
+
+  return ['*', ''] if target == '*'
+
+  path, query = target.split('?', 2)
+  path = '/' if path.nil? || path.empty?
+  path = "/#{path}" unless path.start_with?('/')
+  [path, query.to_s]
+end
+
+# Strip the configured service route prefix from a request path.
+#
+# Returns:
+# - stripped path passed to the user app
+# - matched mount prefix (empty when no prefix matched)
+def strip_service_route_prefix(path, prefix)
+  return [path, ''] if path == '*'
+
+  normalized_path = path.nil? || path.empty? ? '/' : path
+  normalized_path = "/#{normalized_path}" unless normalized_path.start_with?('/')
+
+  normalized_prefix = prefix.to_s
+  return [normalized_path, ''] if normalized_prefix.empty?
+
+  return ['/', normalized_prefix] if normalized_path == normalized_prefix
+
+  if normalized_path.start_with?("#{normalized_prefix}/")
+    stripped = normalized_path[normalized_prefix.length..]
+    return [stripped.nil? || stripped.empty? ? '/' : stripped, normalized_prefix]
+  end
+
+  [normalized_path, '']
+end
+
+# Apply service-prefix stripping to a full request-target.
+#
+# Returns:
+# - updated request-target (path + optional query)
+# - matched mount prefix for Rack SCRIPT_NAME (or "")
+def apply_service_route_prefix_to_target(target, prefix)
+  path, query = split_request_target(target)
+  path, script_name = strip_service_route_prefix(path, prefix)
+  updated = query.empty? ? path : "#{path}?#{query}"
+  [updated, script_name]
+end