one/dist/cjs/vercel/build/generate/createSsrServerlessFunction.cjs

One is a new React Framework that makes Vite serve both native and web.

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 createSsrServerlessFunction_exports = {};
__export(createSsrServerlessFunction_exports, {
  createSsrServerlessFunction: () => createSsrServerlessFunction
});
module.exports = __toCommonJS(createSsrServerlessFunction_exports);
var import_node_path = require("node:path");
var import_fs_extra = __toESM(require("fs-extra"), 1);
var import_vc_config_base = require("../config/vc-config-base.cjs");
var import_vc_package_base = require("../config/vc-package-base.cjs");
var import_getPathFromRoute = require("../getPathFromRoute.cjs");
async function createSsrServerlessFunction(route, buildInfo, oneOptionsRoot, postBuildLogs) {
  try {
    const path = (0, import_getPathFromRoute.getPathFromRoute)(route, {
      includeIndex: true
    });
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] path: ${path}`);
    const buildInfoAsString = JSON.stringify(buildInfo);
    const funcFolder = (0, import_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, `.vercel/output/functions/${path}.func`));
    await import_fs_extra.default.ensureDir(funcFolder);
    const outDir = buildInfo.outDir || "dist";
    const distServerFrom = (0, import_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, outDir, "server"));
    const distServerTo = (0, import_node_path.resolve)((0, import_node_path.join)(funcFolder, "server"));
    await import_fs_extra.default.ensureDir(distServerTo);
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] copy server dist files from ${distServerFrom} to ${distServerTo}`);
    await import_fs_extra.default.copy(distServerFrom, distServerTo);
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] writing buildInfo.json`);
    await import_fs_extra.default.writeFile((0, import_node_path.join)(funcFolder, "buildInfo.js"), `export default ${buildInfoAsString}`);
    await import_fs_extra.default.ensureDir((0, import_node_path.join)(funcFolder, "entrypoint"));
    const entrypointFilePath = (0, import_node_path.resolve)((0, import_node_path.join)(funcFolder, "entrypoint", "index.js"));
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] writing entrypoint to ${entrypointFilePath}`);
    await import_fs_extra.default.writeFile(entrypointFilePath, `
  const buildInfoConfig = await import('../buildInfo.js');
  const entry = await import('../server/_virtual_one-entry.js');
  const routeFile = ${JSON.stringify(route.file)}

  const handler = async (req, res) => {
    // console.debug("req.url", req.url);
    const url = new URL(req.url, \`https://\${process.env.VERCEL_URL}\`);

    // Check if this is a loader request (routed here by config.json rewrite)
    const isLoaderRequest = url.searchParams.get('__loader') === '1';

    // Extract route params - from URL path match OR from query params (for loader requests)
    const routePattern = ${JSON.stringify(route.page)};
    const paramNames = [];
    const regexPattern = routePattern
      .replace(/\\[\\.\\.\\.(\\w+)\\]/g, (_, name) => { paramNames.push({ name, catch: true }); return '(.+)'; })
      .replace(/\\[(\\w+)\\]/g, (_, name) => { paramNames.push({ name, catch: false }); return '([^/]+)'; });

    const routeParams = {};

    // First try to get params from query string (set by Vercel rewrite rules)
    // This handles both loader requests and regular page requests that went through rewrites
    for (const param of paramNames) {
      const value = url.searchParams.get(param.name);
      if (value) {
        routeParams[param.name] = param.catch ? value.split('/') : value;
      }
    }

    // If no params found in query string, try extracting from URL path
    if (Object.keys(routeParams).length === 0) {
      const match = url.pathname.match(new RegExp(\`^\${regexPattern}$\`));
      if (match) {
        paramNames.forEach((param, index) => {
          const value = match[index + 1];
          routeParams[param.name] = param.catch ? value.split('/') : value;
        });
      }
    }

    // Create a proper Request object for SSR loaders
    const request = new Request(url.toString(), {
      method: req.method || 'GET',
      headers: new Headers(req.headers || {}),
    });

    // Reconstruct the original path by replacing :param placeholders with actual values
    // The pathname might be the rewritten path (e.g., /dynamic/:id instead of /dynamic/123)
    let originalPath = url.pathname;
    for (const [key, value] of Object.entries(routeParams)) {
      originalPath = originalPath.replace(\`:\${key}\`, String(value));
    }

    const host = url.hostname;
    let subdomain;
    if (host && host !== 'localhost' && !/^\\d+\\.\\d+\\.\\d+\\.\\d+$/.test(host)) {
      const parts = host.split('.');
      if (parts.length >= 3) subdomain = parts.slice(0, -2).join('.');
    }

    const loaderProps = {
      path: originalPath,
      params: routeParams,
      subdomain,
      request,
    }

    const postfix = url.pathname.endsWith('/') ? 'index.tsx' : '+ssr.tsx';
    // const routeFile = \`.\${url.pathname}\${postfix}\`;
    let route = buildInfoConfig.default.routeToBuildInfo[routeFile];

    // If we cannot find the route by direct match, try to find it by looking it up in the
    // pathToRoute mapping. Currently this handles cases such as "(some-group)/index.tsx",
    // "index.web.tsx".
    if (!route) {
      const routeName = buildInfoConfig.default.pathToRoute[url.pathname];
      route = buildInfoConfig.default.routeToBuildInfo[routeName];
    }

    const exported = await import(route.serverJsPath.replace('${outDir}/','../'))
    const loaderData = await exported.loader?.(loaderProps)

    // For loader requests, return the loader data as a JavaScript module
    if (isLoaderRequest) {
      res.setHeader('Content-Type', 'application/javascript; charset=utf-8')
      res.setHeader('Cache-Control', 'no-store')
      res.end(\`export function loader() { return \${JSON.stringify(loaderData)} }\`)
      return
    }

    // For page requests, render the full HTML
    const render = entry.default.render;
    const preloads = route.preloads
    const css = route.css || []
    const rendered = await render({
      mode: route.type,
      loaderData,
      loaderProps,
      path: loaderProps?.path || '/',
      preloads,
      css,
    })
    res.setHeader('Content-Type', 'text/html; charset=utf-8')
    // https://vercel.com/docs/deployments/skew-protection#supported-frameworks__
    if (process.env.VERCEL_SKEW_PROTECTION_ENABLED === '1') {
      res.setHeader('Set-Cookie', [
        \`__vdpl=\${process.env.VERCEL_DEPLOYMENT_ID}; HttpOnly\`,
      ]);
    }
    res.end(rendered)
  }

  export default handler;
  `);
    const packageJsonFilePath = (0, import_node_path.resolve)((0, import_node_path.join)(funcFolder, "package.json"));
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] writing package.json to ${packageJsonFilePath}`);
    await import_fs_extra.default.writeJSON(packageJsonFilePath, import_vc_package_base.serverlessVercelPackageJson);
    const vcConfigFilePath = (0, import_node_path.resolve)((0, import_node_path.join)(funcFolder, ".vc-config.json"));
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] writing .vc-config.json to ${vcConfigFilePath}`);
    return import_fs_extra.default.writeJson(vcConfigFilePath, {
      ...import_vc_config_base.serverlessVercelNodeJsConfig,
      handler: "entrypoint/index.js",
      environment: {
        ...import_vc_config_base.serverlessVercelNodeJsConfig.environment,
        ONE_DEFAULT_RENDER_MODE: "ssr"
      }
    });
  } catch (e) {
    console.error(`[one.build][vercel.createSsrServerlessFunction] failed to generate func for ${route.file}`, e);
  }
}