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

package/dist/cjs/utils/index.js

@@ -1,37 +1,101 @@
 "use strict";
-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 __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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  debug: () => import_debug.debug
-});
-module.exports = __toCommonJS(utils_exports);
-__reExport(utils_exports, require("./storage"), module.exports);
-__reExport(utils_exports, require("./alias"), module.exports);
-var import_debug = require("./debug");
-__reExport(utils_exports, require("./meta"), module.exports);
-__reExport(utils_exports, require("./validate"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  debug,
-  ...require("./storage"),
-  ...require("./alias"),
-  ...require("./meta"),
-  ...require("./validate")
+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_2.debug
+    });
+    var _storage__rspack_import_0 = __webpack_require__("./storage");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _storage__rspack_import_0)if ([
+        "debug",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_storage__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _alias__rspack_import_1 = __webpack_require__("./alias");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _alias__rspack_import_1)if ([
+        "debug",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_alias__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _debug__rspack_import_2 = __webpack_require__("./debug");
+    var _meta__rspack_import_3 = __webpack_require__("./meta");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _meta__rspack_import_3)if ([
+        "debug",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_meta__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

@@ -1,41 +1,48 @@
 "use strict";
-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 meta_exports = {};
-__export(meta_exports, {
-  HANDLER_WITH_META: () => HANDLER_WITH_META,
-  INPUT_PARAMS_DECIDER: () => INPUT_PARAMS_DECIDER,
-  isInputParamsDeciderHandler: () => isInputParamsDeciderHandler,
-  isWithMetaHandler: () => isWithMetaHandler
+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
 });
-module.exports = __toCommonJS(meta_exports);
-const HANDLER_WITH_META = "HANDLER_WITH_META";
-const INPUT_PARAMS_DECIDER = "INPUT_PARAMS_DECIDER";
-const isWithMetaHandler = (handler) => {
-  return typeof handler === "function" && handler[HANDLER_WITH_META];
-};
-const isInputParamsDeciderHandler = (handler) => {
-  return typeof handler === "function" && handler[INPUT_PARAMS_DECIDER];
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  HANDLER_WITH_META,
-  INPUT_PARAMS_DECIDER,
-  isInputParamsDeciderHandler,
-  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

@@ -1,74 +1,64 @@
 "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 storage_exports = {};
-__export(storage_exports, {
-  createStorage: () => createStorage
+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
 });
-module.exports = __toCommonJS(storage_exports);
-var ah = __toESM(require("async_hooks"));
-const createStorage = () => {
-  let storage;
-  if (typeof ah.AsyncLocalStorage !== "undefined") {
-    storage = new ah.AsyncLocalStorage();
-  }
-  const run = (context, cb) => {
-    if (!storage) {
-      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+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
+        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
-  };
+        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
+    };
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createStorage
+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

@@ -1,81 +1,82 @@
 "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 validate_exports = {};
-__export(validate_exports, {
-  ERR_INVALID_ARG_TYPE: () => ERR_INVALID_ARG_TYPE,
-  getTypeErrorMessage: () => getTypeErrorMessage,
-  validateFunction: () => validateFunction
+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
 });
-module.exports = __toCommonJS(validate_exports);
-var import_util = __toESM(require("util"));
-const getTypeErrorMessage = (actual) => {
-  let msg = "";
-  if (actual == null) {
-    msg += `. Received ${actual}`;
-  } else if (typeof actual === "function" && actual.name) {
-    msg += `. Received function ${actual.name}`;
-  } else if (typeof actual === "object") {
-    var _actual_constructor;
-    if ((_actual_constructor = actual.constructor) === null || _actual_constructor === void 0 ? void 0 : _actual_constructor.name) {
-      msg += `. Received an instance of ${actual.constructor.name}`;
-    } else {
-      const inspected = import_util.default.inspect(actual, {
-        depth: -1
-      });
-      msg += `. Received ${inspected}`;
+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 = import_util.default.inspect(actual, {
-      colors: false
-    });
-    if (inspected.length > 25) {
-      inspected = `${inspected.slice(0, 25)}...`;
+    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})`;
     }
-    msg += `. Received type ${typeof actual} (${inspected})`;
-  }
-  return msg;
+    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);
-  }
+    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 (typeof maybeFunc !== "function") {
-    throw new ERR_INVALID_ARG_TYPE(name, "function", maybeFunc);
-  }
-  return true;
+const validateFunction = (maybeFunc, name)=>{
+    if ('function' != typeof maybeFunc) throw new ERR_INVALID_ARG_TYPE(name, 'function', maybeFunc);
+    return true;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ERR_INVALID_ARG_TYPE,
-  getTypeErrorMessage,
-  validateFunction
+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";
+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,60 @@
+import { resolve } from "path";
+import { ApiRouter } from "../router";
+import { Err, Ok } from "./result";
+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/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 };