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

package/dist/cjs/index.js

@@ -1,22 +1,58 @@
 "use strict";
-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 __webpack_modules__ = {
+    "./constants" (module) {
+        module.exports = require("./constants.js");
+    }
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./constants"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./constants")
+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__);
+    var _constants__rspack_import_0 = __webpack_require__("./constants");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _constants__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_constants__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/loader.js

@@ -1,69 +1,73 @@
 "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 loader_exports = {};
-__export(loader_exports, {
-  default: () => loader_default
+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__, {
+    default: ()=>src_loader
 });
-module.exports = __toCommonJS(loader_exports);
-var import_bff_core = require("@modern-js/bff-core");
-var import_utils = require("@modern-js/utils");
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const utils_namespaceObject = require("@modern-js/utils");
 async function loader(source) {
-  this.cacheable();
-  const { resourcePath } = this;
-  delete require.cache[resourcePath];
-  const callback = this.async();
-  const draftOptions = this.getOptions();
-  const warning = `The file ${resourcePath} is not allowd to be imported in src directory, only API definition files are allowed.`;
-  if (!draftOptions.existLambda) {
-    import_utils.logger.warn(warning);
-    callback(null, `throw new Error('${warning}')`);
-    return;
-  }
-  const options = {
-    prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
-    appDir: draftOptions.appDir,
-    apiDir: draftOptions.apiDir,
-    lambdaDir: draftOptions.lambdaDir,
-    target: draftOptions.target,
-    port: Number(draftOptions.port),
-    source,
-    resourcePath,
-    httpMethodDecider: draftOptions.httpMethodDecider
-  };
-  const { lambdaDir } = draftOptions;
-  if (!resourcePath.startsWith(lambdaDir)) {
-    import_utils.logger.warn(warning);
-    callback(null, `throw new Error('${warning}')`);
-    return;
-  }
-  if (draftOptions.fetcher) {
-    options.fetcher = draftOptions.fetcher;
-  }
-  if (draftOptions.requestCreator) {
-    options.requestCreator = draftOptions.requestCreator;
-  }
-  options.requireResolve = require.resolve;
-  const result = await (0, import_bff_core.generateClient)(options);
-  if (result.isOk) {
-    callback(void 0, result.value);
-  } else {
-    callback(void 0, `throw new Error('${result.value}')`);
-  }
+    this.cacheable();
+    const { resourcePath } = this;
+    delete require.cache[resourcePath];
+    const callback = this.async();
+    const draftOptions = this.getOptions();
+    const warning = `The file ${resourcePath} is not allowd to be imported in src directory, only API definition files are allowed.`;
+    if (!draftOptions.existLambda) {
+        utils_namespaceObject.logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    const options = {
+        prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+        appDir: draftOptions.appDir,
+        apiDir: draftOptions.apiDir,
+        lambdaDir: draftOptions.lambdaDir,
+        target: draftOptions.target,
+        port: Number(draftOptions.port),
+        source,
+        resourcePath,
+        httpMethodDecider: draftOptions.httpMethodDecider
+    };
+    const { lambdaDir } = draftOptions;
+    if (!resourcePath.startsWith(lambdaDir)) {
+        utils_namespaceObject.logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    if (draftOptions.fetcher) options.fetcher = draftOptions.fetcher;
+    if (draftOptions.requestCreator) options.requestCreator = draftOptions.requestCreator;
+    options.requireResolve = require.resolve;
+    const result = await (0, bff_core_namespaceObject.generateClient)(options);
+    callback(void 0, result.isOk ? result.value : `throw new Error('${result.value}')`);
 }
-var loader_default = loader;
+const src_loader = loader;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/create-request/index.js

@@ -1,32 +1,42 @@
 "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 create_request_exports = {};
-__export(create_request_exports, {
-  configure: () => import_create_request.configure,
-  createRequest: () => import_create_request.createRequest,
-  createUploader: () => import_create_request.createUploader
+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__, {
+    createUploader: ()=>create_request_namespaceObject.createUploader,
+    configure: ()=>create_request_namespaceObject.configure,
+    createRequest: ()=>create_request_namespaceObject.createRequest
 });
-module.exports = __toCommonJS(create_request_exports);
-var import_create_request = require("@modern-js/create-request");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  configure,
-  createRequest,
-  createUploader
+const create_request_namespaceObject = require("@modern-js/create-request");
+exports.configure = __webpack_exports__.configure;
+exports.createRequest = __webpack_exports__.createRequest;
+exports.createUploader = __webpack_exports__.createUploader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "configure",
+    "createRequest",
+    "createUploader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/runtime/hono/adapter.js

@@ -1,137 +1,139 @@
 "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 adapter_exports = {};
-__export(adapter_exports, {
-  HonoAdapter: () => HonoAdapter
+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__, {
+    HonoAdapter: ()=>HonoAdapter
 });
-module.exports = __toCommonJS(adapter_exports);
-var import_server_core = require("@modern-js/server-core");
-var import_utils = require("@modern-js/utils");
-var import_createHonoRoutes = __toESM(require("../../utils/createHonoRoutes"));
+const server_core_namespaceObject = require("@modern-js/server-core");
+const utils_namespaceObject = require("@modern-js/utils");
+const createHonoRoutes_js_namespaceObject = require("../../utils/createHonoRoutes.js");
+var createHonoRoutes_js_default = /*#__PURE__*/ __webpack_require__.n(createHonoRoutes_js_namespaceObject);
 const before = [
-  "custom-server-hook",
-  "custom-server-middleware",
-  "render"
+    'custom-server-hook',
+    'custom-server-middleware',
+    'render'
 ];
 class HonoAdapter {
-  wrapInArray(handler) {
-    if (Array.isArray(handler)) {
-      return handler;
-    } else {
-      return [
-        handler
-      ];
+    wrapInArray(handler) {
+        if (Array.isArray(handler)) return handler;
+        return [
+            handler
+        ];
     }
-  }
-  constructor(api) {
-    this.apiMiddleware = [];
-    this.apiServer = null;
-    this.isHono = true;
-    this.setHandlers = async () => {
-      if (!this.isHono) {
-        return;
-      }
-      const { apiHandlerInfos } = this.api.useAppContext();
-      const honoHandlers = (0, import_createHonoRoutes.default)(apiHandlerInfos);
-      this.apiMiddleware = honoHandlers.map(({ path, method, handler }) => ({
-        name: "hono-bff-api",
-        path,
-        method,
-        handler,
-        order: "post",
-        before
-      }));
-    };
-    this.registerApiRoutes = async () => {
-      if (!this.isHono) {
-        return;
-      }
-      this.apiServer = new import_server_core.Hono();
-      this.apiMiddleware.forEach(({ path = "*", method = "all", handler }) => {
-        var _this_apiServer;
-        const handlers = this.wrapInArray(handler);
-        (_this_apiServer = this.apiServer) === null || _this_apiServer === void 0 ? void 0 : _this_apiServer[method](path, ...handlers);
-      });
-      this.apiServer.onError(async (err, c) => {
-        try {
-          const serverConfig = this.api.useConfigContext();
-          const onErrorHandler = serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.onError;
-          if (onErrorHandler) {
-            const result = await onErrorHandler(err, c);
-            if (result instanceof Response) {
-              return result;
+    constructor(api){
+        this.apiMiddleware = [];
+        this.apiServer = null;
+        this.isHono = true;
+        this.setHandlers = async ()=>{
+            if (!this.isHono) return;
+            const { apiHandlerInfos } = this.api.getServerContext();
+            const honoHandlers = createHonoRoutes_js_default()(apiHandlerInfos);
+            this.apiMiddleware = honoHandlers.map(({ path, method, handler })=>({
+                    name: 'hono-bff-api',
+                    path,
+                    method,
+                    handler,
+                    order: 'post',
+                    before
+                }));
+        };
+        this.registerApiRoutes = async ()=>{
+            if (!this.isHono) return;
+            this.apiServer = new server_core_namespaceObject.Hono();
+            this.apiMiddleware.forEach(({ path = '*', method = 'all', handler })=>{
+                const handlers = this.wrapInArray(handler);
+                if (0 === handlers.length) return;
+                const firstHandler = handlers[0];
+                const restHandlers = handlers.slice(1);
+                const m = method;
+                const server = this.apiServer;
+                if (!server) return;
+                const register = server[m];
+                register.call(server, path, firstHandler, ...restHandlers);
+            });
+            this.apiServer.onError(async (err, c)=>{
+                try {
+                    const serverConfig = this.api.getServerConfig();
+                    const onErrorHandler = serverConfig?.onError;
+                    if (onErrorHandler) {
+                        const result = await onErrorHandler(err, c);
+                        if (result instanceof Response) return result;
+                    } else utils_namespaceObject.logger.error(err);
+                } catch (configError) {
+                    utils_namespaceObject.logger.error(`Error in serverConfig.onError handler: ${configError}`);
+                }
+                return c.json({
+                    message: err?.message || '[BFF] Internal Server Error'
+                }, err?.status || 500);
+            });
+        };
+        this.registerMiddleware = async (options)=>{
+            const { prefix } = options;
+            const { bffRuntimeFramework } = this.api.getServerContext();
+            if ('hono' !== bffRuntimeFramework) {
+                this.isHono = false;
+                return;
             }
-          }
-        } catch (configError) {
-          import_utils.logger.error(`Error in serverConfig.onError handler: ${configError}`);
-        }
-        return c.json({
-          message: (err === null || err === void 0 ? void 0 : err.message) || "[BFF] Internal Server Error"
-        }, (err === null || err === void 0 ? void 0 : err.status) || 500);
-      });
-    };
-    this.registerMiddleware = async (options) => {
-      const { prefix } = options;
-      const { bffRuntimeFramework } = this.api.useAppContext();
-      if (bffRuntimeFramework !== "hono") {
-        this.isHono = false;
-        return;
-      }
-      const { middlewares: globalMiddlewares } = this.api.useAppContext();
-      await this.setHandlers();
-      if ((0, import_utils.isProd)()) {
-        globalMiddlewares.push(...this.apiMiddleware);
-      } else {
-        await this.registerApiRoutes();
-        const dynamicApiMiddleware = {
-          name: "dynamic-bff-handler",
-          path: `${prefix}/*`,
-          method: "all",
-          order: "post",
-          before,
-          handler: async (c, next) => {
-            if (this.apiServer) {
-              const response = await this.apiServer.fetch(c.req, c.env);
-              if (response.status !== 404) {
-                return new Response(response.body, response);
-              }
+            const { middlewares: globalMiddlewares } = this.api.getServerContext();
+            await this.setHandlers();
+            if ((0, utils_namespaceObject.isProd)()) globalMiddlewares.push(...this.apiMiddleware);
+            else {
+                await this.registerApiRoutes();
+                const dynamicApiMiddleware = {
+                    name: 'dynamic-bff-handler',
+                    path: `${prefix}/*`,
+                    method: 'all',
+                    order: 'post',
+                    before,
+                    handler: async (c, next)=>{
+                        if (this.apiServer) {
+                            const response = await this.apiServer.fetch(c.req.raw, c.env);
+                            if (404 !== response.status) return new Response(response.body, response);
+                        }
+                        await next();
+                    }
+                };
+                globalMiddlewares.push(dynamicApiMiddleware);
             }
-            await next();
-          }
         };
-        globalMiddlewares.push(dynamicApiMiddleware);
-      }
-    };
-    this.api = api;
-  }
+        this.api = api;
+    }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  HonoAdapter
+exports.HonoAdapter = __webpack_exports__.HonoAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HonoAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });