@modern-js/bff-core 2.69.5 → 3.0.0-alpha.0

package/dist/esm-node/client/generateClient.mjs

@@ -0,0 +1,60 @@
+import { resolve } from "path";
+import { ApiRouter } from "../router/index.mjs";
+import { Err, Ok } from "./result.mjs";
+const getPackageName = (appDir)=>{
+    try {
+        const packageJsonPath = resolve(appDir, './package.json');
+        const packageJson = require(packageJsonPath);
+        return packageJson.name;
+    } catch (error) {
+        return;
+    }
+};
+const DEFAULT_CLIENT_REQUEST_CREATOR = '@modern-js/create-request';
+const INNER_CLIENT_REQUEST_CREATOR = '@modern-js/plugin-bff/client';
+const generateClient = async ({ appDir, resourcePath, apiDir, lambdaDir, prefix, port, target, requestCreator, fetcher, requireResolve = require.resolve, httpMethodDecider, domain })=>{
+    requestCreator = requestCreator || INNER_CLIENT_REQUEST_CREATOR;
+    const apiRouter = new ApiRouter({
+        appDir,
+        apiDir,
+        lambdaDir,
+        prefix,
+        httpMethodDecider
+    });
+    const handlerInfos = await apiRouter.getSingleModuleHandlers(resourcePath);
+    if (!handlerInfos) return Err(`generate client error: Cannot require module ${resourcePath}`);
+    let handlersCode = '';
+    for (const handlerInfo of handlerInfos){
+        const { name, httpMethod, routePath, action } = handlerInfo;
+        let exportStatement = `var ${name} =`;
+        if ('default' === name.toLowerCase()) exportStatement = 'default';
+        const upperHttpMethod = httpMethod.toUpperCase();
+        const routeName = routePath;
+        const requestId = 'bundle' === target ? getPackageName(appDir) || process.env.npm_package_name : void 0;
+        if ('upload' === action) {
+            const requestOptions = {
+                path: routeName,
+                domain,
+                requestId
+            };
+            handlersCode += `export ${exportStatement} createUploader(${JSON.stringify(requestOptions)});`;
+        } else {
+            const portValue = 'server' === target ? `process.env.PORT || ${String(port)}` : String(port);
+            const optionsStr = `{
+        path: '${routeName}',
+        method: '${upperHttpMethod}',
+        port: ${portValue},
+        httpMethodDecider: '${httpMethodDecider || 'functionName'}'
+        ${domain ? `, domain: '${domain}'` : ''}
+        ${fetcher ? ", fetch: 'fetch'" : ''}
+        ${requestId ? `, requestId: '${requestId}'` : ''}
+      }`.replace(/\n\s*/g, '');
+            handlersCode += `export ${exportStatement} createRequest(${optionsStr});
+      `;
+        }
+    }
+    const importCode = `import { createRequest${handlerInfos.find((i)=>'upload' === i.action) ? ', createUploader' : ''} } from '${requestCreator}';
+${fetcher ? `import { fetch } from '${fetcher}';\n` : ''}`;
+    return Ok(`${importCode}\n${handlersCode}`);
+};
+export { DEFAULT_CLIENT_REQUEST_CREATOR, INNER_CLIENT_REQUEST_CREATOR, generateClient };

package/dist/esm-node/client/index.mjs

@@ -0,0 +1 @@
+export * from "./generateClient.mjs";

package/dist/esm-node/client/result.mjs

@@ -0,0 +1,19 @@
+const Err = (value)=>{
+    const err = {
+        kind: 'Err',
+        value,
+        isErr: true,
+        isOk: false
+    };
+    return err;
+};
+const Ok = (value)=>{
+    const ok = {
+        kind: 'Ok',
+        value,
+        isErr: false,
+        isOk: true
+    };
+    return ok;
+};
+export { Err, Ok };

package/dist/esm-node/errors/http.mjs

@@ -0,0 +1,13 @@
+class HttpError extends Error {
+    constructor(status, message){
+        super(message);
+        this.status = status;
+    }
+}
+class ValidationError extends HttpError {
+    constructor(status, message){
+        super(status, message);
+        this.code = 'VALIDATION_ERROR';
+    }
+}
+export { HttpError, ValidationError };

package/dist/esm-node/index.mjs

