one/dist/cjs/vercel/build/generate/createApiServerlessFunction.native.js

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

"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 createApiServerlessFunction_exports = {};
__export(createApiServerlessFunction_exports, {
  createApiServerlessFunction: () => createApiServerlessFunction
});
module.exports = __toCommonJS(createApiServerlessFunction_exports);
var import_path = require("path");
var import_generator = __toESM(require("@babel/generator"), 1);
var import_parser = __toESM(require("@babel/parser"), 1);
var import_traverse = __toESM(require("@babel/traverse"), 1);
var import_types = __toESM(require("@babel/types"), 1);
var import_resolve = require("@vxrn/resolve");
var import_fs_extra = __toESM(require("fs-extra"), 1);
var import_fs_extra2 = __toESM(require("fs-extra"), 1);
var import_vc_config_base = require("../config/vc-config-base.native.js");
var import_vc_package_base = require("../config/vc-package-base.native.js");
var import_getPathFromRoute = require("../getPathFromRoute.native.js");
async function createApiServerlessFunction(route, code, oneOptionsRoot, postBuildLogs) {
  var outDir = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : "dist";
  try {
    var path = (0, import_getPathFromRoute.getPathFromRoute)(route, {
      includeIndex: true
    });
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] pageName: ${path}`);
    var funcFolder = (0, import_path.join)(oneOptionsRoot, `.vercel/output/functions/${path}.func`);
    await import_fs_extra2.default.ensureDir(funcFolder);
    if (code.includes("react")) {
      postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] detected react in depenency tree for ${path}`);
      var reactPath = (0, import_path.dirname)((0, import_resolve.resolvePath)("react/package.json", oneOptionsRoot));
      await import_fs_extra2.default.copy((0, import_path.resolve)(reactPath), (0, import_path.resolve)((0, import_path.join)(funcFolder, "node_modules", "react")));
    }
    var distAssetsFolder = (0, import_path.resolve)((0, import_path.join)(funcFolder, "assets"));
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] copy shared assets to ${distAssetsFolder}`);
    var sourceAssetsFolder = (0, import_path.resolve)((0, import_path.join)(oneOptionsRoot, outDir, "api", "assets"));
    if (await import_fs_extra.default.pathExists(sourceAssetsFolder)) {
      await import_fs_extra2.default.copy(sourceAssetsFolder, distAssetsFolder);
    }
    await import_fs_extra2.default.ensureDir((0, import_path.resolve)((0, import_path.join)(funcFolder, "entrypoint")));
    var entrypointFilePath = (0, import_path.resolve)((0, import_path.join)(funcFolder, "entrypoint", "index.js"));
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] writing entrypoint to ${entrypointFilePath}`);
    await import_fs_extra2.default.writeFile(entrypointFilePath, wrapHandlerFunctions(code));
    var packageJsonFilePath = (0, import_path.resolve)((0, import_path.join)(funcFolder, "package.json"));
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] writing package.json to ${packageJsonFilePath}`);
    await import_fs_extra2.default.writeJSON(packageJsonFilePath, import_vc_package_base.serverlessVercelPackageJson);
    postBuildLogs.push(`[one.build][vercel.createSsrServerlessFunction] writing .vc-config.json to ${(0, import_path.join)(funcFolder, ".vc-config.json")}`);
    return import_fs_extra2.default.writeJson((0, import_path.join)(funcFolder, ".vc-config.json"), {
      ...import_vc_config_base.serverlessVercelNodeJsConfig,
      handler: "entrypoint/index.js"
    });
  } catch (e) {
    console.error(`[one.build][vercel.createSsrServerlessFunction] failed to generate func for ${route.file}`, e);
  }
}
function wrapHandlerFunctions(code) {
  var ast = import_parser.default.parse(code, {
    sourceType: "module"
  });
  import_traverse.default.default(ast, {
    FunctionDeclaration(path) {
      var {
        node
      } = path;
      var functionNamesToHandle = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
      if (!node.id || !functionNamesToHandle.includes(node.id.name)) return;
      if (node.extra && node.extra.isWrapper) return;
      if (node.extra && node.extra.isWrapped) return;
      var originalName = `orig_${node.id.name}`;
      var originalFunction = import_types.default.functionDeclaration(import_types.default.identifier(originalName), node.params, node.body, node.generator, node.async);
      var requestIdentifier = import_types.default.identifier("request");
      var wrapperParams = [requestIdentifier];
      var urlIdentifier = import_types.default.identifier("url");
      var paramsIdentifier = import_types.default.identifier("params");
      var urlDecl = import_types.default.variableDeclaration("const", [import_types.default.variableDeclarator(urlIdentifier, import_types.default.newExpression(import_types.default.identifier("URL"), /* Node.js global */
      [import_types.default.memberExpression(requestIdentifier, import_types.default.identifier("url"))]))]);
      var paramsDecl = import_types.default.variableDeclaration("const", [import_types.default.variableDeclarator(paramsIdentifier, import_types.default.callExpression(import_types.default.memberExpression(import_types.default.identifier("Object"), import_types.default.identifier("fromEntries")), [import_types.default.callExpression(import_types.default.memberExpression(import_types.default.memberExpression(urlIdentifier, import_types.default.identifier("searchParams")), /* url.searchParams */
      import_types.default.identifier("entries")), [])]))]);
      var callOrigFnStatement = import_types.default.callExpression(import_types.default.identifier(originalName), [requestIdentifier, import_types.default.objectExpression([import_types.default.objectProperty(import_types.default.identifier("params"), paramsIdentifier)])]);
      var wrapperFunction = import_types.default.functionDeclaration(import_types.default.identifier(node.id.name + ""), wrapperParams, import_types.default.blockStatement([urlDecl, paramsDecl, import_types.default.returnStatement(callOrigFnStatement)]));
      node.extra = node.extra || {};
      node.extra.isWrapped = true;
      wrapperFunction.extra = wrapperFunction.extra || {};
      wrapperFunction.extra.isWrapper = true;
      if (path.parentPath.isExportNamedDeclaration()) {
        path.replaceWithMultiple([originalFunction, import_types.default.exportNamedDeclaration(wrapperFunction, [])]);
      } else {
        path.replaceWithMultiple([originalFunction, wrapperFunction]);
      }
    }
  });
  var output = import_generator.default.default(ast, {}).code;
  return output;
}
//# sourceMappingURL=createApiServerlessFunction.native.js.map