@modern-js/bff-core 2.11.0 → 2.11.1-alpha.0

package/dist/js/node/operators/http.js

@@ -0,0 +1,241 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var http_exports = {};
+__export(http_exports, {
+  Connect: () => Connect,
+  Data: () => Data,
+  Delete: () => Delete,
+  Get: () => Get,
+  Head: () => Head,
+  Headers: () => Headers,
+  HttpCode: () => HttpCode,
+  Option: () => Option,
+  Params: () => Params,
+  Patch: () => Patch,
+  Post: () => Post,
+  Put: () => Put,
+  Query: () => Query,
+  Redirect: () => Redirect,
+  SetHeaders: () => SetHeaders,
+  Trace: () => Trace,
+  createHttpOperator: () => createHttpOperator
+});
+module.exports = __toCommonJS(http_exports);
+var import_types = require("../types");
+var import_http = require("../errors/http");
+const validateInput = (schema, input) => __async(void 0, null, function* () {
+  try {
+    return yield schema.parseAsync(input);
+  } catch (error) {
+    const { z: zod } = require("zod");
+    if (error instanceof zod.ZodError) {
+      throw new import_http.ValidationError(400, error.message);
+    }
+    throw error;
+  }
+});
+const createHttpOperator = (method) => {
+  return (urlPath) => {
+    return {
+      name: method,
+      metadata({ setMetadata }) {
+        setMetadata(import_types.OperatorType.Trigger, {
+          type: import_types.TriggerType.Http,
+          path: urlPath,
+          method
+        });
+      }
+    };
+  };
+};
+const Get = createHttpOperator(import_types.HttpMethod.Get);
+const Post = createHttpOperator(import_types.HttpMethod.Post);
+const Put = createHttpOperator(import_types.HttpMethod.Put);
+const Delete = createHttpOperator(import_types.HttpMethod.Delete);
+const Connect = createHttpOperator(import_types.HttpMethod.Connect);
+const Trace = createHttpOperator(import_types.HttpMethod.Trace);
+const Patch = createHttpOperator(import_types.HttpMethod.Patch);
+const Option = createHttpOperator(import_types.HttpMethod.Option);
+const Head = createHttpOperator(import_types.HttpMethod.Head);
+const Data = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Data,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Data, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { data }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          data: yield validateInput(schema, data)
+        });
+        return next();
+      });
+    }
+  };
+};
+const Query = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Query,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Query, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { query }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          query: yield validateInput(schema, query)
+        });
+        return next();
+      });
+    }
+  };
+};
+const Params = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Params,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Params, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { params }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          params: yield validateInput(schema, params)
+        });
+        return next();
+      });
+    }
+  };
+};
+const Headers = (schema) => {
+  return {
+    name: import_types.HttpMetadata.Headers,
+    metadata({ setMetadata }) {
+      setMetadata(import_types.HttpMetadata.Headers, schema);
+    },
+    validate(helper, next) {
+      return __async(this, null, function* () {
+        const {
+          inputs: { headers }
+        } = helper;
+        helper.inputs = __spreadProps(__spreadValues({}, helper.inputs), {
+          headers: yield validateInput(schema, headers)
+        });
+        return next();
+      });
+    }
+  };
+};
+const setResponseMeta = (helper, type, value) => {
+  const responseMetaData = helper.getMetadata(import_types.HttpMetadata.Response) || [];
+  helper.setMetadata(import_types.HttpMetadata.Response, [
+    ...responseMetaData,
+    {
+      type,
+      value
+    }
+  ]);
+};
+const HttpCode = (statusCode) => {
+  return {
+    name: "HttpCode",
+    metadata(helper) {
+      setResponseMeta(helper, import_types.ResponseMetaType.StatusCode, statusCode);
+    }
+  };
+};
+const SetHeaders = (headers) => {
+  return {
+    name: "SetHeaders",
+    metadata(helper) {
+      setResponseMeta(helper, import_types.ResponseMetaType.Headers, headers);
+    }
+  };
+};
+const Redirect = (url) => {
+  return {
+    name: "Redirect",
+    metadata(helper) {
+      setResponseMeta(helper, import_types.ResponseMetaType.Redirect, url);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Connect,
+  Data,
+  Delete,
+  Get,
+  Head,
+  Headers,
+  HttpCode,
+  Option,
+  Params,
+  Patch,
+  Post,
+  Put,
+  Query,
+  Redirect,
+  SetHeaders,
+  Trace,
+  createHttpOperator
+});

package/dist/js/node/router/constants.js

@@ -0,0 +1,61 @@
+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 constants_exports = {};
+__export(constants_exports, {
+  APIMode: () => APIMode,
+  API_DIR: () => API_DIR,
+  API_FILE_RULES: () => API_FILE_RULES,
+  AllHttpMethods: () => AllHttpMethods,
+  FRAMEWORK_MODE_APP_DIR: () => FRAMEWORK_MODE_APP_DIR,
+  FRAMEWORK_MODE_LAMBDA_DIR: () => FRAMEWORK_MODE_LAMBDA_DIR,
+  INDEX_SUFFIX: () => INDEX_SUFFIX
+});
+module.exports = __toCommonJS(constants_exports);
+var import_types = require("../types");
+const AllHttpMethods = Object.values(import_types.HttpMethod);
+var APIMode = /* @__PURE__ */ ((APIMode2) => {
+  APIMode2["FARMEWORK"] = "framework";
+  APIMode2["FUNCTION"] = "function";
+  return APIMode2;
+})(APIMode || {});
+const FRAMEWORK_MODE_LAMBDA_DIR = "lambda";
+const FRAMEWORK_MODE_APP_DIR = "app";
+const INDEX_SUFFIX = "index";
+const API_DIR = "api";
+const API_FILE_RULES = [
+  "**/*.[tj]s",
+  "!**/_*",
+  "!**/_*/**/*.[tj]s",
+  "!**/*.test.js",
+  "!**/*.test.ts",
+  "!**/*.d.ts",
+  "!__test__/*.ts",
+  "!__tests__/*.ts",
+  "!node_modules/**",
+  "!bootstrap.js"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIMode,
+  API_DIR,
+  API_FILE_RULES,
+  AllHttpMethods,
+  FRAMEWORK_MODE_APP_DIR,
+  FRAMEWORK_MODE_LAMBDA_DIR,
+  INDEX_SUFFIX
+});

