vona-module-a-web 5.0.31 → 5.0.32

package/dist/.metadata/index.d.ts

@@ -124,6 +124,23 @@ declare module 'vona-module-a-web' {
     }
 }
 /** filterTransform: end */
+/** hmr: begin */
+export * from '../bean/hmr.controller.ts';
+import 'vona';
+declare module 'vona' {
+    interface IHmrRecord {
+        'a-web:controller': never;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface HmrController {
+    }
+    interface HmrController {
+        get $beanFullName(): 'a-web.hmr.controller';
+        get $onionName(): 'a-web:controller';
+    }
+}
+/** hmr: end */
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';

package/dist/bean/bean.router.d.ts

@@ -1,12 +1,11 @@
-import type { Constructable, VonaContext } from 'vona';
 import * as ModuleInfo from '@cabloy/module-info';
 import Router from 'find-my-way';
 import { BeanBase } from 'vona';
 export declare class BeanRouter extends BeanBase {
-    registerController(moduleName: string, controller: Constructable): void;
+    reRegisterController(beanFullName: string): void;
+    registerController(beanFullName: string): void;
     register(method: Router.HTTPMethod, moduleName: ModuleInfo.IModuleInfo | string, path: string | undefined, simplify: boolean, fn: Router.Handler<Router.HTTPVersion.V1>): void;
     unRegister(method: Router.HTTPMethod, moduleName: ModuleInfo.IModuleInfo | string, path: string | undefined, simplify: boolean): void;
     findByPath(method: Router.HTTPMethod, moduleName: ModuleInfo.IModuleInfo | string, path: string | undefined, simplify: boolean): any;
     private _registerControllerAction;
-    _registerComposeMiddlewares(ctx: VonaContext): (context: any, next?: any) => any;
 }

package/dist/bean/hmr.controller.d.ts

@@ -0,0 +1,6 @@
+import type { IDecoratorBeanOptionsBase } from 'vona';
+import type { IHmrReload } from 'vona-module-a-hmr';
+import { BeanBase } from 'vona';
+export declare class HmrController extends BeanBase implements IHmrReload {
+    reload(beanOptions: IDecoratorBeanOptionsBase): Promise<void>;
+}

package/dist/index.js

@@ -1,8 +1,7 @@
 import { BeanInfo, BeanBase, cast, beanFullNameFromOnionName, appMetadata, appResource, deepExtend, compose, createBeanDecorator, BeanSimple, BeanScopeBase } from 'vona';
 import { isNil, isNilOrEmptyString } from '@cabloy/utils';
 import { ZodMetadata } from '@cabloy/zod-openapi';
-import { Pipe, createArgumentPipe, setArgumentPipe } from 'vona-module-a-aspect';
-import * as ModuleInfo from '@cabloy/module-info';
+import { Pipe, createArgumentPipe, SymbolCacheComposeGuards, SymbolCacheComposeInterceptors, SymbolCacheComposePipes, SymbolCacheComposeMiddlewares, clearCacheComposesRouter, SymbolCacheComposeMiddlewareSystems, setArgumentPipe } from 'vona-module-a-aspect';
 import { Bean, Service, Scope } from 'vona-module-a-bean';
 import { SymbolUseOnionOptions } from 'vona-module-a-onion';
 import { SymbolRouteHandlersArgumentsValue, SymbolRouteHandlersArgumentsMeta, makeSchemaLikes, $schema, SymbolOpenApiOptions, mergeFieldsOpenapiMetadata } from 'vona-module-a-openapiutils';
@@ -11,21 +10,22 @@ import http from 'node:http';
 import { Startup } from 'vona-module-a-startup';
 import { DateTime } from 'luxon';
 import 'vona-module-a-web';
+import { Hmr } from 'vona-module-a-hmr';
 import Router from 'find-my-way';
 import { SymbolRouterMiddleware } from 'vona-module-a-executor';
 import { z } from 'zod';
 
-var _dec$7, _dec2$7, _class$7;
+var _dec$8, _dec2$8, _class$8;
 const __FieldsSystem = ['columns', 'where', 'orders', 'pageNo', 'pageSize'];
-let PipeFilter = (_dec$7 = Pipe({
+let PipeFilter = (_dec$8 = Pipe({
   // ValidatorOptions
   disableErrorMessages: false,
   errorHttpStatusCode: 400,
   loose: false,
   strict: false
-}), _dec2$7 = BeanInfo({
+}), _dec2$8 = BeanInfo({
   module: "a-web"
-}), _dec$7(_class$7 = _dec2$7(_class$7 = class PipeFilter extends BeanBase {
+}), _dec$8(_class$8 = _dec2$8(_class$8 = class PipeFilter extends BeanBase {
   async transform(value, metadata, options) {
     if (!options.schema) throw new Error(`should specify the schema of pipeFilter: ${metadata.controller.name}.${metadata.method}#${metadata.index}`);
     // validateSchema
@@ -164,19 +164,19 @@ let PipeFilter = (_dec$7 = Pipe({
       await this._transformField(key, value[key], params, value, options);
     }
   }
-}) || _class$7) || _class$7);
+}) || _class$8) || _class$8);
 const ArgFilterPro = createArgumentPipe('a-web:filter');
 
-var _dec$6, _dec2$6, _class$6;
-let PipeValid = (_dec$6 = Pipe({
+var _dec$7, _dec2$7, _class$7;
+let PipeValid = (_dec$7 = Pipe({
   // ValidatorOptions
   disableErrorMessages: false,
   errorHttpStatusCode: 400,
   loose: false,
   strict: false
-}), _dec2$6 = BeanInfo({
+}), _dec2$7 = BeanInfo({
   module: "a-web"
-}), _dec$6(_class$6 = _dec2$6(_class$6 = class PipeValid extends BeanBase {
+}), _dec$7(_class$7 = _dec2$7(_class$7 = class PipeValid extends BeanBase {
   async transform(value, metadata, options) {
     if (options.schema) {
       // validateSchema
@@ -184,26 +184,56 @@ let PipeValid = (_dec$6 = Pipe({
     }
     return value;
   }
-}) || _class$6) || _class$6);
+}) || _class$7) || _class$7);
 const ArgValid = createArgumentPipe('a-web:valid');
 
+const SymbolCacheControllerRoutes = Symbol('SymbolCacheControllerRoutes');
+function getCacheControllerRoutes(app) {
+  if (!app.meta[SymbolCacheControllerRoutes]) app.meta[SymbolCacheControllerRoutes] = {};
+  return app.meta[SymbolCacheControllerRoutes];
+}
+
 async function middlewareGuard(ctx, next) {
   // check handler
   const handler = ctx.getHandler();
   if (!handler) return next();
   // compose
-  const result = await ctx.app.bean.onion.guard.compose(ctx)(ctx);
+  const result = await _composeGuards(ctx.app, ctx.route)(ctx);
   if (result === false) ctx.app.throw(403);
   // next
   return next();
 }
+function _composeGuards(app, route) {
+  // compose
+  if (!app.meta[SymbolCacheComposeGuards]) app.meta[SymbolCacheComposeGuards] = {};
+  const cacheComposeGuards = app.meta[SymbolCacheComposeGuards];
+  const beanFullName = route.controllerBeanFullName;
+  const handlerName = route.action;
+  const key = `${beanFullName}:${handlerName}`;
+  if (!cacheComposeGuards[key]) {
+    cacheComposeGuards[key] = app.bean.onion.guard.compose(route);
+  }
+  return cacheComposeGuards[key];
+}
 
 async function middlewareInterceptor(ctx, next) {
   // check handler
   const handler = ctx.getHandler();
   if (!handler) return next();
   // compose
-  return await ctx.app.bean.onion.interceptor.compose(ctx)(ctx, next);
+  return await _composeInterceptors(ctx.app, ctx.route)(ctx, next);
+}
+function _composeInterceptors(app, route) {
+  // compose
+  if (!app.meta[SymbolCacheComposeInterceptors]) app.meta[SymbolCacheComposeInterceptors] = {};
+  const cacheComposeInterceptors = app.meta[SymbolCacheComposeInterceptors];
+  const beanFullName = route.controllerBeanFullName;
+  const handlerName = route.action;
+  const key = `${beanFullName}:${handlerName}`;
+  if (!cacheComposeInterceptors[key]) {
+    cacheComposeInterceptors[key] = app.bean.onion.interceptor.compose(route);
+  }
+  return cacheComposeInterceptors[key];
 }
 
 function extractValue(ctx, argMeta) {
@@ -256,16 +286,16 @@ async function middlewarePipe(ctx, next) {
   const handler = ctx.getHandler();
   if (!handler) return next();
   // arguments
-  ctx[SymbolRouteHandlersArgumentsValue] = await _transformArguments(ctx, ctx.getController(), handler);
+  ctx[SymbolRouteHandlersArgumentsValue] = await _transformArguments(ctx.app, ctx.route);
   // next
   return next();
 }
-async function _transformArguments(ctx, controller, handler) {
-  const paramtypes = appMetadata.getMetadata('design:paramtypes', controller.prototype, handler.name);
+async function _transformArguments(app, route) {
+  const paramtypes = appMetadata.getMetadata('design:paramtypes', route.controller.prototype, route.action);
   if (!paramtypes) return;
 
   // meta
-  const argsMeta = appMetadata.getMetadata(SymbolRouteHandlersArgumentsMeta, controller.prototype, handler.name);
+  const argsMeta = appMetadata.getMetadata(SymbolRouteHandlersArgumentsMeta, route.controller.prototype, route.action);
   if (!argsMeta) return;
 
   // args
@@ -276,24 +306,24 @@ async function _transformArguments(ctx, controller, handler) {
     const argMeta = argsMeta.find(item => item?.index === index);
     if (!argMeta) continue;
     // extractValue
-    const value = await _extractArgumentValue(ctx, argMeta);
+    const value = await _extractArgumentValue(app.ctx, argMeta);
     // metadata
     const metadata = {
       type: argMeta.type,
       field: argMeta.field,
       metaType: paramtypes[index],
-      controller,
-      method: handler.name,
+      controller: route.controller,
+      method: route.action,
       index: argMeta.index
     };
     // transform
-    args[index] = await _transformArgument(ctx, argMeta, metadata, value);
+    args[index] = await _transformArgument(app, route, argMeta, metadata, value);
   }
   return args;
 }
-async function _transformArgument(ctx, argMeta, metadata, value) {
+async function _transformArgument(app, route, argMeta, metadata, value) {
   // pipes
-  const pipes = composePipes(ctx, argMeta, (beanInstance, value, options, _next) => {
+  const pipes = composePipes(app, route, argMeta, (beanInstance, value, options, _next) => {
     if (!isNil(options.argIndex) && argMeta.index !== options.argIndex) return value;
     return beanInstance.transform(value, metadata, options);
   });
@@ -313,22 +343,21 @@ async function _extractArgumentValue(ctx, argMeta) {
   }
   return extractValue(ctx, argMeta);
 }
-const SymbolCacheMiddlewaresArgument = Symbol('SymbolCacheMiddlewaresArgument');
-function composePipes(ctx, argMeta, executeCustom) {
-  if (!ctx.app.meta[SymbolCacheMiddlewaresArgument]) ctx.app.meta[SymbolCacheMiddlewaresArgument] = {};
-  const __cacheMiddlewaresArgument = ctx.app.meta[SymbolCacheMiddlewaresArgument];
-  const onionPipe = ctx.app.bean.onion.pipe;
-  const beanFullName = ctx.getControllerBeanFullName();
-  const handlerName = ctx.getHandler().name;
+function composePipes(app, route, argMeta, executeCustom) {
+  if (!app.meta[SymbolCacheComposePipes]) app.meta[SymbolCacheComposePipes] = {};
+  const cacheComposePipes = app.meta[SymbolCacheComposePipes];
+  const onionPipe = app.bean.onion.pipe;
+  const beanFullName = route.controllerBeanFullName;
+  const handlerName = route.action;
   const key = `${beanFullName}:${handlerName}:${argMeta.index}`;
-  if (!__cacheMiddlewaresArgument[key]) {
+  if (!cacheComposePipes[key]) {
     const middlewares = [];
     // pipes: global
     for (const item of onionPipe.onionsGlobal) {
       middlewares.push(onionPipe._wrapOnion(item, executeCustom));
     }
     // pipes: route
-    const middlewaresLocal = onionPipe._collectOnionsHandler(ctx);
+    const middlewaresLocal = onionPipe._collectOnionsHandler(route);
     for (const item of middlewaresLocal) {
       middlewares.push(onionPipe._wrapOnion(item, executeCustom));
     }
@@ -339,9 +368,9 @@ function composePipes(ctx, argMeta, executeCustom) {
         middlewares.push(onionPipe._wrapOnion(item, executeCustom));
       }
     }
-    __cacheMiddlewaresArgument[key] = middlewares;
+    cacheComposePipes[key] = middlewares;
   }
-  return __cacheMiddlewaresArgument[key];
+  return cacheComposePipes[key];
 }
 function _collectArgumentMiddlewares(onionPipe, argMeta) {
   if (!argMeta.pipes) return;
@@ -373,17 +402,28 @@ const SymbolRequestMappingHandler = Symbol('SymbolRequestMappingHandler');
 //   HEAD = 'head',
 // }
 
-var _dec$5, _dec2$5, _class$5;
-const SymbolRouteComposeMiddlewaresCache = Symbol('SymbolRouteComposeMiddlewaresCache');
-let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
+var _dec$6, _dec2$6, _class$6;
+let BeanRouter = (_dec$6 = Bean(), _dec2$6 = BeanInfo({
   module: "a-web"
-}), _dec$5(_class$5 = _dec2$5(_class$5 = class BeanRouter extends BeanBase {
-  registerController(moduleName, controller) {
-    // info
-    const info = ModuleInfo.parseInfo(moduleName);
+}), _dec$6(_class$6 = _dec2$6(_class$6 = class BeanRouter extends BeanBase {
+  reRegisterController(beanFullName) {
+    const app = this.app;
+    // remove
+    const cacheControllerRoutes = getCacheControllerRoutes(this.app);
+    const routes = cacheControllerRoutes[beanFullName];
+    if (!routes) return;
+    delete cacheControllerRoutes[beanFullName];
+    for (const route of routes) {
+      app.router.off(route.routeMethod.toUpperCase(), route.routePath);
+    }
+    // register
+    this.registerController(beanFullName);
+  }
+  registerController(beanFullName) {
     // controller options
-    const beanOptions = appResource.getBean(controller);
+    const beanOptions = appResource.getBean(beanFullName);
     if (!beanOptions) return;
+    const controller = beanOptions.beanClass;
     const controllerBeanFullName = beanOptions.beanFullName;
     const controllerOptions = beanOptions.options;
     const controllerPath = controllerOptions.path;
@@ -394,7 +434,7 @@ let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
       const desc = descs[actionKey];
       if (['constructor'].includes(actionKey)) continue;
       if (!desc.value || typeof desc.value !== 'function') continue;
-      this._registerControllerAction(info, controller, controllerBeanFullName, controllerPath, controllerMiddlewaresOptions, actionKey, desc);
+      this._registerControllerAction(beanOptions.module, controller, controllerBeanFullName, controllerPath, controllerMiddlewaresOptions, actionKey, desc);
     }
   }
   register(method, moduleName, path, simplify, fn) {
@@ -412,7 +452,7 @@ let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
     const _path = app.util.combineApiPath(path, moduleName, true, simplify);
     return app.router.findRoute(method, _path);
   }
-  _registerControllerAction(info, controller, controllerBeanFullName, controllerPath, controllerMiddlewaresOptions, actionKey, desc) {
+  _registerControllerAction(moduleName, controller, controllerBeanFullName, controllerPath, controllerMiddlewaresOptions, actionKey, desc) {
     // app
     const app = this.app;
 
@@ -422,8 +462,8 @@ let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
     const actionPath = handlerMetadata.path || '';
     const actionMethod = handlerMetadata.method || 'get';
     // routePath
-    const routePath = app.util.combineApiPathControllerAndAction(info.relativeName, controllerPath, actionPath, true, true);
-    const routePathRaw = app.util.combineApiPathControllerAndActionRaw(info.relativeName, controllerPath, actionPath, true);
+    const routePath = app.util.combineApiPathControllerAndAction(moduleName, controllerPath, actionPath, true, true);
+    const routePathRaw = app.util.combineApiPathControllerAndActionRaw(moduleName, controllerPath, actionPath, true);
 
     // middlewares options
     const actionMiddlewaresOptions = appMetadata.getMetadata(SymbolUseOnionOptions, controller.prototype, actionKey);
@@ -435,8 +475,6 @@ let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
 
     // route
     const _route = {
-      pid: info.pid,
-      module: info.name,
       controller,
       actionDescriptor: desc,
       controllerBeanFullName,
@@ -448,22 +486,33 @@ let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
     };
 
     // fn
-    const self = this;
     const fn = function (_req, _res, params, _store, searchParams) {
       const ctx = this;
       ctx.route = _route;
       ctx.request.params = params;
       ctx.request.query = searchParams;
-      if (!_route[SymbolRouteComposeMiddlewaresCache]) {
-        _route[SymbolRouteComposeMiddlewaresCache] = self._registerComposeMiddlewares(ctx);
-      }
-      return _route[SymbolRouteComposeMiddlewaresCache](ctx);
+      return _composeMiddlewares(this.app, _route)(ctx);
     };
 
+    // add
+    const cacheControllerRoutes = getCacheControllerRoutes(this.app);
+    if (!cacheControllerRoutes[controllerBeanFullName]) {
+      cacheControllerRoutes[controllerBeanFullName] = [];
+    }
+    cacheControllerRoutes[controllerBeanFullName].push(_route);
+
     // register
-    app.router.on(_route.routeMethod.toUpperCase(), _route.routePath.toString(), fn);
+    app.router.on(_route.routeMethod.toUpperCase(), _route.routePath, fn);
   }
-  _registerComposeMiddlewares(ctx) {
+}) || _class$6) || _class$6);
+function _composeMiddlewares(app, route) {
+  // compose
+  if (!app.meta[SymbolCacheComposeMiddlewares]) app.meta[SymbolCacheComposeMiddlewares] = {};
+  const cacheComposeMiddlewares = app.meta[SymbolCacheComposeMiddlewares];
+  const beanFullName = route.controllerBeanFullName;
+  const handlerName = route.action;
+  const key = `${beanFullName}:${handlerName}`;
+  if (!cacheComposeMiddlewares[key]) {
     // start
     const fnStart = routeStartMiddleware;
     // mid: guard/interceptor/pipes/tail
@@ -474,10 +523,10 @@ let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
     fnMid.push(routeTailDoneMiddleware);
     // end: controller
     const fnEnd = classControllerMiddleware;
-    // compose
-    return this.app.bean.onion.middleware.compose(ctx, fnStart, fnMid, fnEnd);
+    cacheComposeMiddlewares[key] = app.bean.onion.middleware.compose(route, fnStart, fnMid, fnEnd);
   }
-}) || _class$5) || _class$5);
+  return cacheComposeMiddlewares[key];
+}
 function classControllerMiddleware(ctx) {
   const handlerName = ctx.getHandlerName();
   const controller = ctx.getControllerBean();
@@ -500,61 +549,10 @@ async function routeTailDoneMiddleware(ctx, next) {
   return res;
 }
 
-// _registerInner(route, middlewaresLocal) {
-//   // app
-//   const app = this.app;
-//   // args
-//   let args: any[] = [];
-//   // middlewares: start
-//   const fnStart = async (ctx: VonaContext, next: Next) => {
-//     // route
-//     ctx.route = route;
-//     // next
-//     const res = await next();
-//     // invoke callbackes: handle secondly
-//     await ctx.commitsDone();
-//     // ok
-//     return res;
-//   };
-//   fnStart._name = 'start';
-//   args.push(fnStart);
-
-//   // middlewares: globals
-//   args.push(...app.bean.onion.middleware.composedOnionsGlobal);
-//   // middlewares: guard/interceptor/pipes
-//   args.push(middlewareGuard);
-//   args.push(middlewareInterceptor);
-//   args.push(middlewarePipe);
-
-//   // middlewares: tailDone
-//   const fnTailDone = async (ctx, next) => {
-//     // next
-//     const res = await next();
-//     // invoke callbackes: handle firstly
-//     await ctx.commitsDone();
-//     // ok
-//     return res;
-//   };
-//   fnTailDone._name = 'tailDone';
-//   args.push(fnTailDone);
-
-//   // middlewares
-//   if (middlewaresLocal.length > 0) {
-//     args = args.concat(middlewaresLocal);
-//   }
-
-//   // load
-//   if (route.routeName) {
-//     app.router[route.routeMethod](route.routeName, route.routePath, ...args);
-//   } else {
-//     app.router[route.routeMethod](route.routePath, ...args);
-//   }
-// }
-
-var _dec$4, _dec2$4, _class$4;
-let ServiceWeb = (_dec$4 = Service(), _dec2$4 = BeanInfo({
+var _dec$5, _dec2$5, _class$5;
+let ServiceWeb = (_dec$5 = Service(), _dec2$5 = BeanInfo({
   module: "a-web"
-}), _dec$4(_class$4 = _dec2$4(_class$4 = class ServiceWeb extends BeanBase {
+}), _dec$5(_class$5 = _dec2$5(_class$5 = class ServiceWeb extends BeanBase {
   combineControllerActionApiPath(controller, actionKey, prefix, simplify) {
     // beanOptions
     const beanOptions = appResource.getBean(controller);
@@ -568,14 +566,14 @@ let ServiceWeb = (_dec$4 = Service(), _dec2$4 = BeanInfo({
     // combine
     return this.app.util.combineApiPathControllerAndAction(beanOptions.module, controllerPath, actionPath, prefix, simplify);
   }
-}) || _class$4) || _class$4);
+}) || _class$5) || _class$5);
 
-var _dec$3, _dec2$3, _class$3;
-let StartupListen = (_dec$3 = Startup({
+var _dec$4, _dec2$4, _class$4;
+let StartupListen = (_dec$4 = Startup({
   after: true
-}), _dec2$3 = BeanInfo({
+}), _dec2$4 = BeanInfo({
   module: "a-web"
-}), _dec$3(_class$3 = _dec2$3(_class$3 = class StartupListen extends BeanBase {
+}), _dec$4(_class$4 = _dec2$4(_class$4 = class StartupListen extends BeanBase {
   async execute() {
     if (!this.app.config.server.listen.disable) {
       this.app.server = this._listen(this.app.config.server.listen.port, this.app.config.server.listen.hostname);
@@ -601,16 +599,16 @@ let StartupListen = (_dec$3 = Startup({
       }); // not set instanceName
     };
   }
-}) || _class$3) || _class$3);
+}) || _class$4) || _class$4);
 
 function FilterTransform(options) {
   return createBeanDecorator('filterTransform', options);
 }
 
-var _dec$2, _dec2$2, _class$2;
-let FilterTransformBase = (_dec$2 = FilterTransform(), _dec2$2 = BeanInfo({
+var _dec$3, _dec2$3, _class$3;
+let FilterTransformBase = (_dec$3 = FilterTransform(), _dec2$3 = BeanInfo({
   module: "a-web"
-}), _dec$2(_class$2 = _dec2$2(_class$2 = class FilterTransformBase extends BeanBase {
+}), _dec$3(_class$3 = _dec2$3(_class$3 = class FilterTransformBase extends BeanBase {
   async where(info, _options) {
     const {
       value,
@@ -635,14 +633,14 @@ let FilterTransformBase = (_dec$2 = FilterTransform(), _dec2$2 = BeanInfo({
     }
     return where;
   }
-}) || _class$2) || _class$2);
+}) || _class$3) || _class$3);
 
-var _dec$1, _dec2$1, _class$1;
-let FilterTransformDateRange = (_dec$1 = FilterTransform({
+var _dec$2, _dec2$2, _class$2;
+let FilterTransformDateRange = (_dec$2 = FilterTransform({
   separator: '~'
-}), _dec2$1 = BeanInfo({
+}), _dec2$2 = BeanInfo({
   module: "a-web"
-}), _dec$1(_class$1 = _dec2$1(_class$1 = class FilterTransformDateRange extends BeanBase {
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class FilterTransformDateRange extends BeanBase {
   async where(info, options) {
     const {
       value
@@ -667,6 +665,17 @@ let FilterTransformDateRange = (_dec$1 = FilterTransform({
     }
     return where;
   }
+}) || _class$2) || _class$2);
+
+var _dec$1, _dec2$1, _class$1;
+let HmrController = (_dec$1 = Hmr(), _dec2$1 = BeanInfo({
+  module: "a-web"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class HmrController extends BeanBase {
+  async reload(beanOptions) {
+    clearCacheComposesRouter(this.app);
+    this.bean.router.reRegisterController(beanOptions.beanFullName);
+    await this.$scope.openapi.service.openapi.clearAllCaches();
+  }
 }) || _class$1) || _class$1);
 
 function config(_app) {
@@ -700,36 +709,18 @@ class Main extends BeanSimple {
       }
     });
     // register controllers
-    for (const controller of this.bean.onion.controller.getOnionsEnabled()) {
-      this.bean.router.registerController(controller.beanOptions.module, controller.beanOptions.beanClass);
+    for (const controller of this.bean.onion.controller.getOnionsEnabledCached()) {
+      this.bean.router.registerController(controller.beanOptions.beanFullName);
     }
     // middleware: system
-    const middlewares = this.bean.onion.middlewareSystem.getOnionsEnabledWrapped(item => {
-      return this._wrapOnion(item);
+    this.app.use((ctx, next) => {
+      return _composeMiddlewareSystems(this.app)(ctx, next);
     });
-    this.app.use(compose(middlewares));
     // middleware: router
     this.app[SymbolRouterMiddleware] = routerMiddleware(this[SymbolRouter]);
     this.app.use(this.app[SymbolRouterMiddleware]);
   }
   async configLoaded(_config) {}
-  _wrapOnion(item) {
-    const fn = (_ctx, next) => {
-      const options = item.beanOptions.options;
-      if (!this.bean.onion.checkOnionOptionsEnabled(options, this.ctx.path)) {
-        return next();
-      }
-      // execute
-      const beanFullName = item.beanOptions.beanFullName;
-      const beanInstance = this.app.bean._getBean(beanFullName);
-      if (!beanInstance) {
-        throw new Error(`middlewareSystem bean not found: ${beanFullName}`);
-      }
-      return beanInstance.execute(options, next);
-    };
-    fn._name = item.name;
-    return fn;
-  }
 }
 function routerMiddleware(router) {
   return function (ctx) {
@@ -741,6 +732,33 @@ function routerMiddleware(router) {
     });
   };
 }
+function _composeMiddlewareSystems(app) {
+  // compose
+  if (!app.meta[SymbolCacheComposeMiddlewareSystems]) {
+    const middlewares = app.bean.onion.middlewareSystem.getOnionsEnabledWrapped(item => {
+      return _wrapOnion(app, item);
+    });
+    app.meta[SymbolCacheComposeMiddlewareSystems] = compose(middlewares);
+  }
+  return app.meta[SymbolCacheComposeMiddlewareSystems];
+}
+function _wrapOnion(app, item) {
+  const fn = (_ctx, next) => {
+    const options = item.beanOptions.options;
+    if (!app.bean.onion.checkOnionOptionsEnabled(options, app.ctx.path)) {
+      return next();
+    }
+    // execute
+    const beanFullName = item.beanOptions.beanFullName;
+    const beanInstance = app.bean._getBean(beanFullName);
+    if (!beanInstance) {
+      throw new Error(`middlewareSystem bean not found: ${beanFullName}`);
+    }
+    return beanInstance.execute(options, next);
+  };
+  fn._name = item.name;
+  return fn;
+}
 
 var _dec, _dec2, _class;
 let ScopeModuleAWeb = (_dec = Scope(), _dec2 = BeanInfo({
@@ -918,4 +936,4 @@ const Web = {
   head: Head
 };
 
-export { Arg, ArgFilterPro, ArgValid, BeanRouter, Controller, Dto, FilterTransform, FilterTransformBase, FilterTransformDateRange, Main, PipeFilter, PipeValid, RequestMapping, ScopeModuleAWeb, ServiceWeb, StartupListen, SymbolRequestMappingHandler, Web, config, createPipesArgumentDecorator, mergeActionsOpenapiMetadata };
+export { Arg, ArgFilterPro, ArgValid, BeanRouter, Controller, Dto, FilterTransform, FilterTransformBase, FilterTransformDateRange, HmrController, Main, PipeFilter, PipeValid, RequestMapping, ScopeModuleAWeb, ServiceWeb, StartupListen, SymbolCacheControllerRoutes, SymbolRequestMappingHandler, Web, config, createPipesArgumentDecorator, getCacheControllerRoutes, mergeActionsOpenapiMetadata };

package/dist/lib/const.d.ts

@@ -0,0 +1,4 @@
+import type { VonaApplication } from 'vona';
+import type { ContextRoute } from '../types/router.ts';
+export declare const SymbolCacheControllerRoutes: unique symbol;
+export declare function getCacheControllerRoutes(app: VonaApplication): Record<string, ContextRoute[]>;

package/dist/lib/index.d.ts

@@ -1 +1,2 @@
+export * from './const.ts';
 export * from './decorator/index.ts';

package/dist/main.d.ts

@@ -6,6 +6,5 @@ export declare class Main extends BeanSimple implements IModuleMain {
     moduleLoading(): Promise<void>;
     moduleLoaded(): Promise<void>;
     configLoaded(_config: any): Promise<void>;
-    private _wrapOnion;
 }
 export {};

package/dist/types/router.d.ts

@@ -5,16 +5,14 @@ export interface ContextRouteMetadata {
     meta: any;
 }
 export interface ContextRoute {
-    pid: string;
-    module: string;
     controller: Constructable;
     actionDescriptor: PropertyDescriptor;
     controllerBeanFullName: string;
     action: string;
     route: ContextRouteMetadata;
     routeMethod: TypeRequestMethod;
-    routePath: string | RegExp;
-    routePathRaw: string | RegExp;
+    routePath: string;
+    routePathRaw: string;
 }
 declare module 'vona' {
     interface VonaApplication {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-web",
   "type": "module",
-  "version": "5.0.31",
+  "version": "5.0.32",
   "title": "a-web",
   "vonaModule": {
     "capabilities": {