@bleedingdev/modern-js-bff-core 3.2.0-ultramodern.0

package/dist/cjs/types.js

@@ -0,0 +1,88 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    HttpMetadata: ()=>HttpMetadata,
+    HttpMethod: ()=>HttpMethod,
+    OperatorType: ()=>OperatorType,
+    ResponseMetaType: ()=>ResponseMetaType,
+    TriggerType: ()=>TriggerType,
+    httpMethods: ()=>httpMethods
+});
+var OperatorType = /*#__PURE__*/ function(OperatorType) {
+    OperatorType[OperatorType["Trigger"] = 0] = "Trigger";
+    OperatorType[OperatorType["Middleware"] = 1] = "Middleware";
+    return OperatorType;
+}({});
+var TriggerType = /*#__PURE__*/ function(TriggerType) {
+    TriggerType[TriggerType["Http"] = 0] = "Http";
+    return TriggerType;
+}({});
+var 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 ResponseMetaType = /*#__PURE__*/ function(ResponseMetaType) {
+    ResponseMetaType[ResponseMetaType["StatusCode"] = 0] = "StatusCode";
+    ResponseMetaType[ResponseMetaType["Redirect"] = 1] = "Redirect";
+    ResponseMetaType[ResponseMetaType["Headers"] = 2] = "Headers";
+    return ResponseMetaType;
+}({});
+var 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(HttpMethod);
+exports.HttpMetadata = __webpack_exports__.HttpMetadata;
+exports.HttpMethod = __webpack_exports__.HttpMethod;
+exports.OperatorType = __webpack_exports__.OperatorType;
+exports.ResponseMetaType = __webpack_exports__.ResponseMetaType;
+exports.TriggerType = __webpack_exports__.TriggerType;
+exports.httpMethods = __webpack_exports__.httpMethods;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HttpMetadata",
+    "HttpMethod",
+    "OperatorType",
+    "ResponseMetaType",
+    "TriggerType",
+    "httpMethods"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/alias.js

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createMatchPath: ()=>createMatchPath,
+    getRelativeRuntimePath: ()=>getRelativeRuntimePath,
+    registerPaths: ()=>registerPaths
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_module_namespaceObject = require("module");
+var external_module_default = /*#__PURE__*/ __webpack_require__.n(external_module_namespaceObject);
+const external_os_namespaceObject = require("os");
+const external_path_namespaceObject = require("path");
+const getRelativeRuntimePath = (appDirectory, serverRuntimePath)=>{
+    let relativeRuntimePath = '';
+    relativeRuntimePath = 'win32' === external_os_namespaceObject.platform() ? `../${external_path_namespaceObject.relative(appDirectory, serverRuntimePath)}` : external_path_namespaceObject.join('../', external_path_namespaceObject.relative(appDirectory, serverRuntimePath));
+    if ('development' === process.env.NODE_ENV || 'test' === process.env.NODE_ENV) relativeRuntimePath = `./${external_path_namespaceObject.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)=>external_path_namespaceObject.isAbsolute(foundPath));
+            for (const p of foundPaths){
+                const foundPath = request.replace(found, p);
+                if (external_fs_default().existsSync(foundPath)) return foundPath;
+            }
+            return request.replace(found, foundPaths[0]);
+        }
+        return null;
+    };
+};
+const registerPaths = (paths)=>{
+    const originalResolveFilename = external_module_default()._resolveFilename;
+    const { builtinModules } = external_module_default();
+    const matchPath = createMatchPath(paths);
+    external_module_default()._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 ()=>{
+        external_module_default()._resolveFilename = originalResolveFilename;
+    };
+};
+exports.createMatchPath = __webpack_exports__.createMatchPath;
+exports.getRelativeRuntimePath = __webpack_exports__.getRelativeRuntimePath;
+exports.registerPaths = __webpack_exports__.registerPaths;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createMatchPath",
+    "getRelativeRuntimePath",
+    "registerPaths"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/debug.js

@@ -0,0 +1,37 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    debug: ()=>debug
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const debug = (0, utils_namespaceObject.createDebugger)('bff');
+exports.debug = __webpack_exports__.debug;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "debug"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/index.js

@@ -0,0 +1,101 @@
+"use strict";
+var __webpack_modules__ = {
+    "./alias" (module) {
+        module.exports = require("./alias.js");
+    },
+    "./debug" (module) {
+        module.exports = require("./debug.js");
+    },
+    "./meta" (module) {
+        module.exports = require("./meta.js");
+    },
+    "./storage" (module) {
+        module.exports = require("./storage.js");
+    },
+    "./validate" (module) {
+        module.exports = require("./validate.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        debug: ()=>_debug__rspack_import_1.debug
+    });
+    var _alias__rspack_import_0 = __webpack_require__("./alias");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _alias__rspack_import_0)if ([
+        "debug",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_alias__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _debug__rspack_import_1 = __webpack_require__("./debug");
+    var _meta__rspack_import_2 = __webpack_require__("./meta");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _meta__rspack_import_2)if ([
+        "debug",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_meta__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _storage__rspack_import_3 = __webpack_require__("./storage");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _storage__rspack_import_3)if ([
+        "debug",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_storage__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _validate__rspack_import_4 = __webpack_require__("./validate");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _validate__rspack_import_4)if ([
+        "debug",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_validate__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+exports.debug = __webpack_exports__.debug;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "debug"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/meta.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    HANDLER_WITH_META: ()=>HANDLER_WITH_META,
+    INPUT_PARAMS_DECIDER: ()=>INPUT_PARAMS_DECIDER,
+    isInputParamsDeciderHandler: ()=>isInputParamsDeciderHandler,
+    isWithMetaHandler: ()=>isWithMetaHandler
+});
+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];
+exports.HANDLER_WITH_META = __webpack_exports__.HANDLER_WITH_META;
+exports.INPUT_PARAMS_DECIDER = __webpack_exports__.INPUT_PARAMS_DECIDER;
+exports.isInputParamsDeciderHandler = __webpack_exports__.isInputParamsDeciderHandler;
+exports.isWithMetaHandler = __webpack_exports__.isWithMetaHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HANDLER_WITH_META",
+    "INPUT_PARAMS_DECIDER",
+    "isInputParamsDeciderHandler",
+    "isWithMetaHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/storage.js

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createStorage: ()=>createStorage
+});
+const external_async_hooks_namespaceObject = require("async_hooks");
+const createStorage = ()=>{
+    let storage;
+    if (void 0 !== external_async_hooks_namespaceObject.AsyncLocalStorage) storage = new external_async_hooks_namespaceObject.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
+    };
+};
+exports.createStorage = __webpack_exports__.createStorage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createStorage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/validate.js

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ERR_INVALID_ARG_TYPE: ()=>ERR_INVALID_ARG_TYPE,
+    getTypeErrorMessage: ()=>getTypeErrorMessage,
+    validateFunction: ()=>validateFunction
+});
+const external_util_namespaceObject = require("util");
+var external_util_default = /*#__PURE__*/ __webpack_require__.n(external_util_namespaceObject);
+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 = external_util_default().inspect(actual, {
+            depth: -1
+        });
+        msg += `. Received ${inspected}`;
+    }
+    else {
+        let inspected = external_util_default().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;
+};
+exports.ERR_INVALID_ARG_TYPE = __webpack_exports__.ERR_INVALID_ARG_TYPE;
+exports.getTypeErrorMessage = __webpack_exports__.getTypeErrorMessage;
+exports.validateFunction = __webpack_exports__.validateFunction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ERR_INVALID_ARG_TYPE",
+    "getTypeErrorMessage",
+    "validateFunction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/api.mjs

@@ -0,0 +1,44 @@
+import "reflect-metadata";
+import koa_compose from "koa-compose";
+import { HANDLER_WITH_META, validateFunction } from "./utils/index.mjs";
+function Api(...args) {
+    const handler = args.pop();
+    validateFunction(handler, 'Apihandler');
+    const operators = args;
+    const metadataHelper = {
+        getMetadata (key) {
+            return Reflect.getMetadata(key, runner);
+        },
+        setMetadata (key, value) {
+            return Reflect.defineMetadata(key, value, runner);
+        }
+    };
+    for (const operator of operators)if (operator.metadata) operator.metadata(metadataHelper);
+    const validateHandlers = operators.filter((operator)=>operator.validate).map((operator)=>operator.validate);
+    const pipeHandlers = operators.filter((operator)=>operator.execute).map((operator)=>operator.execute);
+    async function runner(inputs) {
+        const executeHelper = {
+            result: null,
+            get inputs () {
+                return inputs;
+            },
+            set inputs (val){
+                inputs = val;
+            }
+        };
+        const stack = [
+            ...validateHandlers,
+            ...pipeHandlers
+        ];
+        stack.push(async (helper, next)=>{
+            const res = await handler(helper.inputs);
+            helper.result = res;
+            return next();
+        });
+        await koa_compose(stack)(executeHelper);
+        return executeHelper.result;
+    }
+    runner[HANDLER_WITH_META] = true;
+    return runner;
+}
+export { Api };

package/dist/esm/client/generateClient.mjs

@@ -0,0 +1,99 @@
+import "path";
+import { ApiRouter } from "../router/index.mjs";
+import { createOperationEntries, createOperationSchemaHash } from "../security/operationContracts.mjs";
+import { Err, Ok } from "./result.mjs";
+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, requestId })=>{
+    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}`);
+    const operationEntries = createOperationEntries(handlerInfos);
+    const operationVersion = 1;
+    const schemaHash = createOperationSchemaHash(operationEntries, requestId || 'default');
+    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 serializedRouteName = JSON.stringify(routePath);
+        const serializedMethod = JSON.stringify(upperHttpMethod);
+        const serializedMethodDecider = JSON.stringify(httpMethodDecider ? httpMethodDecider : 'functionName');
+        const serializedOperationContext = JSON.stringify({
+            operationId: name,
+            routePath,
+            method: upperHttpMethod,
+            schemaHash,
+            operationVersion
+        });
+        const tailArgs = `, ${fetcher ? 'fetch' : 'undefined'}, ${requestId ? JSON.stringify(requestId) : 'undefined'}, ${serializedOperationContext}`;
+        if ('server' === target) handlersCode += `export ${exportStatement} createRequest(${serializedRouteName}, ${serializedMethod}, process.env.PORT || ${String(port)}, ${serializedMethodDecider}${tailArgs});
+      `;
+        else handlersCode += `export ${exportStatement} createRequest(${serializedRouteName}, ${serializedMethod}, ${String(port)}, ${serializedMethodDecider}${tailArgs});
+      `;
+    }
+    const serializedRequestCreator = JSON.stringify(requestCreator);
+    const serializedFetcher = fetcher ? JSON.stringify(fetcher) : void 0;
+    const importCode = requestId ? `import * as requestRuntime from ${serializedRequestCreator};
+const { createRequest } = requestRuntime;
+${serializedFetcher ? `import { fetch } from ${serializedFetcher};\n` : ''}` : `import { createRequest } from ${serializedRequestCreator};
+${serializedFetcher ? `import { fetch } from ${serializedFetcher};\n` : ''}`;
+    const bootstrapCode = requestId ? `export const initProducerClient = (options = {}) => {
+  const configure = requestRuntime.configure;
+  if (typeof configure !== 'function') {
+    console.warn('[modernjs] Compatibility request creator path does not expose configure(); use default @modern-js/create-request or migrate the compatibility path.');
+    return undefined;
+  }
+  const defaultSecureOptions = {
+    requestId: ${JSON.stringify(requestId)},
+    requireEnvelope: true,
+    identityBinding: {
+      enabled: true,
+      strict: true,
+    },
+    operationContract: {
+      enabled: true,
+      strict: true,
+      requireSchemaHash: true,
+      requireOperationVersion: true,
+    },
+  };
+  return configure({
+    ...defaultSecureOptions,
+    ...options,
+    identityBinding: {
+      ...defaultSecureOptions.identityBinding,
+      ...(options && options.identityBinding ? options.identityBinding : {}),
+    },
+    operationContract: {
+      ...defaultSecureOptions.operationContract,
+      ...(options && options.operationContract ? options.operationContract : {}),
+    },
+  });
+};
+` : '';
+    const manifestCode = `export const operationVersion = ${String(operationVersion)};
+export const operationSchemaHash = '${schemaHash}';
+export const operationManifest = ${JSON.stringify({
+        operationVersion,
+        schemaHash,
+        operations: operationEntries
+    }, null, 2)};
+`;
+    const generatedParts = [
+        importCode.trimEnd(),
+        bootstrapCode.trimEnd(),
+        manifestCode.trimEnd(),
+        handlersCode.trimEnd()
+    ].filter(Boolean);
+    return Ok(`${generatedParts.join('\n\n')}
+`);
+};
+export { INNER_CLIENT_REQUEST_CREATOR, generateClient };

package/dist/esm/client/index.mjs

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