package/dist/js/node/router/index.js

@@ -0,0 +1,256 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var router_exports = {};
+__export(router_exports, {
+  ApiRouter: () => ApiRouter
+});
+module.exports = __toCommonJS(router_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_reflect_metadata = require("reflect-metadata");
+var import_types = require("../types");
+var import_utils2 = require("../utils");
+var import_constants = require("./constants");
+var import_utils3 = require("./utils");
+__reExport(router_exports, require("./types"), module.exports);
+__reExport(router_exports, require("./constants"), module.exports);
+class ApiRouter {
+  constructor({
+    apiDir,
+    lambdaDir,
+    prefix
+  }) {
+    this.apiFiles = [];
+    this.getExactApiMode = (apiDir) => {
+      const exist = this.createExistChecker(apiDir);
+      const existLambdaDir = exist(import_constants.FRAMEWORK_MODE_LAMBDA_DIR);
+      const existAppDir = exist(import_constants.FRAMEWORK_MODE_APP_DIR);
+      const existAppFile = exist("app.ts") || exist("app.js");
+      if (existLambdaDir || existAppDir || existAppFile) {
+        return import_constants.APIMode.FARMEWORK;
+      }
+      return import_constants.APIMode.FUNCTION;
+    };
+    this.createExistChecker = (base) => (target) => import_utils.fs.pathExistsSync(import_path.default.resolve(base, target));
+    this.getExactLambdaDir = (apiDir) => {
+      if (this.lambdaDir) {
+        return this.lambdaDir;
+      }
+      const lambdaDir = this.apiMode === import_constants.APIMode.FARMEWORK ? import_path.default.join(apiDir, import_constants.FRAMEWORK_MODE_LAMBDA_DIR) : apiDir;
+      return lambdaDir;
+    };
+    this.validateAbsolute(apiDir, "apiDir");
+    this.validateAbsolute(lambdaDir, "lambdaDir");
+    this.prefix = this.initPrefix(prefix);
+    this.apiDir = apiDir;
+    this.apiMode = this.getExactApiMode(apiDir);
+    this.lambdaDir = lambdaDir || this.getExactLambdaDir(this.apiDir);
+    this.existLambdaDir = import_utils.fs.existsSync(this.lambdaDir);
+  }
+  isExistLambda() {
+    return this.existLambdaDir;
+  }
+  getApiMode() {
+    return this.apiMode;
+  }
+  getLambdaDir() {
+    return this.lambdaDir;
+  }
+  isApiFile(filename) {
+    if (this.existLambdaDir) {
+      return false;
+    }
+    if (!this.apiFiles.includes(filename)) {
+      return false;
+    }
+    return true;
+  }
+  getSingleModuleHandlers(filename) {
+    const moduleInfo = this.getModuleInfo(filename);
+    if (moduleInfo) {
+      return this.getModuleHandlerInfos(moduleInfo);
+    }
+    return null;
+  }
+  getHandlerInfo(filename, originFuncName, handler) {
+    const httpMethod = this.getHttpMethod(originFuncName, handler);
+    const routeName = this.getRouteName(filename, handler);
+    if (httpMethod && routeName) {
+      return {
+        handler,
+        name: originFuncName,
+        httpMethod,
+        routeName,
+        filename,
+        routePath: this.getRoutePath(this.prefix, routeName)
+      };
+    }
+    return null;
+  }
+  getSafeRoutePath(filename, handler) {
+    this.loadApiFiles();
+    this.validateValidApifile(filename);
+    return this.getRouteName(filename, handler);
+  }
+  getRouteName(filename, handler) {
+    if (handler) {
+      const trigger = Reflect.getMetadata(import_types.OperatorType.Trigger, handler);
+      if (trigger && trigger.type === import_types.TriggerType.Http) {
+        if (!trigger.path) {
+          throw new Error(
+            `The http trigger ${trigger.name} needs to specify a path`
+          );
+        }
+        return trigger.path;
+      }
+    }
+    const routePath = (0, import_utils3.getPathFromFilename)(this.lambdaDir, filename);
+    return routePath;
+  }
+  getHttpMethod(originHandlerName, handler) {
+    if (handler) {
+      const trigger = Reflect.getMetadata(import_types.OperatorType.Trigger, handler);
+      if (trigger && import_types.httpMethods.includes(trigger.method)) {
+        return trigger.method;
+      }
+    }
+    const upperName = originHandlerName.toUpperCase();
+    switch (upperName) {
+      case "GET":
+        return import_types.HttpMethod.Get;
+      case "POST":
+        return import_types.HttpMethod.Post;
+      case "PUT":
+        return import_types.HttpMethod.Put;
+      case "DELETE":
+      case "DEL":
+        return import_types.HttpMethod.Delete;
+      case "CONNECT":
+        return import_types.HttpMethod.Connect;
+      case "TRACE":
+        return import_types.HttpMethod.Trace;
+      case "PATCH":
+        return import_types.HttpMethod.Patch;
+      case "OPTION":
+        return import_types.HttpMethod.Option;
+      case "DEFAULT": {
+        return import_types.HttpMethod.Get;
+      }
+      default:
+        import_utils.logger.warn(
+          `Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`
+        );
+        return null;
+    }
+  }
+  loadApiFiles() {
+    if (!this.existLambdaDir) {
+      return [];
+    }
+    const apiFiles = this.apiFiles = (0, import_utils3.getFiles)(this.lambdaDir, import_constants.API_FILE_RULES);
+    return apiFiles;
+  }
+  getApiFiles() {
+    if (!this.existLambdaDir) {
+      return [];
+    }
+    if (this.apiFiles.length > 0) {
+      return this.apiFiles;
+    }
+    return this.loadApiFiles();
+  }
+  getApiHandlers() {
+    const filenames = this.getApiFiles();
+    const moduleInfos = this.getModuleInfos(filenames);
+    const apiHandlers = this.getHandlerInfos(moduleInfos);
+    (0, import_utils2.debug)("apiHandlers", apiHandlers.length, apiHandlers);
+    return apiHandlers;
+  }
+  initPrefix(prefix) {
+    if (prefix === "/") {
+      return "";
+    }
+    return prefix || "/api";
+  }
+  validateAbsolute(filename, paramsName) {
+    if (typeof filename === "string" && !import_path.default.isAbsolute(filename)) {
+      throw new Error(`The ${paramsName} ${filename} is not a abolute path`);
+    }
+  }
+  getModuleInfos(filenames) {
+    return filenames.map((filename) => this.getModuleInfo(filename)).filter((moduleInfo) => Boolean(moduleInfo));
+  }
+  getModuleInfo(filename) {
+    try {
+      const module2 = (0, import_utils3.requireHandlerModule)(filename);
+      return {
+        filename,
+        module: module2
+      };
+    } catch (err) {
+      if (process.env.NODE_ENV === "production") {
+        throw err;
+      } else {
+        console.error(err);
+        return null;
+      }
+    }
+  }
+  getHandlerInfos(moduleInfos) {
+    let apiHandlers = [];
+    moduleInfos.forEach((moduleInfo) => {
+      const handlerInfos = this.getModuleHandlerInfos(moduleInfo);
+      if (handlerInfos) {
+        apiHandlers = apiHandlers.concat(handlerInfos);
+      }
+    });
+    const sortedHandlers = (0, import_utils3.sortRoutes)(apiHandlers);
+    return sortedHandlers;
+  }
+  getModuleHandlerInfos(moduleInfo) {
+    const { module: module2, filename } = moduleInfo;
+    return Object.entries(module2).filter(([, handler]) => typeof handler === "function").map(([key]) => {
+      const handler = module2[key];
+      const handlerInfo = this.getHandlerInfo(filename, key, handler);
+      return handlerInfo;
+    }).filter((handlerInfo) => Boolean(handlerInfo));
+  }
+  validateValidApifile(filename) {
+    if (!this.apiFiles.includes(filename)) {
+      throw new Error(`The ${filename} is not a valid api file.`);
+    }
+  }
+  getRoutePath(prefix, routeName) {
+    const finalRouteName = routeName === "/" ? "" : routeName;
+    if (prefix === "" && finalRouteName === "") {
+      return "/";
+    }
+    return `${prefix}${finalRouteName}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiRouter
+});

package/dist/js/node/router/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/js/node/router/utils.js

@@ -0,0 +1,116 @@
+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(
+  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, {
+  getFiles: () => getFiles,
+  getPathFromFilename: () => getPathFromFilename,
+  isHandler: () => isHandler,
+  requireHandlerModule: () => requireHandlerModule,
+  sortRoutes: () => sortRoutes
+});
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+const getFiles = (lambdaDir, rules) => import_utils.globby.sync(rules, {
+  cwd: lambdaDir,
+  gitignore: true
+}).map((file) => import_path.default.resolve(lambdaDir, file));
+const getPathFromFilename = (baseDir, filename) => {
+  const relativeName = filename.substring(baseDir.length);
+  const relativePath = relativeName.split(".").slice(0, -1).join(".");
+  const nameSplit = relativePath.split(import_path.default.sep).map((item) => {
+    if (item.length > 2) {
+      if (item.startsWith("[") && item.endsWith("]")) {
+        return `:${item.substring(1, item.length - 1)}`;
+      }
+    }
+    return item;
+  });
+  const name = nameSplit.join("/");
+  const finalName = name.endsWith(import_constants.INDEX_SUFFIX) ? name.substring(0, name.length - import_constants.INDEX_SUFFIX.length) : name;
+  return clearRouteName(finalName);
+};
+const clearRouteName = (routeName) => {
+  let finalRouteName = routeName.trim();
+  if (!finalRouteName.startsWith("/")) {
+    finalRouteName = `/${finalRouteName}`;
+  }
+  if (finalRouteName.length > 1 && finalRouteName.endsWith("/")) {
+    finalRouteName = finalRouteName.substring(0, finalRouteName.length - 1);
+  }
+  return finalRouteName;
+};
+const isHandler = (input) => input && typeof input === "function";
+const enableRegister = (requireFn) => {
+  let existTsLoader = false;
+  let firstCall = true;
+  return (modulePath) => {
+    if (firstCall) {
+      existTsLoader = Boolean(require.extensions[".ts"]);
+      firstCall = false;
+    }
+    if (!existTsLoader) {
+      const {
+        register
+      } = require("esbuild-register/dist/node");
+      const { unregister } = register({
+        extensions: [".ts"]
+      });
+      const requiredModule2 = requireFn(modulePath);
+      unregister();
+      return requiredModule2;
+    }
+    const requiredModule = requireFn(modulePath);
+    return requiredModule;
+  };
+};
+const isFunction = (input) => input && {}.toString.call(input) === "[object Function]";
+const requireHandlerModule = enableRegister((modulePath) => {
+  const originRequire = process.env.NODE_ENV === "test" ? jest.requireActual : require;
+  const module2 = originRequire(modulePath);
+  if (isFunction(module2)) {
+    return { default: module2 };
+  }
+  return module2;
+});
+const routeValue = (routePath) => {
+  if (routePath.includes(":")) {
+    return 11;
+  }
+  return 1;
+};
+const sortRoutes = (apiHandlers) => {
+  return apiHandlers.sort((handlerA, handlerB) => {
+    return routeValue(handlerA.routeName) - routeValue(handlerB.routeName);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFiles,
+  getPathFromFilename,
+  isHandler,
+  requireHandlerModule,
+  sortRoutes
+});