vona-module-test-vona 5.0.52 → 5.0.54

package/dist/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './serializer.ts';

package/dist/lib/serializer.d.ts

@@ -0,0 +1 @@
+export declare function SensitiveEmail(): PropertyDecorator;

package/dist/service/post.d.ts

@@ -50,11 +50,11 @@ export declare class ServicePost extends BeanBase {
             postContent: "testVonaPostContent";
             user: "testVonaUser";
         }>, import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelPost> | import("vona").TypeRecordValues<{
-            postContent: "testVonaPostContent.id" | "testVonaPostContent.content" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
+            postContent: "testVonaPostContent.content" | "testVonaPostContent.id" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
             user: "testVonaUser.name" | "testVonaUser.id" | "testVonaUser.iid" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.age" | "testVonaUser.scores";
         }>>[] | undefined;
         orders?: import("vona-module-a-orm").IModelSelectParamsOrder<import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelPost> | import("vona").TypeRecordValues<{
-            postContent: "testVonaPostContent.id" | "testVonaPostContent.content" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
+            postContent: "testVonaPostContent.content" | "testVonaPostContent.id" | "testVonaPostContent.iid" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.postId";
             user: "testVonaUser.name" | "testVonaUser.id" | "testVonaUser.iid" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.age" | "testVonaUser.scores";
         }>>[] | undefined;
         limit?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-test-vona",
   "type": "module",