@@ -0,0 +1,8 @@
+import { Api } from "./api.mjs";
+import { HttpError, ValidationError } from "./errors/http.mjs";
+import { HANDLER_WITH_META, INPUT_PARAMS_DECIDER, createStorage, getRelativeRuntimePath, isInputParamsDeciderHandler, isWithMetaHandler, registerPaths } from "./utils/index.mjs";
+export * from "./router/index.mjs";
+export * from "./types.mjs";
+export * from "./client/index.mjs";
+export * from "./operators/http.mjs";
+export { Api, HANDLER_WITH_META, HttpError, INPUT_PARAMS_DECIDER, ValidationError, createStorage, getRelativeRuntimePath, isInputParamsDeciderHandler, isWithMetaHandler, registerPaths };

package/dist/esm-node/operators/http.mjs

@@ -0,0 +1,135 @@
+import { ValidationError } from "../errors/http.mjs";
+import { HttpMetadata, HttpMethod, OperatorType, ResponseMetaType, TriggerType } from "../types.mjs";
+const validateInput = async (schema, input)=>{
+    try {
+        return await schema.parseAsync(input);
+    } catch (error) {
+        if ('name' in error && 'ZodError' === error.name) throw new ValidationError(400, error.message);
+        throw error;
+    }
+};
+const createHttpOperator = (method)=>(urlPath)=>({
+            name: method,
+            metadata ({ setMetadata }) {
+                setMetadata(OperatorType.Trigger, {
+                    type: TriggerType.Http,
+                    path: urlPath,
+                    method
+                });
+            }
+        });
+const Get = createHttpOperator(HttpMethod.Get);
+const Post = createHttpOperator(HttpMethod.Post);
+const Put = createHttpOperator(HttpMethod.Put);
+const Delete = createHttpOperator(HttpMethod.Delete);
+const Connect = createHttpOperator(HttpMethod.Connect);
+const Trace = createHttpOperator(HttpMethod.Trace);
+const Patch = createHttpOperator(HttpMethod.Patch);
+const Options = createHttpOperator(HttpMethod.Options);
+const Head = createHttpOperator(HttpMethod.Head);
+const Data = (schema)=>({
+        name: HttpMetadata.Data,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Data, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { data } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                data: await validateInput(schema, data)
+            };
+            return next();
+        }
+    });
+const Query = (schema)=>({
+        name: HttpMetadata.Query,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Query, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { query } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                query: await validateInput(schema, query)
+            };
+            return next();
+        }
+    });
+const Params = (schema)=>({
+        name: HttpMetadata.Params,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Params, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { params } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                params: await validateInput(schema, params)
+            };
+            return next();
+        }
+    });
+const Headers = (schema)=>({
+        name: HttpMetadata.Headers,
+        metadata ({ setMetadata }) {
+            setMetadata(HttpMetadata.Headers, schema);
+        },
+        async validate (helper, next) {
+            const { inputs: { headers } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                headers: await validateInput(schema, headers)
+            };
+            return next();
+        }
+    });
+const setResponseMeta = (helper, type, value)=>{
+    const responseMetaData = helper.getMetadata(HttpMetadata.Response) || [];
+    helper.setMetadata(HttpMetadata.Response, [
+        ...responseMetaData,
+        {
+            type,
+            value
+        }
+    ]);
+};
+const HttpCode = (statusCode)=>({
+        name: 'HttpCode',
+        metadata (helper) {
+            setResponseMeta(helper, ResponseMetaType.StatusCode, statusCode);
+        }
+    });
+const SetHeaders = (headers)=>({
+        name: 'SetHeaders',
+        metadata (helper) {
+            setResponseMeta(helper, ResponseMetaType.Headers, headers);
+        }
+    });
+const Redirect = (url)=>({
+        name: 'Redirect',
+        metadata (helper) {
+            setResponseMeta(helper, ResponseMetaType.Redirect, url);
+        }
+    });
+const Upload = (urlPath, schema)=>({
+        name: 'Upload',
+        metadata ({ setMetadata }) {
+            setMetadata(OperatorType.Trigger, {
+                type: TriggerType.Http,
+                path: urlPath,
+                method: HttpMethod.Post,
+                action: 'upload'
+            });
+            setMetadata(HttpMetadata.Files, schema);
+        },
+        async validate (helper, next) {
+            if (!schema) return next();
+            const { inputs: { formData: files } } = helper;
+            helper.inputs = {
+                ...helper.inputs,
+                files: await validateInput(schema, files)
+            };
+            return next();
+        }
+    });
+export { Connect, Data, Delete, Get, Head, Headers, HttpCode, Options, Params, Patch, Post, Put, Query, Redirect, SetHeaders, Trace, Upload, createHttpOperator };

