vona-module-a-web 5.0.30 → 5.0.32

package/cli/filterTransform/boilerplate/{{sceneName}}.{{beanName}}.ts_

@@ -0,0 +1,10 @@
+import type { IDecoratorFilterTransformOptions, IFilterTransformWhere, IPipeOptionsFilterTransformInfo } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { FilterTransform } from 'vona-module-a-web';
+
+export interface IFilterTransformOptions<%=argv.beanNameCapitalize%> extends IDecoratorFilterTransformOptions {}
+
+@FilterTransform<IFilterTransformOptions<%=argv.beanNameCapitalize%>>()
+export class FilterTransform<%=argv.beanNameCapitalize%> extends BeanBase implements IFilterTransformWhere {
+  async where(_info: IPipeOptionsFilterTransformInfo, _options: IFilterTransformOptions<%=argv.beanNameCapitalize%>): Promise<any | undefined> {}
+}

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

@@ -1,22 +1,22 @@
 /** pipe: begin */
-export * from '../bean/pipe.query.ts';
+export * from '../bean/pipe.filter.ts';
 export * from '../bean/pipe.valid.ts';
-import type { IPipeOptionsQuery } from '../bean/pipe.query.ts';
+import type { IPipeOptionsFilter } from '../bean/pipe.filter.ts';
 import type { IPipeOptionsValid } from '../bean/pipe.valid.ts';
 import 'vona-module-a-aspect';
 declare module 'vona-module-a-aspect' {
     interface IPipeRecordLocal {
-        'a-web:query': IPipeOptionsQuery;
+        'a-web:filter': IPipeOptionsFilter;
         'a-web:valid': IPipeOptionsValid;
     }
 }
 declare module 'vona-module-a-web' {
-    interface PipeQuery {
+    interface PipeFilter {
     }
-    interface PipeQuery {
-        get $beanFullName(): 'a-web.pipe.query';
-        get $onionName(): 'a-web:query';
-        get $onionOptions(): IPipeOptionsQuery;
+    interface PipeFilter {
+        get $beanFullName(): 'a-web.pipe.filter';
+        get $onionName(): 'a-web:filter';
+        get $onionOptions(): IPipeOptionsFilter;
     }
     interface PipeValid {
     }
@@ -95,6 +95,52 @@ declare module 'vona-module-a-web' {
     }
 }
 /** startup: end */
+/** filterTransform: begin */
+export * from '../bean/filterTransform.base.ts';
+export * from '../bean/filterTransform.dateRange.ts';
+import type { IFilterTransformOptionsBase } from '../bean/filterTransform.base.ts';
+import type { IFilterTransformOptionsDateRange } from '../bean/filterTransform.dateRange.ts';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+    interface IFilterTransformRecord {
+        'a-web:base': IFilterTransformOptionsBase;
+        'a-web:dateRange': IFilterTransformOptionsDateRange;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface FilterTransformBase {
+    }
+    interface FilterTransformBase {
+        get $beanFullName(): 'a-web.filterTransform.base';
+        get $onionName(): 'a-web:base';
+        get $onionOptions(): IFilterTransformOptionsBase;
+    }
+    interface FilterTransformDateRange {
+    }
+    interface FilterTransformDateRange {
+        get $beanFullName(): 'a-web.filterTransform.dateRange';
+        get $onionName(): 'a-web:dateRange';
+        get $onionOptions(): IFilterTransformOptionsDateRange;
+    }
+}
+/** 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/filterTransform.base.d.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorFilterTransformOptions, IFilterTransformWhere, IPipeOptionsFilterTransformInfo } from '../types/filterTransform.ts';
+import { BeanBase } from 'vona';
+export interface IFilterTransformOptionsBase extends IDecoratorFilterTransformOptions {
+    test: boolean;
+}
+export declare class FilterTransformBase extends BeanBase implements IFilterTransformWhere {
+    where(info: IPipeOptionsFilterTransformInfo, _options: IFilterTransformOptionsBase): Promise<any | undefined>;
+}

package/dist/bean/filterTransform.dateRange.d.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorFilterTransformOptions, IFilterTransformWhere, IPipeOptionsFilterTransformInfo } from '../types/filterTransform.ts';
+import { BeanBase } from 'vona';
+export interface IFilterTransformOptionsDateRange extends IDecoratorFilterTransformOptions {
+    separator: string;
+}
+export declare class FilterTransformDateRange extends BeanBase implements IFilterTransformWhere {
+    where(info: IPipeOptionsFilterTransformInfo, options: IFilterTransformOptionsDateRange): Promise<any | undefined>;
+}

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/bean/pipe.filter.d.ts

@@ -0,0 +1,17 @@
+import type { IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, IPipeTransform } from 'vona-module-a-aspect';
+import type { RouteHandlerArgumentMeta } from 'vona-module-a-openapi';
+import type { ValidatorOptions } from 'vona-module-a-validation';
+import { BeanBase } from 'vona';
+export type TypePipeFilterData = unknown;
+export type TypePipeFilterResult = TypePipeFilterData;
+export interface IPipeOptionsFilter extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {
+}
+export declare class PipeFilter extends BeanBase implements IPipeTransform<TypePipeFilterData, TypePipeFilterResult> {
+    transform(value: TypePipeFilterData, metadata: RouteHandlerArgumentMeta, options: IPipeOptionsFilter): Promise<TypePipeFilterResult>;
+    private _transform;
+    private _transformSystem;
+    private _transformOrders;
+    private _transformField;
+    private _transformFields;
+}
+export declare const ArgFilterPro: (options?: Partial<IPipeOptionsFilter> | undefined) => any;

package/dist/index.js

@@ -1,44 +1,45 @@
-import { BeanInfo, BeanBase, cast, appMetadata, appResource, deepExtend, compose, BeanSimple, BeanScopeBase, createBeanDecorator } from 'vona';
-import { isNil, combineParamsAndQuery } from '@cabloy/utils';
+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, mergeFieldsOpenapiMetadata } from 'vona-module-a-openapi';
+import { SymbolRouteHandlersArgumentsValue, SymbolRouteHandlersArgumentsMeta, makeSchemaLikes, $schema, SymbolOpenApiOptions, mergeFieldsOpenapiMetadata } from 'vona-module-a-openapiutils';
 import { SymbolUploadValue } from 'vona-module-a-upload';
 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';
-import { SymbolOpenApiOptions } from 'vona-module-a-openapiutils';
 
-var _dec$5, _dec2$5, _class$5;
+var _dec$8, _dec2$8, _class$8;
 const __FieldsSystem = ['columns', 'where', 'orders', 'pageNo', 'pageSize'];
-let PipeQuery = (_dec$5 = Pipe({
+let PipeFilter = (_dec$8 = Pipe({
   // ValidatorOptions
   disableErrorMessages: false,
   errorHttpStatusCode: 400,
   loose: false,
   strict: false
-}), _dec2$5 = BeanInfo({
+}), _dec2$8 = BeanInfo({
   module: "a-web"
-}), _dec$5(_class$5 = _dec2$5(_class$5 = class PipeQuery 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 pipeQuery: ${metadata.controller.name}.${metadata.method}#${metadata.index}`);
+    if (!options.schema) throw new Error(`should specify the schema of pipeFilter: ${metadata.controller.name}.${metadata.method}#${metadata.index}`);
     // validateSchema
     value = await this.bean.validator.validateSchema(options.schema, value, options, metadata.field);
     // transform
-    value = this._transform(value, options);
+    value = await this._transform(value, options);
     // ok
     return value;
   }
-  _transform(value, options) {
+  async _transform(value, options) {
     // 1. system: columns/where/orders/pageNo/pageSize
     const params = this._transformSystem(value);
     // 2. fields
-    this._transformFields(params, value, options);
+    await this._transformFields(params, value, options);
     // 3. system: orders
     this._transformOrders(params, options);
     // ok
@@ -76,41 +77,43 @@ let PipeQuery = (_dec$5 = Pipe({
     if (!params.orders) return;
     // openapi
     const openapi = ZodMetadata.getOpenapiMetadata(options.schema);
-    const table = openapi?.query?.table;
+    const table = openapi?.filter?.table;
     // loop
     for (const order of params.orders) {
       const field = order[0];
       if (field.includes('.')) continue;
       let tableCurrent = table;
       let fieldCurrent = field;
-      const fieldSchema = ZodMetadata.unwrapChained(ZodMetadata.getFieldSchema(options.schema, field));
+      const fieldSchema = ZodMetadata.getFieldSchema(options.schema, field);
       if (fieldSchema) {
         const openapi = ZodMetadata.getOpenapiMetadata(fieldSchema);
-        if (openapi?.query?.table) {
-          tableCurrent = openapi?.query?.table;
+        if (openapi?.filter?.table) {
+          tableCurrent = openapi?.filter?.table;
         }
-        if (openapi?.query?.originalName) {
-          fieldCurrent = openapi?.query?.originalName;
+        if (openapi?.filter?.originalName) {
+          fieldCurrent = openapi?.filter?.originalName;
         }
       }
       cast(order)[0] = tableCurrent ? `${tableCurrent}.${fieldCurrent}` : fieldCurrent;
     }
   }
-  _transformField(key, fieldValue, params, value, options) {
+  async _transformField(key, fieldValue, params, value, options) {
+    if (isNilOrEmptyString(fieldValue)) return;
     if (__FieldsSystem.includes(key)) return;
-    const fieldSchema = ZodMetadata.unwrapChained(ZodMetadata.getFieldSchema(options.schema, key));
+    const fieldSchema = ZodMetadata.getFieldSchema(options.schema, key);
     if (!fieldSchema) return;
+    const fieldSchemaInner = ZodMetadata.unwrapChained(fieldSchema);
     // openapi
     const openapi = ZodMetadata.getOpenapiMetadata(fieldSchema);
     // name
-    const originalName = openapi?.query?.originalName ?? key;
+    const originalName = openapi?.filter?.originalName ?? key;
     let fullName;
     // joins
     let joinInfo;
-    if (openapi?.query?.joinOn) {
-      const joinType = openapi.query.joinType ?? 'innerJoin';
-      const joinTable = openapi.query.table;
-      const joinOn = openapi.query.joinOn;
+    if (openapi?.filter?.joinOn) {
+      const joinType = openapi.filter.joinType ?? 'innerJoin';
+      const joinTable = openapi.filter.table;
+      const joinOn = openapi.filter.joinOn;
       joinInfo = [joinType, joinTable, joinOn];
       fullName = `${joinTable}.${originalName}`;
     } else {
@@ -118,8 +121,19 @@ let PipeQuery = (_dec$5 = Pipe({
     }
     // check where
     if (Object.prototype.hasOwnProperty.call(params.where, fullName)) return;
-    // custom transform
-    const resTransform = this._performTransformFn(options, {
+    // filter transform
+    const [transformName, transformOptions] = openapi?.filter?.transform ?? ['a-web:base', undefined];
+    const transformOptions2 = this.bean.onion.filterTransform.getOnionOptionsDynamic(transformName, transformOptions);
+    // execute
+    const beanFullName = beanFullNameFromOnionName(transformName, 'filterTransform');
+    const beanInstance = this.bean._getBean(beanFullName);
+    if (!beanInstance) {
+      throw new Error(`filterTransform bean not found: ${beanFullName}`);
+    }
+    if (!beanInstance.where) {
+      throw new Error(`filterTransform.where not found: ${beanFullName}`);
+    }
+    const info = {
       params,
       query: value,
       options,
@@ -127,82 +141,42 @@ let PipeQuery = (_dec$5 = Pipe({
       fullName,
       key,
       value: fieldValue,
+      type: fieldSchemaInner.type,
       schema: fieldSchema,
       openapi
-    });
-    // res: ignore
-    if (resTransform === false) return;
-    // join
-    if (joinInfo) {
-      if (!params.joins) params.joins = [];
-      if (params.joins.findIndex(item => item[1] === joinInfo.joinTable) === -1) {
-        params.joins.push(joinInfo);
-      }
-    }
-    // res: done
-    if (resTransform === true) return;
-    // default transform
-    let op = openapi?.query?.op;
-    if (!op) {
-      const typeName = fieldSchema.type;
-      if (typeName === 'string') {
-        op = '_includesI_';
-      } else {
-        op = '_eq_';
+    };
+    const resTransform = await beanInstance.where(info, transformOptions2);
+    if (resTransform !== undefined) {
+      // where
+      params.where[fullName] = resTransform;
+      // join
+      if (joinInfo) {
+        if (!params.joins) params.joins = [];
+        if (params.joins.findIndex(item => item[1] === joinInfo.joinTable) === -1) {
+          params.joins.push(joinInfo);
+        }
       }
     }
-    if (op === '_eq_') {
-      params.where[fullName] = fieldValue;
-    } else {
-      params.where[fullName] = {
-        [op]: fieldValue
-      };
-    }
   }
-  _transformFields(params, value, options) {
+  async _transformFields(params, value, options) {
     // loop
     for (const key in value) {
-      this._transformField(key, value[key], params, value, options);
-    }
-    // custom transform
-    this._performTransformFn(options, {
-      params,
-      query: value,
-      options
-    });
-  }
-  _performTransformFn(options, info) {
-    if (options.transformFn) {
-      if (typeof options.transformFn === 'string') {
-        const controller = this.ctx.getControllerBean();
-        if (!controller[options.transformFn]) {
-          throw new Error(`transformFn not found: ${this.ctx.getControllerBeanFullName()}`);
-        }
-        return controller[options.transformFn](info);
-      } else {
-        return options.transformFn(this.ctx, info);
-      }
-    } else {
-      const controller = this.ctx.getControllerBean();
-      const transformFn = `${String(this.ctx.getHandlerName())}QueryTransform`;
-      if (controller[transformFn]) {
-        return controller[transformFn](info);
-      }
+      await this._transformField(key, value[key], params, value, options);
     }
   }
-}) || _class$5) || _class$5);
-const ArgQueryPro$1 = createArgumentPipe('a-web:query');
+}) || _class$8) || _class$8);
+const ArgFilterPro = createArgumentPipe('a-web:filter');
 
-var _dec$4, _dec2$4, _class$4;
-let PipeValid = (_dec$4 = Pipe({
+var _dec$7, _dec2$7, _class$7;
+let PipeValid = (_dec$7 = Pipe({
   // ValidatorOptions
   disableErrorMessages: false,
   errorHttpStatusCode: 400,
   loose: false,
   strict: false
-}), _dec2$4 = BeanInfo({
+}), _dec2$7 = BeanInfo({
   module: "a-web"
-}), _dec$4(_class$4 = _dec2$4(_class$4 = 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
@@ -210,26 +184,56 @@ let PipeValid = (_dec$4 = Pipe({
     }
     return value;
   }
-}) || _class$4) || _class$4);
+}) || _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) {
@@ -282,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
@@ -302,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);
   });
@@ -339,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));
     }
@@ -365,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;
@@ -399,17 +402,28 @@ const SymbolRequestMappingHandler = Symbol('SymbolRequestMappingHandler');
 //   HEAD = 'head',
 // }
 
-var _dec$3, _dec2$3, _class$3;
-const SymbolRouteComposeMiddlewaresCache = Symbol('SymbolRouteComposeMiddlewaresCache');
-let BeanRouter = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
+var _dec$6, _dec2$6, _class$6;
+let BeanRouter = (_dec$6 = Bean(), _dec2$6 = BeanInfo({
   module: "a-web"
-}), _dec$3(_class$3 = _dec2$3(_class$3 = 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;
@@ -420,7 +434,7 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = 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) {
@@ -438,7 +452,7 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = 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;
 
@@ -448,8 +462,8 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = 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);
@@ -461,8 +475,6 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
 
     // route
     const _route = {
-      pid: info.pid,
-      module: info.name,
       controller,
       actionDescriptor: desc,
       controllerBeanFullName,
@@ -474,22 +486,33 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = 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
@@ -500,10 +523,10 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = 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$3) || _class$3);
+  return cacheComposeMiddlewares[key];
+}
 function classControllerMiddleware(ctx) {
   const handlerName = ctx.getHandlerName();
   const controller = ctx.getControllerBean();
@@ -526,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$2, _dec2$2, _class$2;
-let ServiceWeb = (_dec$2 = Service(), _dec2$2 = BeanInfo({
+var _dec$5, _dec2$5, _class$5;
+let ServiceWeb = (_dec$5 = Service(), _dec2$5 = BeanInfo({
   module: "a-web"
-}), _dec$2(_class$2 = _dec2$2(_class$2 = 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);
@@ -594,14 +566,14 @@ let ServiceWeb = (_dec$2 = Service(), _dec2$2 = BeanInfo({
     // combine
     return this.app.util.combineApiPathControllerAndAction(beanOptions.module, controllerPath, actionPath, prefix, simplify);
   }
-}) || _class$2) || _class$2);
+}) || _class$5) || _class$5);
 
-var _dec$1, _dec2$1, _class$1;
-let StartupListen = (_dec$1 = Startup({
+var _dec$4, _dec2$4, _class$4;
+let StartupListen = (_dec$4 = Startup({
   after: true
-}), _dec2$1 = BeanInfo({
+}), _dec2$4 = BeanInfo({
   module: "a-web"
-}), _dec$1(_class$1 = _dec2$1(_class$1 = 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);
@@ -627,6 +599,83 @@ let StartupListen = (_dec$1 = Startup({
       }); // not set instanceName
     };
   }
+}) || _class$4) || _class$4);
+
+function FilterTransform(options) {
+  return createBeanDecorator('filterTransform', options);
+}
+
+var _dec$3, _dec2$3, _class$3;
+let FilterTransformBase = (_dec$3 = FilterTransform(), _dec2$3 = BeanInfo({
+  module: "a-web"
+}), _dec$3(_class$3 = _dec2$3(_class$3 = class FilterTransformBase extends BeanBase {
+  async where(info, _options) {
+    const {
+      value,
+      type,
+      openapi
+    } = info;
+    let op = openapi?.filter?.op;
+    if (!op) {
+      if (type === 'string') {
+        op = '_includesI_';
+      } else {
+        op = '_eq_';
+      }
+    }
+    let where;
+    if (op === '_eq_') {
+      where = value;
+    } else {
+      where = {
+        [op]: value
+      };
+    }
+    return where;
+  }
+}) || _class$3) || _class$3);
+
+var _dec$2, _dec2$2, _class$2;
+let FilterTransformDateRange = (_dec$2 = FilterTransform({
+  separator: '~'
+}), _dec2$2 = BeanInfo({
+  module: "a-web"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class FilterTransformDateRange extends BeanBase {
+  async where(info, options) {
+    const {
+      value
+    } = info;
+    const [dateStartStr, dateEndStr] = value.split(options.separator);
+    if (!dateStartStr && !dateEndStr) return;
+    //
+    const where = {};
+    if (dateStartStr) {
+      const dateStart = DateTime.fromISO(dateStartStr, {
+        zone: this.ctx.tz
+      });
+      where._gte_ = dateStart.toJSDate();
+    }
+    if (dateEndStr) {
+      const dateEnd = DateTime.fromISO(dateEndStr, {
+        zone: this.ctx.tz
+      }).plus({
+        day: 1
+      });
+      where._lt_ = dateEnd.toJSDate();
+    }
+    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) {
@@ -660,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) {
@@ -701,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({
@@ -766,13 +824,12 @@ function File(property, ...schemaLikes) {
 function User(...schemaLikes) {
   return createPipesArgumentDecorator('user')(undefined, ...schemaLikes);
 }
-function ArgQueryPro(schemaLike, transformFn) {
+function ArgFilter(schemaLike) {
   return function (target, prop, index) {
     const schema = $schema(schemaLike);
-    setArgumentPipe('a-web:query', {
+    setArgumentPipe('a-web:filter', {
       type: 'query',
-      schema,
-      transformFn
+      schema
     }, target, prop, index);
   };
 }
@@ -786,7 +843,7 @@ const Arg = {
   files: Files,
   file: File,
   user: User,
-  queryPro: ArgQueryPro
+  filter: ArgFilter
 };
 
 function Controller(path, options) {
@@ -879,11 +936,4 @@ const Web = {
   head: Head
 };
 
-function $apiPath(path) {
-  return path;
-}
-function $apiPathAndCombineParamsAndQuery(path, options) {
-  return combineParamsAndQuery(path, options);
-}
-
-export { $apiPath, $apiPathAndCombineParamsAndQuery, Arg, ArgQueryPro$1 as ArgQueryPro, ArgValid, BeanRouter, Controller, Dto, Main, PipeQuery, 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/decorator/arguments.d.ts

@@ -1,7 +1,6 @@
 import type { Constructable } from 'vona';
 import type { SchemaLike } from 'vona-module-a-openapiutils';
 import type z from 'zod';
-import type { TypePipeOptionsQueryTransform } from '../../bean/pipe.query.ts';
 declare function Param(): ParameterDecorator;
 declare function Param(...schemaLikes: SchemaLike[]): ParameterDecorator;
 declare function Param(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
@@ -27,7 +26,7 @@ declare function File(): ParameterDecorator;
 declare function File(...schemaLikes: SchemaLike[]): ParameterDecorator;
 declare function File(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
 declare function User(...schemaLikes: SchemaLike[]): ParameterDecorator;
-declare function ArgQueryPro(schemaLike: z.ZodType | Constructable, transformFn?: TypePipeOptionsQueryTransform | string): any;
+declare function ArgFilter(schemaLike: z.ZodType | Constructable): any;
 export declare const Arg: {
     param: typeof Param;
     query: typeof Query;
@@ -38,6 +37,6 @@ export declare const Arg: {
     files: typeof Files;
     file: typeof File;
     user: typeof User;
-    queryPro: typeof ArgQueryPro;
+    filter: typeof ArgFilter;
 };
 export {};

package/dist/lib/decorator/filterTransform.d.ts

@@ -0,0 +1,2 @@
+import type { IDecoratorFilterTransformOptions } from '../../types/filterTransform.ts';
+export declare function FilterTransform<T extends IDecoratorFilterTransformOptions>(options?: T): ClassDecorator;

package/dist/lib/decorator/index.d.ts

@@ -1,5 +1,5 @@
 export * from './arguments.ts';
 export * from './bean.ts';
+export * from './filterTransform.ts';
 export * from './pipesArgument.ts';
 export * from './request.ts';
-export * from './response.ts';

package/dist/lib/index.d.ts

@@ -1,2 +1,2 @@
+export * from './const.ts';
 export * from './decorator/index.ts';
-export * from './utils.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/filter.d.ts

@@ -0,0 +1,26 @@
+import type { IModelSelectParamsJoinType, ITableRecord, TypeOpsNormal } from 'vona-module-a-orm';
+import type { IDecoratorFilterTransformOptions, IFilterTransformRecord } from './filterTransform.ts';
+export interface ISchemaObjectExtensionFieldFilterJoin {
+    type?: IModelSelectParamsJoinType;
+    table: keyof ITableRecord;
+    on: [string, string];
+}
+export interface ISchemaObjectExtensionFieldFilterCapabilities {
+    where?: boolean;
+    order?: boolean;
+}
+export type TypeSchemaObjectExtensionFieldFilterTransform = [keyof IFilterTransformRecord, IDecoratorFilterTransformOptions | undefined];
+export interface ISchemaObjectExtensionFieldFilter {
+    capabilities?: ISchemaObjectExtensionFieldFilterCapabilities;
+    table?: keyof ITableRecord;
+    joinType?: IModelSelectParamsJoinType;
+    joinOn?: [string, string];
+    originalName?: string;
+    op?: TypeOpsNormal;
+    transform?: TypeSchemaObjectExtensionFieldFilterTransform;
+}
+declare module 'vona-module-a-openapi' {
+    interface ISchemaObjectExtensionField {
+        filter?: ISchemaObjectExtensionFieldFilter;
+    }
+}

package/dist/types/filterTransform.d.ts

@@ -0,0 +1,41 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+import type { ISchemaObjectExtensionField } from 'vona-module-a-openapi';
+import type { IQueryParams } from 'vona-module-a-orm';
+import type z from 'zod';
+import type { IPipeOptionsFilter } from '../bean/pipe.filter.ts';
+export type TypeQueryParamsPatch = IQueryParams & {
+    where: {};
+};
+export interface IPipeOptionsFilterTransformInfo {
+    params: TypeQueryParamsPatch;
+    query: any;
+    options: IPipeOptionsFilter;
+    originalName: string;
+    fullName: string;
+    key?: string;
+    value?: any;
+    type?: string;
+    schema?: z.ZodType;
+    openapi?: ISchemaObjectExtensionField;
+}
+export interface IFilterTransformRecord {
+}
+export interface IFilterTransformWhere {
+    where(info: IPipeOptionsFilterTransformInfo, options: IDecoratorFilterTransformOptions): Promise<boolean>;
+}
+export interface IDecoratorFilterTransformOptions {
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        filterTransform: ServiceOnion<IFilterTransformRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        filterTransform: OmitNever<IFilterTransformRecord>;
+    }
+    interface IBeanSceneRecord {
+        filterTransform: never;
+    }
+}

package/dist/types/index.d.ts

@@ -1,5 +1,7 @@
 export * from './controller.ts';
 export * from './dto.ts';
+export * from './filter.ts';
+export * from './filterTransform.ts';
 export * from './request.ts';
 export * from './response.ts';
 export * from './router.ts';

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.30",
+  "version": "5.0.32",
   "title": "a-web",
   "vonaModule": {
     "capabilities": {
@@ -22,6 +22,11 @@
         "optionsGlobalInterfaceFrom": "vona-module-a-web",
         "boilerplate": "cli/controller/boilerplate",
         "metadataCustom": "cli/controller/metadata/generate.ts"
+      },
+      "filterTransform": {
+        "optionsGlobalInterfaceName": "IDecoratorFilterTransformOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-web",
+        "boilerplate": "cli/filterTransform/boilerplate"
       }
     }
   },

package/dist/bean/pipe.query.d.ts

@@ -1,37 +0,0 @@
-import type { VonaContext } from 'vona';
-import type { IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, IPipeTransform } from 'vona-module-a-aspect';
-import type { ISchemaObjectExtensionField, RouteHandlerArgumentMeta } from 'vona-module-a-openapi';
-import type { IQueryParams } from 'vona-module-a-orm';
-import type { ValidatorOptions } from 'vona-module-a-validation';
-import type z from 'zod';
-import { BeanBase } from 'vona';
-export type TypePipeQueryData = unknown;
-export type TypePipeQueryResult = TypePipeQueryData;
-export interface IPipeOptionsQuery extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {
-    transformFn?: TypePipeOptionsQueryTransform | string;
-}
-export type TypeQueryParamsPatch = IQueryParams & {
-    where: {};
-};
-export interface IPipeOptionsQueryTransformInfo {
-    params: TypeQueryParamsPatch;
-    query: any;
-    options: IPipeOptionsQuery;
-    originalName: string;
-    fullName: string;
-    key?: string;
-    value?: any;
-    schema?: z.ZodType;
-    openapi?: ISchemaObjectExtensionField;
-}
-export type TypePipeOptionsQueryTransform = (ctx: VonaContext, info: IPipeOptionsQueryTransformInfo) => boolean | undefined;
-export declare class PipeQuery extends BeanBase implements IPipeTransform<TypePipeQueryData, TypePipeQueryResult> {
-    transform(value: TypePipeQueryData, metadata: RouteHandlerArgumentMeta, options: IPipeOptionsQuery): Promise<TypePipeQueryResult>;
-    private _transform;
-    private _transformSystem;
-    private _transformOrders;
-    private _transformField;
-    private _transformFields;
-    private _performTransformFn;
-}
-export declare const ArgQueryPro: (options?: Partial<IPipeOptionsQuery> | undefined) => any;

package/dist/lib/decorator/response.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/utils.d.ts

@@ -1,6 +0,0 @@
-import type { IApiPathRecord } from '../types/controller.ts';
-export declare function $apiPath<K extends keyof IApiPathRecord>(path: K): K;
-export declare function $apiPathAndCombineParamsAndQuery<K extends keyof IApiPathRecord>(path: K, options?: {
-    params?: object;
-    query?: object;
-}): string;