-  "version": "5.0.52",
+  "version": "5.0.54",
   "title": "test-vona",
   "vonaModule": {
     "fileVersion": 1,

package/src/.metadata/index.ts

@@ -451,7 +451,7 @@ import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'von
 declare module 'vona-module-test-vona' {
   export interface IModelOptionsCategory {
         relations: {
-          children: IModelRelationHasMany<ModelCategory, true, 'id'|'name',undefined,undefined,undefined>;
+          children: IModelRelationHasMany<ModelCategory, 'categoryIdParent', true, 'id'|'name', undefined, undefined, undefined>;
         };
       }
 export interface IModelOptionsCategoryChain {
@@ -462,24 +462,24 @@ export interface IModelOptionsCategoryChain {
 export interface IModelOptionsOrder {
         relations: {
           user: IModelRelationBelongsTo<ModelOrder, ModelUser, true, 'id'|'name'>;
-products: IModelRelationHasMany<ModelProduct, true, 'id'|'name'|'price'|'quantity'|'amount',undefined,undefined,undefined>;
+products: IModelRelationHasMany<ModelProduct, 'orderId', true, 'id'|'name'|'price'|'quantity'|'amount', undefined, undefined, undefined>;
         };
       }
 export interface IModelOptionsOrderStats {
         relations: {
-          productStats: IModelRelationHasMany<ModelProduct, true, '*',undefined,{ count?: '*' | Array<'*'>;sum?: 'amount' | Array<'amount'> },undefined>;
-productsGroups: IModelRelationHasMany<ModelProduct, false, undefined,undefined,{ count?: '*' | Array<'*'>;sum?: 'amount' | Array<'amount'> },'id' | Array<'id'>>;
+          productStats: IModelRelationHasMany<ModelProduct, 'orderId', true, undefined, undefined, { count?: '*' | Array<'*'>;sum?: 'amount' | Array<'amount'> }, undefined>;
+productsGroups: IModelRelationHasMany<ModelProduct, 'orderId', false, undefined, undefined, { count?: '*' | Array<'*'>;sum?: 'amount' | Array<'amount'> }, 'id' | Array<'id'>>;
         };
       }
 export interface IModelOptionsPost {
         relations: {
-          postContent: IModelRelationHasOne<ModelPostContent, false, 'id'|'content'>;
+          postContent: IModelRelationHasOne<ModelPostContent, 'postId', false, 'id'|'content'>;
 user: IModelRelationBelongsTo<ModelPost, ModelUser, true, 'id'|'name'>;
         };
       }
 export interface IModelOptionsPostContent {
         relations: {
-          post: IModelRelationBelongsTo<ModelPostContent, ModelPost, false, '*'>;
+          post: IModelRelationBelongsTo<ModelPostContent, ModelPost, false, undefined>;
         };
       }
 export interface IModelOptionsRole {
@@ -489,19 +489,19 @@ export interface IModelOptionsRole {
       }
 export interface IModelOptionsUser {
         relations: {
-          posts: IModelRelationHasMany<ModelPost, false, 'id'|'title',['test-vona:user',ModelPostContent],undefined,undefined>;
+          posts: IModelRelationHasMany<ModelPost, 'userId', false, 'id'|'title', ['test-vona:user',ModelPostContent], undefined, undefined>;
 roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, 'id'|'name',undefined,undefined,undefined>;
         };
       }
 export interface IModelOptionsUserStats {
         relations: {
-          posts: IModelRelationHasMany<ModelPost, true, '*',undefined,{ count?: '*'|'title' | Array<'*'|'title'>;sum?: 'stars' | Array<'stars'> },undefined>;
-roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, '*',undefined,{ count?: '*' | Array<'*'> },undefined>;
+          posts: IModelRelationHasMany<ModelPost, 'userId', true, undefined, undefined, { count?: '*'|'title' | Array<'*'|'title'>;sum?: 'stars' | Array<'stars'> }, undefined>;
+roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, undefined,undefined,{ count?: '*' | Array<'*'> },undefined>;
         };
       }
 export interface IModelOptionsUserStatsGroup {
         relations: {
-          posts: IModelRelationHasMany<ModelPost, true, undefined,undefined,{ count?: '*'|'title' | Array<'*'|'title'>;sum?: 'stars' | Array<'stars'> },'title' | Array<'title'>>;
+          posts: IModelRelationHasMany<ModelPost, 'userId', true, undefined, undefined, { count?: '*'|'title' | Array<'*'|'title'>;sum?: 'stars' | Array<'stars'> }, 'title' | Array<'title'>>;
 roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false, undefined,undefined,{ count?: '*' | Array<'*'> },'name' | Array<'name'>>;
         };
       }
@@ -1296,6 +1296,31 @@ declare module 'vona-module-test-vona' {
           } 
 }
 /** schedule: end */
+/** serializerTransform: begin */
+export * from '../bean/serializerTransform.email.ts';
+import type { ISerializerTransformOptionsEmail } from '../bean/serializerTransform.email.ts';
+import 'vona';
+declare module 'vona-module-a-serialization' {
+  
+    export interface ISerializerTransformRecord {
+      'test-vona:email': ISerializerTransformOptionsEmail;
+    }
+
+  
+}
+declare module 'vona-module-test-vona' {
+  
+        export interface SerializerTransformEmail {
+          /** @internal */
+          get scope(): ScopeModuleTestVona;
+        }
+
+          export interface SerializerTransformEmail {
+            get $beanFullName(): 'test-vona.serializerTransform.email';
+            get $onionName(): 'test-vona:email';
+          } 
+}
+/** serializerTransform: end */
 /** summerCache: begin */
 export * from '../bean/summerCache.test.ts';
 
@@ -1335,11 +1360,16 @@ export * from '../dto/orderQueryPage.ts';
 export * from '../dto/orderResult.ts';
 export * from '../dto/orderResultPage.ts';
 export * from '../dto/orderUpdate.ts';
+export * from '../dto/postAggregate.ts';
 export * from '../dto/postCreate.ts';
+export * from '../dto/postGroup.ts';
 export * from '../dto/postQuery.ts';
 export * from '../dto/postQueryRes.ts';
 export * from '../dto/profile.ts';
 export * from '../dto/roleLazy.ts';
+export * from '../dto/serializerArray.ts';
+export * from '../dto/serializerLazy.ts';
+export * from '../dto/serializerSimple.ts';
 export * from '../dto/signin.ts';
 export * from '../dto/user.ts';
 export * from '../dto/userCreate.ts';
@@ -1352,11 +1382,16 @@ import type { IDtoOptionsOrderQueryPage } from '../dto/orderQueryPage.ts';
 import type { IDtoOptionsOrderResult } from '../dto/orderResult.ts';
 import type { IDtoOptionsOrderResultPage } from '../dto/orderResultPage.ts';
 import type { IDtoOptionsOrderUpdate } from '../dto/orderUpdate.ts';
+import type { IDtoOptionsPostAggregate } from '../dto/postAggregate.ts';
 import type { IDtoOptionsPostCreate } from '../dto/postCreate.ts';
+import type { IDtoOptionsPostGroup } from '../dto/postGroup.ts';
 import type { IDtoOptionsPostQuery } from '../dto/postQuery.ts';
 import type { IDtoOptionsPostQueryRes } from '../dto/postQueryRes.ts';
 import type { IDtoOptionsProfile } from '../dto/profile.ts';
 import type { IDtoOptionsRoleLazy } from '../dto/roleLazy.ts';
+import type { IDtoOptionsSerializerArray } from '../dto/serializerArray.ts';
+import type { IDtoOptionsSerializerLazy } from '../dto/serializerLazy.ts';
+import type { IDtoOptionsSerializerSimple } from '../dto/serializerSimple.ts';
 import type { IDtoOptionsSignin } from '../dto/signin.ts';
 import type { IDtoOptionsUser } from '../dto/user.ts';
 import type { IDtoOptionsUserCreate } from '../dto/userCreate.ts';
@@ -1373,11 +1408,16 @@ declare module 'vona-module-a-web' {
 'test-vona:orderResult': IDtoOptionsOrderResult;
 'test-vona:orderResultPage': IDtoOptionsOrderResultPage;
 'test-vona:orderUpdate': IDtoOptionsOrderUpdate;
+'test-vona:postAggregate': IDtoOptionsPostAggregate;
 'test-vona:postCreate': IDtoOptionsPostCreate;
+'test-vona:postGroup': IDtoOptionsPostGroup;
 'test-vona:postQuery': IDtoOptionsPostQuery;
 'test-vona:postQueryRes': IDtoOptionsPostQueryRes;
 'test-vona:profile': IDtoOptionsProfile;
 'test-vona:roleLazy': IDtoOptionsRoleLazy;
+'test-vona:serializerArray': IDtoOptionsSerializerArray;
+'test-vona:serializerLazy': IDtoOptionsSerializerLazy;
+'test-vona:serializerSimple': IDtoOptionsSerializerSimple;
 'test-vona:signin': IDtoOptionsSignin;
 'test-vona:user': IDtoOptionsUser;
 'test-vona:userCreate': IDtoOptionsUserCreate;
@@ -1399,11 +1439,16 @@ import type { DtoOrderQueryPage } from '../dto/orderQueryPage.ts';
 import type { DtoOrderResult } from '../dto/orderResult.ts';
 import type { DtoOrderResultPage } from '../dto/orderResultPage.ts';
 import type { DtoOrderUpdate } from '../dto/orderUpdate.ts';
+import type { DtoPostAggregate } from '../dto/postAggregate.ts';
 import type { DtoPostCreate } from '../dto/postCreate.ts';
+import type { DtoPostGroup } from '../dto/postGroup.ts';
 import type { DtoPostQuery } from '../dto/postQuery.ts';
 import type { DtoPostQueryRes } from '../dto/postQueryRes.ts';
 import type { DtoProfile } from '../dto/profile.ts';
 import type { DtoRoleLazy } from '../dto/roleLazy.ts';
+import type { DtoSerializerArray } from '../dto/serializerArray.ts';
+import type { DtoSerializerLazy } from '../dto/serializerLazy.ts';
+import type { DtoSerializerSimple } from '../dto/serializerSimple.ts';
 import type { DtoSignin } from '../dto/signin.ts';
 import type { DtoUser } from '../dto/user.ts';
 import type { DtoUserCreate } from '../dto/userCreate.ts';
@@ -1439,10 +1484,18 @@ declare module 'vona-module-test-vona' {
       fields?: TypeEntityOptionsFields<DtoOrderUpdate, IDtoOptionsOrderUpdate[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsPostAggregate {
+      fields?: TypeEntityOptionsFields<DtoPostAggregate, IDtoOptionsPostAggregate[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsPostCreate {
       fields?: TypeEntityOptionsFields<DtoPostCreate, IDtoOptionsPostCreate[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsPostGroup {
+      fields?: TypeEntityOptionsFields<DtoPostGroup, IDtoOptionsPostGroup[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsPostQuery {
       fields?: TypeEntityOptionsFields<DtoPostQuery, IDtoOptionsPostQuery[TypeSymbolKeyFieldsMore]>;
     }
@@ -1459,6 +1512,18 @@ declare module 'vona-module-test-vona' {
       fields?: TypeEntityOptionsFields<DtoRoleLazy, IDtoOptionsRoleLazy[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsSerializerArray {
+      fields?: TypeEntityOptionsFields<DtoSerializerArray, IDtoOptionsSerializerArray[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsSerializerLazy {
+      fields?: TypeEntityOptionsFields<DtoSerializerLazy, IDtoOptionsSerializerLazy[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsSerializerSimple {
+      fields?: TypeEntityOptionsFields<DtoSerializerSimple, IDtoOptionsSerializerSimple[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsSignin {
       fields?: TypeEntityOptionsFields<DtoSignin, IDtoOptionsSignin[TypeSymbolKeyFieldsMore]>;
     }
@@ -1493,6 +1558,7 @@ export * from '../controller/passport.ts';
 export * from '../controller/performAction.ts';
 export * from '../controller/post.ts';
 export * from '../controller/queue.ts';
+export * from '../controller/serializer.ts';
 export * from '../controller/summer.ts';
 export * from '../controller/tail.ts';
 export * from '../controller/transaction.ts';
@@ -1509,6 +1575,7 @@ import type { IControllerOptionsPassport } from '../controller/passport.ts';
 import type { IControllerOptionsPerformAction } from '../controller/performAction.ts';
 import type { IControllerOptionsPost } from '../controller/post.ts';
 import type { IControllerOptionsQueue } from '../controller/queue.ts';
+import type { IControllerOptionsSerializer } from '../controller/serializer.ts';
 import type { IControllerOptionsSummer } from '../controller/summer.ts';
 import type { IControllerOptionsTail } from '../controller/tail.ts';
 import type { IControllerOptionsTransaction } from '../controller/transaction.ts';
@@ -1529,6 +1596,7 @@ declare module 'vona-module-a-web' {
 'test-vona:performAction': IControllerOptionsPerformAction;
 'test-vona:post': IControllerOptionsPost;
 'test-vona:queue': IControllerOptionsQueue;
+'test-vona:serializer': IControllerOptionsSerializer;
 'test-vona:summer': IControllerOptionsSummer;
 'test-vona:tail': IControllerOptionsTail;
 'test-vona:transaction': IControllerOptionsTransaction;
@@ -1659,6 +1727,16 @@ declare module 'vona-module-test-vona' {
             get $onionName(): 'test-vona:queue';
           }
 
+        export interface ControllerSerializer {
+          /** @internal */
+          get scope(): ScopeModuleTestVona;
+        }
+
+          export interface ControllerSerializer {
+            get $beanFullName(): 'test-vona.controller.serializer';
+            get $onionName(): 'test-vona:serializer';
+          }
+
         export interface ControllerSummer {
           /** @internal */
           get scope(): ScopeModuleTestVona;
@@ -1726,6 +1804,8 @@ import type { ControllerPost } from '../controller/post.ts';
 // @ts-ignore ignore
 import type { ControllerQueue } from '../controller/queue.ts';
 // @ts-ignore ignore
+import type { ControllerSerializer } from '../controller/serializer.ts';
+// @ts-ignore ignore
 import type { ControllerSummer } from '../controller/summer.ts';
 // @ts-ignore ignore
 import type { ControllerTail } from '../controller/tail.ts';
@@ -1783,6 +1863,10 @@ declare module 'vona-module-test-vona' {
       actions?: TypeControllerOptionsActions<ControllerQueue>;
     }
 
+    export interface IControllerOptionsSerializer {
+      actions?: TypeControllerOptionsActions<ControllerSerializer>;
+    }
+
     export interface IControllerOptionsSummer {
       actions?: TypeControllerOptionsActions<ControllerSummer>;
     }
@@ -1821,6 +1905,8 @@ declare module 'vona-module-a-web' {
 '/test/vona/order/findMany': undefined;
 '/test/vona/passport/echo/:name': undefined;
 '/test/vona/passport/isAuthenticated': undefined;
+'/test/vona/post/group': undefined;
+'/test/vona/post/aggregate': undefined;
 '/test/vona/post/findManyEcho': undefined;
 '/test/vona/post/findMany': undefined;
     }
@@ -1833,12 +1919,16 @@ export interface IApiPathPostRecord{
 '/test/vona/onion/echo2/:userId/:userName': undefined;
 '/test/vona/onion/echo4': undefined;
 '/test/vona/order/create': undefined;
+'/test/vona/order/update/:id': undefined;
 '/test/vona/passport/login': undefined;
 '/test/vona/passport/refresh': undefined;
 '/test/vona/passport/logout': undefined;
 '/test/vona/performAction/echo': undefined;
 '/test/vona/queue/pushAsync': undefined;
 '/test/vona/queue/push': undefined;
+'/test/vona/serializer/echoSimple': undefined;
+'/test/vona/serializer/echoArray': undefined;
+'/test/vona/serializer/echoLazy': undefined;
 '/test/vona/summer': undefined;
 '/test/vona/tail': undefined;
 '/test/vona/transaction/fail': undefined;

package/src/bean/serializerTransform.email.ts

@@ -0,0 +1,28 @@
+import type { IDecoratorSerializerTransformOptions, ISerializerTransform } from 'vona-module-a-serialization';
+import { BeanBase } from 'vona';
+import { SerializerTransform } from 'vona-module-a-serialization';
+
+export type TypeSerializerTransformEmailValue = string | undefined;
+
+export type TypeSerializerTransformEmailData = unknown;
+
+export type TypeSerializerTransformEmailResult = TypeSerializerTransformEmailValue;
+
+export interface ISerializerTransformOptionsEmail extends IDecoratorSerializerTransformOptions {}
+
+@SerializerTransform<ISerializerTransformOptionsEmail>()
+export class SerializerTransformEmail extends BeanBase
+  implements ISerializerTransform<
+    TypeSerializerTransformEmailValue,
+    TypeSerializerTransformEmailData,
+    TypeSerializerTransformEmailResult
+  > {
+  async transform(
+    value: TypeSerializerTransformEmailValue,
+    _data: TypeSerializerTransformEmailData,
+    _options: ISerializerTransformOptionsEmail,
+  ): Promise<TypeSerializerTransformEmailResult> {
+    // eslint-disable-next-line
+    return value?.replace(/(\w?)(\w+)(\w)(@\w+\.[a-z]+)/, '$1****$3$4');
+  }
+}

package/src/controller/order.ts

@@ -1,3 +1,4 @@
+import type { TableIdentity } from 'table-identity';
 import type { VonaContext } from 'vona';
 import type { IQueryParams } from 'vona-module-a-orm';
 import type { IDecoratorControllerOptions, IPipeOptionsQueryTransformInfo } from 'vona-module-a-web';
@@ -10,6 +11,7 @@ import { DtoOrderQuery } from '../dto/orderQuery.ts';
 import { DtoOrderQueryPage } from '../dto/orderQueryPage.ts';
 import { DtoOrderResult } from '../dto/orderResult.ts';
 import { DtoOrderResultPage } from '../dto/orderResultPage.ts';
+import { DtoOrderUpdate } from '../dto/orderUpdate.ts';
 
 export interface IControllerOptionsOrder extends IDecoratorControllerOptions {}
 
@@ -25,10 +27,18 @@ function myCustomQueryTransform(_ctx: VonaContext, info: IPipeOptionsQueryTransf
 export class ControllerOrder extends BeanBase {
   @Web.post('create')
   @Api.body(DtoOrderResult)
-  async create(@Arg.body(DtoOrderCreate) data: DtoOrderCreate) {
+  async create(@Arg.body() data: DtoOrderCreate) {
     return await this.scope.model.order.insert(data);
   }
 
+  @Web.post('update/:id')
+  async update(@Arg.param('id') id: TableIdentity, @Arg.body() data: DtoOrderUpdate) {
+    return await this.scope.model.order.update({
+      ...data,
+      id,
+    });
+  }
+
   @Web.get('findAll')
   @Api.body(v.array(DtoOrderResult))
   async findAll(
@@ -46,7 +56,7 @@ export class ControllerOrder extends BeanBase {
   @Api.body(DtoOrderResultPage)
   async findMany(
     @Arg.queryPro(DtoOrderQueryPage) params: IQueryParams<ModelOrder>,
-  ): Promise<DtoOrderResultPage> {
+  ) {
     return this.scope.model.order.selectAndCount({
       ...params,
       include: {

package/src/controller/post.ts

@@ -2,9 +2,11 @@ import type { IQueryParams } from 'vona-module-a-orm';
 import type { IDecoratorControllerOptions, IPipeOptionsQueryTransformInfo } from 'vona-module-a-web';
 import type { ModelPost } from '../model/post.ts';
 import { BeanBase } from 'vona';
-import { Api } from 'vona-module-a-openapi';
+import { Api, v } from 'vona-module-a-openapi';
 import { Passport } from 'vona-module-a-user';
 import { Arg, Controller, Web } from 'vona-module-a-web';
+import { DtoPostAggregate } from '../dto/postAggregate.ts';
+import { DtoPostGroup } from '../dto/postGroup.ts';
 import { DtoPostQuery } from '../dto/postQuery.ts';
 import { DtoPostQueryRes } from '../dto/postQueryRes.ts';
 
@@ -12,6 +14,32 @@ export interface IControllerOptionsPost extends IDecoratorControllerOptions {}
 
 @Controller<IControllerOptionsPost>('post', { meta: { mode: ['test', 'dev'] } })
 export class ControllerPost extends BeanBase {
+  @Web.get('group')
+  @Api.body(v.array(DtoPostGroup))
+  async group(): Promise<DtoPostGroup[]> {
+    return await this.scope.model.post.group({
+      groups: 'userId',
+      aggrs: {
+        count: '*',
+        sum: 'stars',
+      },
+    });
+  }
+
+  @Web.get('aggregate')
+  @Api.body(DtoPostAggregate)
+  async aggregate(): Promise<DtoPostAggregate> {
+    return await this.scope.model.post.aggregate({
+      aggrs: {
+        count: ['*', 'stars'],
+        sum: 'stars',
+        avg: 'stars',
+        min: 'stars',
+        max: 'stars',
+      },
+    });
+  }
+
   @Web.get('findManyEcho')
   @Api.body(DtoPostQueryRes)
   @Passport.public()

package/src/controller/serializer.ts

@@ -0,0 +1,34 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { Api, v } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+import { DtoSerializerArray } from '../dto/serializerArray.ts';
+import { DtoSerializerLazy } from '../dto/serializerLazy.ts';
+import { DtoSerializerSimple } from '../dto/serializerSimple.ts';
+
+export interface IControllerOptionsSerializer extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsSerializer>({ path: 'serializer', meta: { mode: ['test', 'dev'] } })
+export class ControllerSerializer extends BeanBase {
+  @Web.post('echoSimple')
+  @Api.body(DtoSerializerSimple)
+  @Passport.public()
+  echoSimple(@Arg.body() data: DtoSerializerSimple) {
+    return data;
+  }
+
+  @Web.post('echoArray')
+  @Api.body(v.array(DtoSerializerArray))
+  @Passport.public()
+  echoArray(@Arg.body(v.array(DtoSerializerArray)) data: DtoSerializerArray[]) {
+    return data;
+  }
+
+  @Web.post('echoLazy')
+  @Api.body(DtoSerializerLazy)
+  @Passport.public()
+  echoLazy(@Arg.body(DtoSerializerLazy) data: DtoSerializerLazy) {
+    return data;
+  }
+}

package/src/dto/orderCreate.ts

@@ -6,5 +6,4 @@ import { ModelOrder } from '../model/order.ts';
 export interface IDtoOptionsOrderCreate extends IDecoratorDtoOptions {}
 
 @Dto<IDtoOptionsOrderCreate>()
-export class DtoOrderCreate
-  extends $Dto.create(() => ModelOrder, { columns: ['orderNo', 'remark'] }) {}
+export class DtoOrderCreate extends $Dto.create(() => ModelOrder, { columns: ['orderNo', 'remark'] }) {}

package/src/dto/postAggregate.ts

@@ -0,0 +1,16 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ModelPost } from '../model/post.ts';
+
+export interface IDtoOptionsPostAggregate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPostAggregate>()
+export class DtoPostAggregate
+  extends $Dto.aggregate(() => ModelPost, {
+    count: ['*', 'stars'],
+    sum: 'stars',
+    avg: 'stars',
+    min: 'stars',
+    max: 'stars',
+  }) {}

package/src/dto/postGroup.ts

@@ -0,0 +1,13 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ModelPost } from '../model/post.ts';
+
+export interface IDtoOptionsPostGroup extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPostGroup>()
+export class DtoPostGroup
+  extends $Dto.group(() => ModelPost, 'userId', {
+    count: '*',
+    sum: 'stars',
+  }) {}

package/src/dto/serializerArray.ts

@@ -0,0 +1,29 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+import { DtoSerializerSimple } from './serializerSimple.ts';
+
+export interface IDtoOptionsSerializerArray extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsSerializerArray>()
+export class DtoSerializerArray {
+  @Api.field(v.serializerGetter((value: DtoSerializerSimple[], _data: DtoSerializerArray) => {
+    return value.map(item => {
+      return {
+        ...item,
+        password: '111111',
+      };
+    });
+  }), v.title('Simple'), v.array(DtoSerializerSimple))
+  simples: DtoSerializerSimple[];
+
+  @Api.field(v.serializerGetter((value: DtoSerializerSimple[], _data: DtoSerializerArray) => {
+    return value.map(item => {
+      return {
+        ...item,
+        password: '111111',
+      };
+    });
+  }), v.title('Simple'), v.array(v.lazy(() => DtoSerializerSimple)))
+  simplesLazy: DtoSerializerSimple[];
+}

package/src/dto/serializerLazy.ts

@@ -0,0 +1,32 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+import { DtoSerializerSimple } from './serializerSimple.ts';
+
+export interface IDtoOptionsSerializerLazy extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsSerializerLazy>()
+export class DtoSerializerLazy {
+  @Api.field(
+    v.serializerGetter((value: DtoSerializerSimple) => {
+      return { ...value, password: '111111' };
+    }),
+    v.object(DtoSerializerSimple),
+  )
+  simple: DtoSerializerSimple;
+
+  @Api.field(
+    v.serializerGetter((value: DtoSerializerSimple) => {
+      return { ...value, password: '111111' };
+    }),
+    v.title('title'),
+    v.optional(),
+    v.lazy(
+      v.description('description'),
+      () => {
+        return DtoSerializerSimple;
+      },
+    ),
+  )
+  simpleLazy: DtoSerializerSimple;
+}