package/dist/esm-node/router/constants.mjs

@@ -0,0 +1,19 @@
+import { HttpMethod } from "../types.mjs";
+const AllHttpMethods = Object.values(HttpMethod);
+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.jsx'
+];
+export { API_DIR, API_FILE_RULES, AllHttpMethods, FRAMEWORK_MODE_APP_DIR, FRAMEWORK_MODE_LAMBDA_DIR, INDEX_SUFFIX };

package/dist/esm-node/router/index.mjs

@@ -0,0 +1,186 @@
+import path from "path";
+import { fs, logger } from "@modern-js/utils";
+import "reflect-metadata";
+import { HttpMethod, OperatorType, TriggerType, httpMethods } from "../types.mjs";
+import { INPUT_PARAMS_DECIDER, debug } from "../utils/index.mjs";
+import { API_FILE_RULES, FRAMEWORK_MODE_LAMBDA_DIR } from "./constants.mjs";
+import { getFiles, getPathFromFilename, requireHandlerModule, sortRoutes } from "./utils.mjs";
+export * from "./types.mjs";
+export * from "./constants.mjs";
+class ApiRouter {
+    isExistLambda() {
+        return this.existLambdaDir;
+    }
+    getLambdaDir() {
+        return this.lambdaDir;
+    }
+    isApiFile(filename) {
+        if (this.apiFiles.includes(filename)) return true;
+        return false;
+    }
+    async getSingleModuleHandlers(filename) {
+        const moduleInfo = await 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);
+        const action = this.getAction(handler);
+        const responseObj = {
+            handler,
+            name: originFuncName,
+            httpMethod,
+            routeName,
+            filename,
+            routePath: this.getRoutePath(this.prefix, routeName)
+        };
+        if (action) responseObj.action = action;
+        if (httpMethod && routeName) return responseObj;
+        return null;
+    }
+    getSafeRoutePath(filename, handler) {
+        this.loadApiFiles();
+        this.validateValidApifile(filename);
+        return this.getRouteName(filename, handler);
+    }
+    getRouteName(filename, handler) {
+        if (handler) {
+            const trigger = Reflect.getMetadata(OperatorType.Trigger, handler);
+            if (trigger && trigger.type === TriggerType.Http) {
+                if (!trigger.path) throw new Error(`The http trigger ${trigger.name} needs to specify a path`);
+                return trigger.path;
+            }
+        }
+        let routePath = getPathFromFilename(this.lambdaDir, filename);
+        if ('inputParams' === this.httpMethodDecider) if (routePath.endsWith('/')) routePath += `${handler?.name}`;
+        else routePath += `/${handler?.name}`;
+        return routePath;
+    }
+    getHttpMethod(originHandlerName, handler) {
+        if (handler) {
+            const trigger = Reflect.getMetadata(OperatorType.Trigger, handler);
+            if (trigger && httpMethods.includes(trigger.method)) return trigger.method;
+        }
+        if ('functionName' === this.httpMethodDecider) {
+            const upperName = originHandlerName.toUpperCase();
+            switch(upperName){
+                case 'GET':
+                    return HttpMethod.Get;
+                case 'POST':
+                    return HttpMethod.Post;
+                case 'PUT':
+                    return HttpMethod.Put;
+                case 'DELETE':
+                case 'DEL':
+                    return HttpMethod.Delete;
+                case 'CONNECT':
+                    return HttpMethod.Connect;
+                case 'TRACE':
+                    return HttpMethod.Trace;
+                case 'PATCH':
+                    return HttpMethod.Patch;
+                case 'OPTIONS':
+                    return HttpMethod.Options;
+                case 'DEFAULT':
+                    return HttpMethod.Get;
+                default:
+                    if ('test' !== process.env.NODE_ENV) logger.warn(`Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`);
+                    return null;
+            }
+        }
+        if (!handler) return null;
+        if ('function' == typeof handler && handler.length > 0) return HttpMethod.Post;
+        return HttpMethod.Get;
+    }
+    getAction(handler) {
+        if (handler) {
+            const trigger = Reflect.getMetadata(OperatorType.Trigger, handler);
+            if (trigger?.action) return trigger.action;
+        }
+    }
+    loadApiFiles() {
+        if (!this.existLambdaDir) return [];
+        const apiFiles = this.apiFiles = getFiles(this.lambdaDir, API_FILE_RULES);
+        return apiFiles;
+    }
+    getApiFiles() {
+        if (!this.existLambdaDir) return [];
+        if (this.apiFiles.length > 0) return this.apiFiles;
+        return this.loadApiFiles();
+    }
+    async getApiHandlers() {
+        const filenames = this.getApiFiles();
+        const moduleInfos = await this.getModuleInfos(filenames);
+        const apiHandlers = this.getHandlerInfos(moduleInfos);
+        debug('apiHandlers', apiHandlers.length, apiHandlers);
+        return apiHandlers;
+    }
+    initPrefix(prefix) {
+        if ('/' === prefix) return '';
+        return prefix || '/api';
+    }
+    validateAbsolute(filename, paramsName) {
+        if ('string' == typeof filename && !path.isAbsolute(filename)) throw new Error(`The ${paramsName} ${filename} is not a abolute path`);
+    }
+    async getModuleInfos(filenames) {
+        return Promise.all(filenames.map((filename)=>this.getModuleInfo(filename)).filter((moduleInfo)=>Boolean(moduleInfo)));
+    }
+    async getModuleInfo(filename) {
+        try {
+            const module = await requireHandlerModule(filename);
+            return {
+                filename,
+                module
+            };
+        } catch (err) {
+            if ('production' === process.env.NODE_ENV) throw err;
+            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 = sortRoutes(apiHandlers);
+        return sortedHandlers;
+    }
+    getModuleHandlerInfos(moduleInfo) {
+        const { module, filename } = moduleInfo;
+        const { httpMethodDecider } = this;
+        return Object.entries(module).filter(([, handler])=>'function' == typeof handler).map(([key])=>{
+            const handler = module[key];
+            if ('inputParams' === httpMethodDecider) Object.assign(handler, {
+                [INPUT_PARAMS_DECIDER]: true
+            });
+            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}`;
+    }
+    constructor({ appDir, apiDir, lambdaDir, prefix, isBuild, httpMethodDecider = 'functionName' }){
+        this.apiFiles = [];
+        this.getExactLambdaDir = (apiDir, originLambdaDir)=>originLambdaDir || path.join(apiDir, FRAMEWORK_MODE_LAMBDA_DIR);
+        this.validateAbsolute(apiDir, 'apiDir');
+        this.validateAbsolute(lambdaDir, 'lambdaDir');
+        this.prefix = this.initPrefix(prefix);
+        this.appDir = appDir;
+        this.apiDir = apiDir;
+        this.httpMethodDecider = httpMethodDecider;
+        this.isBuild = isBuild;
+        this.lambdaDir = this.getExactLambdaDir(this.apiDir, lambdaDir);
+        this.existLambdaDir = fs.existsSync(this.lambdaDir);
+        debug("apiDir:", this.apiDir, "lambdaDir:", this.lambdaDir);
+    }
+}
+export { ApiRouter };

package/dist/esm-node/router/utils.mjs

@@ -0,0 +1,42 @@
+import path from "path";
+import { compatibleRequire, globby } from "@modern-js/utils";
+import { INDEX_SUFFIX } from "./constants.mjs";
+const getFiles = (lambdaDir, rules)=>globby.sync(rules, {
+        cwd: lambdaDir,
+        gitignore: true
+    }).map((file)=>path.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(path.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(INDEX_SUFFIX) ? name.substring(0, name.length - 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 && 'function' == typeof input;
+const isFunction = (input)=>input && '[object Function]' === ({}).toString.call(input);
+const requireHandlerModule = async (modulePath)=>{
+    const originRequire = 'test' === process.env.NODE_ENV ? jest.requireActual : compatibleRequire;
+    const module = await originRequire(modulePath, false);
+    if (isFunction(module)) return {
+        default: module
+    };
+    return module;
+};
+const routeValue = (routePath)=>{
+    if (routePath.includes(':')) return 11;
+    return 1;
+};
+const sortRoutes = (apiHandlers)=>apiHandlers.sort((handlerA, handlerB)=>routeValue(handlerA.routeName) - routeValue(handlerB.routeName));
+export { getFiles, getPathFromFilename, isHandler, requireHandlerModule, sortRoutes };

package/dist/esm-node/types.mjs

@@ -0,0 +1,39 @@
+var types_OperatorType = /*#__PURE__*/ function(OperatorType) {
+    OperatorType[OperatorType["Trigger"] = 0] = "Trigger";
+    OperatorType[OperatorType["Middleware"] = 1] = "Middleware";
+    return OperatorType;
+}({});
+var types_TriggerType = /*#__PURE__*/ function(TriggerType) {
+    TriggerType[TriggerType["Http"] = 0] = "Http";
+    return TriggerType;
+}({});
+var types_HttpMetadata = /*#__PURE__*/ function(HttpMetadata) {
+    HttpMetadata["Method"] = "METHOD";
+    HttpMetadata["Data"] = "DATA";
+    HttpMetadata["Query"] = "QUERY";
+    HttpMetadata["Params"] = "PARAMS";
+    HttpMetadata["Headers"] = "HEADERS";
+    HttpMetadata["Response"] = "RESPONSE";
+    HttpMetadata["Files"] = "Files";
+    return HttpMetadata;
+}({});
+var types_ResponseMetaType = /*#__PURE__*/ function(ResponseMetaType) {
+    ResponseMetaType[ResponseMetaType["StatusCode"] = 0] = "StatusCode";
+    ResponseMetaType[ResponseMetaType["Redirect"] = 1] = "Redirect";
+    ResponseMetaType[ResponseMetaType["Headers"] = 2] = "Headers";
+    return ResponseMetaType;
+}({});
+var types_HttpMethod = /*#__PURE__*/ function(HttpMethod) {
+    HttpMethod["Get"] = "GET";
+    HttpMethod["Post"] = "POST";
+    HttpMethod["Put"] = "PUT";
+    HttpMethod["Delete"] = "DELETE";
+    HttpMethod["Connect"] = "CONNECT";
+    HttpMethod["Trace"] = "TRACE";
+    HttpMethod["Patch"] = "PATCH";
+    HttpMethod["Options"] = "OPTIONS";
+    HttpMethod["Head"] = "HEAD";
+    return HttpMethod;
+}({});
+const httpMethods = Object.values(types_HttpMethod);
+export { types_HttpMetadata as HttpMetadata, types_HttpMethod as HttpMethod, types_OperatorType as OperatorType, types_ResponseMetaType as ResponseMetaType, types_TriggerType as TriggerType, httpMethods };

package/dist/esm-node/utils/alias.mjs

@@ -0,0 +1,57 @@
+import fs from "fs";
+import module_0 from "module";
+import { platform } from "os";
+import { isAbsolute, join, relative } from "path";
+const getRelativeRuntimePath = (appDirectory, serverRuntimePath)=>{
+    let relativeRuntimePath = '';
+    relativeRuntimePath = 'win32' === platform() ? `../${relative(appDirectory, serverRuntimePath)}` : join('../', relative(appDirectory, serverRuntimePath));
+    if ('development' === process.env.NODE_ENV || 'test' === process.env.NODE_ENV) relativeRuntimePath = `./${relative(appDirectory, serverRuntimePath)}`;
+    return relativeRuntimePath;
+};
+const sortByLongestPrefix = (arr)=>arr.concat().sort((a, b)=>b.length - a.length);
+const createMatchPath = (paths)=>{
+    const sortedKeys = sortByLongestPrefix(Object.keys(paths));
+    const sortedPaths = {};
+    sortedKeys.forEach((key)=>{
+        sortedPaths[key] = paths[key];
+    });
+    return (request)=>{
+        const found = Object.keys(sortedPaths).find((key)=>request.startsWith(key));
+        if (found) {
+            let foundPaths = sortedPaths[found];
+            if (!Array.isArray(foundPaths)) foundPaths = [
+                foundPaths
+            ];
+            foundPaths = foundPaths.filter((foundPath)=>isAbsolute(foundPath));
+            for (const p of foundPaths){
+                const foundPath = request.replace(found, p);
+                if (fs.existsSync(foundPath)) return foundPath;
+            }
+            return request.replace(found, foundPaths[0]);
+        }
+        return null;
+    };
+};
+const registerPaths = (paths)=>{
+    const originalResolveFilename = module_0._resolveFilename;
+    const { builtinModules } = module_0;
+    const matchPath = createMatchPath(paths);
+    module_0._resolveFilename = function(request, _parent) {
+        const isCoreModule = builtinModules.includes(request);
+        if (!isCoreModule) {
+            const matched = matchPath(request);
+            if (matched) {
+                const modifiedArguments = [
+                    matched,
+                    ...[].slice.call(arguments, 1)
+                ];
+                return originalResolveFilename.apply(this, modifiedArguments);
+            }
+        }
+        return originalResolveFilename.apply(this, arguments);
+    };
+    return ()=>{
+        module_0._resolveFilename = originalResolveFilename;
+    };
+};
+export { createMatchPath, getRelativeRuntimePath, registerPaths };

package/dist/esm-node/utils/debug.mjs

@@ -0,0 +1,3 @@
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger('bff');
+export { debug };

package/dist/esm-node/utils/index.mjs

@@ -0,0 +1,6 @@
+import { debug } from "./debug.mjs";
+export * from "./storage.mjs";
+export * from "./alias.mjs";
+export * from "./meta.mjs";
+export * from "./validate.mjs";
+export { debug };

package/dist/esm-node/utils/meta.mjs

@@ -0,0 +1,5 @@
+const HANDLER_WITH_META = 'HANDLER_WITH_META';
+const INPUT_PARAMS_DECIDER = 'INPUT_PARAMS_DECIDER';
+const isWithMetaHandler = (handler)=>'function' == typeof handler && handler[HANDLER_WITH_META];
+const isInputParamsDeciderHandler = (handler)=>'function' == typeof handler && handler[INPUT_PARAMS_DECIDER];
+export { HANDLER_WITH_META, INPUT_PARAMS_DECIDER, isInputParamsDeciderHandler, isWithMetaHandler };

package/dist/esm-node/utils/storage.mjs

@@ -0,0 +1,30 @@
+import { AsyncLocalStorage } from "async_hooks";
+const createStorage = ()=>{
+    let storage;
+    if (void 0 !== AsyncLocalStorage) storage = new AsyncLocalStorage();
+    const run = (context, cb)=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        return new Promise((resolve, reject)=>{
+            storage.run(context, ()=>{
+                try {
+                    return resolve(cb());
+                } catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    const useContext = ()=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        const context = storage.getStore();
+        if (!context) throw new Error("Can't call useContext out of scope, it should be placed in the bff function");
+        return context;
+    };
+    return {
+        run,
+        useContext
+    };
+};
+export { createStorage };

package/dist/esm-node/utils/validate.mjs

@@ -0,0 +1,32 @@
+import util from "util";
+const getTypeErrorMessage = (actual)=>{
+    let msg = '';
+    if (null == actual) msg += `. Received ${actual}`;
+    else if ('function' == typeof actual && actual.name) msg += `. Received function ${actual.name}`;
+    else if ('object' == typeof actual) if (actual.constructor?.name) msg += `. Received an instance of ${actual.constructor.name}`;
+    else {
+        const inspected = util.inspect(actual, {
+            depth: -1
+        });
+        msg += `. Received ${inspected}`;
+    }
+    else {
+        let inspected = util.inspect(actual, {
+            colors: false
+        });
+        if (inspected.length > 25) inspected = `${inspected.slice(0, 25)}...`;
+        msg += `. Received type ${typeof actual} (${inspected})`;
+    }
+    return msg;
+};
+class ERR_INVALID_ARG_TYPE extends Error {
+    constructor(funcName, expectedType, actual){
+        const message = `[ERR_INVALID_ARG_TYPE]: The '${funcName}' argument must be of type ${expectedType}${getTypeErrorMessage(actual)}`;
+        super(message);
+    }
+}
+const validateFunction = (maybeFunc, name)=>{
+    if ('function' != typeof maybeFunc) throw new ERR_INVALID_ARG_TYPE(name, 'function', maybeFunc);
+    return true;
+};
+export { ERR_INVALID_ARG_TYPE, getTypeErrorMessage, validateFunction };