vona-module-a-web 5.0.30 → 5.0.31

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,35 @@ 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 */
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';

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/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 { 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 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$7, _dec2$7, _class$7;
 const __FieldsSystem = ['columns', 'where', 'orders', 'pageNo', 'pageSize'];
-let PipeQuery = (_dec$5 = Pipe({
+let PipeFilter = (_dec$7 = Pipe({
   // ValidatorOptions
   disableErrorMessages: false,
   errorHttpStatusCode: 400,
   loose: false,
   strict: false
-}), _dec2$5 = BeanInfo({
+}), _dec2$7 = BeanInfo({
   module: "a-web"
-}), _dec$5(_class$5 = _dec2$5(_class$5 = class PipeQuery extends BeanBase {
+}), _dec$7(_class$7 = _dec2$7(_class$7 = 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);
+      await 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);
-      }
-    }
-  }
-}) || _class$5) || _class$5);
-const ArgQueryPro$1 = createArgumentPipe('a-web:query');
+}) || _class$7) || _class$7);
+const ArgFilterPro = createArgumentPipe('a-web:filter');
 
-var _dec$4, _dec2$4, _class$4;
-let PipeValid = (_dec$4 = Pipe({
+var _dec$6, _dec2$6, _class$6;
+let PipeValid = (_dec$6 = Pipe({
   // ValidatorOptions
   disableErrorMessages: false,
   errorHttpStatusCode: 400,
   loose: false,
   strict: false
-}), _dec2$4 = BeanInfo({
+}), _dec2$6 = BeanInfo({
   module: "a-web"
-}), _dec$4(_class$4 = _dec2$4(_class$4 = class PipeValid extends BeanBase {
+}), _dec$6(_class$6 = _dec2$6(_class$6 = class PipeValid extends BeanBase {
   async transform(value, metadata, options) {
     if (options.schema) {
       // validateSchema
@@ -210,7 +184,7 @@ let PipeValid = (_dec$4 = Pipe({
     }
     return value;
   }
-}) || _class$4) || _class$4);
+}) || _class$6) || _class$6);
 const ArgValid = createArgumentPipe('a-web:valid');
 
 async function middlewareGuard(ctx, next) {
@@ -399,11 +373,11 @@ const SymbolRequestMappingHandler = Symbol('SymbolRequestMappingHandler');
 //   HEAD = 'head',
 // }
 
-var _dec$3, _dec2$3, _class$3;
+var _dec$5, _dec2$5, _class$5;
 const SymbolRouteComposeMiddlewaresCache = Symbol('SymbolRouteComposeMiddlewaresCache');
-let BeanRouter = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
+let BeanRouter = (_dec$5 = Bean(), _dec2$5 = BeanInfo({
   module: "a-web"
-}), _dec$3(_class$3 = _dec2$3(_class$3 = class BeanRouter extends BeanBase {
+}), _dec$5(_class$5 = _dec2$5(_class$5 = class BeanRouter extends BeanBase {
   registerController(moduleName, controller) {
     // info
     const info = ModuleInfo.parseInfo(moduleName);
@@ -503,7 +477,7 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
     // compose
     return this.app.bean.onion.middleware.compose(ctx, fnStart, fnMid, fnEnd);
   }
-}) || _class$3) || _class$3);
+}) || _class$5) || _class$5);
 function classControllerMiddleware(ctx) {
   const handlerName = ctx.getHandlerName();
   const controller = ctx.getControllerBean();
@@ -577,10 +551,10 @@ async function routeTailDoneMiddleware(ctx, next) {
 //   }
 // }
 
-var _dec$2, _dec2$2, _class$2;
-let ServiceWeb = (_dec$2 = Service(), _dec2$2 = BeanInfo({
+var _dec$4, _dec2$4, _class$4;
+let ServiceWeb = (_dec$4 = Service(), _dec2$4 = BeanInfo({
   module: "a-web"
-}), _dec$2(_class$2 = _dec2$2(_class$2 = class ServiceWeb extends BeanBase {
+}), _dec$4(_class$4 = _dec2$4(_class$4 = class ServiceWeb extends BeanBase {
   combineControllerActionApiPath(controller, actionKey, prefix, simplify) {
     // beanOptions
     const beanOptions = appResource.getBean(controller);
@@ -594,14 +568,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$4) || _class$4);
 
-var _dec$1, _dec2$1, _class$1;
-let StartupListen = (_dec$1 = Startup({
+var _dec$3, _dec2$3, _class$3;
+let StartupListen = (_dec$3 = Startup({
   after: true
-}), _dec2$1 = BeanInfo({
+}), _dec2$3 = BeanInfo({
   module: "a-web"
-}), _dec$1(_class$1 = _dec2$1(_class$1 = class StartupListen extends BeanBase {
+}), _dec$3(_class$3 = _dec2$3(_class$3 = 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 +601,72 @@ let StartupListen = (_dec$1 = Startup({
       }); // not set instanceName
     };
   }
+}) || _class$3) || _class$3);
+
+function FilterTransform(options) {
+  return createBeanDecorator('filterTransform', options);
+}
+
+var _dec$2, _dec2$2, _class$2;
+let FilterTransformBase = (_dec$2 = FilterTransform(), _dec2$2 = BeanInfo({
+  module: "a-web"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = 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$2) || _class$2);
+
+var _dec$1, _dec2$1, _class$1;
+let FilterTransformDateRange = (_dec$1 = FilterTransform({
+  separator: '~'
+}), _dec2$1 = BeanInfo({
+  module: "a-web"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = 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$1) || _class$1);
 
 function config(_app) {
@@ -766,13 +806,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 +825,7 @@ const Arg = {
   files: Files,
   file: File,
   user: User,
-  queryPro: ArgQueryPro
+  filter: ArgFilter
 };
 
 function Controller(path, options) {
@@ -879,11 +918,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, Main, PipeFilter, PipeValid, RequestMapping, ScopeModuleAWeb, ServiceWeb, StartupListen, SymbolRequestMappingHandler, Web, config, createPipesArgumentDecorator, mergeActionsOpenapiMetadata };

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 @@
 export * from './decorator/index.ts';
-export * from './utils.ts';

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-web",
   "type": "module",
-  "version": "5.0.30",
+  "version": "5.0.31",
   "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;