vona-module-test-vona 5.0.53 → 5.0.55

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.53",
+  "version": "5.0.55",
   "title": "test-vona",
   "vonaModule": {
     "fileVersion": 1,

package/src/.metadata/index.ts

@@ -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,12 +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/serializerTest.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';
@@ -1353,12 +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 { IDtoOptionsSerializerTest } from '../dto/serializerTest.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';
@@ -1375,12 +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:serializerTest': IDtoOptionsSerializerTest;
+'test-vona:serializerArray': IDtoOptionsSerializerArray;
+'test-vona:serializerLazy': IDtoOptionsSerializerLazy;
+'test-vona:serializerSimple': IDtoOptionsSerializerSimple;
 'test-vona:signin': IDtoOptionsSignin;
 'test-vona:user': IDtoOptionsUser;
 'test-vona:userCreate': IDtoOptionsUserCreate;
@@ -1402,12 +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 { DtoSerializerTest } from '../dto/serializerTest.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';
@@ -1443,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]>;
     }
@@ -1463,8 +1512,16 @@ declare module 'vona-module-test-vona' {
       fields?: TypeEntityOptionsFields<DtoRoleLazy, IDtoOptionsRoleLazy[TypeSymbolKeyFieldsMore]>;
     }
 
-    export interface IDtoOptionsSerializerTest {
-      fields?: TypeEntityOptionsFields<DtoSerializerTest, IDtoOptionsSerializerTest[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 {
@@ -1501,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';
@@ -1517,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';
@@ -1537,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;
@@ -1667,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;
@@ -1734,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';
@@ -1791,6 +1863,10 @@ declare module 'vona-module-test-vona' {
       actions?: TypeControllerOptionsActions<ControllerQueue>;
     }
 
+    export interface IControllerOptionsSerializer {
+      actions?: TypeControllerOptionsActions<ControllerSerializer>;
+    }
+
     export interface IControllerOptionsSummer {
       actions?: TypeControllerOptionsActions<ControllerSummer>;
     }
@@ -1829,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;
     }
@@ -1848,6 +1926,9 @@ export interface IApiPathPostRecord{
 '/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/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,38 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { Api, v } from 'vona-module-a-openapi';
+import { Serializer } from 'vona-module-a-serialization';
+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()
+  @Serializer.enable()
+  echoSimple(@Arg.body() data: DtoSerializerSimple) {
+    return data;
+  }
+
+  @Web.post('echoArray')
+  @Api.body(v.array(DtoSerializerArray))
+  @Passport.public()
+  @Serializer.enable()
+  echoArray(@Arg.body(v.array(DtoSerializerArray)) data: DtoSerializerArray[]) {
+    return data;
+  }
+
+  @Web.post('echoLazy')
+  @Api.body(DtoSerializerLazy)
+  @Passport.public()
+  @Serializer.enable()
+  echoLazy(@Arg.body(DtoSerializerLazy) data: DtoSerializerLazy) {
+    return data;
+  }
+}

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;
+}

package/src/dto/serializerSimple.ts

@@ -0,0 +1,98 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { Serializer } from 'vona-module-a-serialization';
+import { Dto } from 'vona-module-a-web';
+import { SensitiveEmail } from '../lib/serializer.ts';
+
+export interface IDtoOptionsSerializerSimple extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsSerializerSimple>()
+export class DtoSerializerSimple {
+  @Serializer.exclude()
+  @Api.field(v.min(6))
+  password: string;
+
+  @Api.field(v.serializerExclude(), v.min(6))
+  password2: string;
+
+  @Serializer.transform('test-vona:email')
+  email: string;
+
+  @Serializer.transform(
+    'a-serialization:sensitive',
+    {
+      // eslint-disable-next-line
+      patternFrom: /(\w?)(\w+)(\w)(@\w+\.[a-z]+)/,
+      patternTo: '$1****$3$4',
+    },
+  )
+  @Api.field(v.email())
+  email2: string;
+
+  @Serializer.sensitive({
+    // eslint-disable-next-line
+    patternFrom: /(\w?)(\w+)(\w)(@\w+\.[a-z]+)/,
+    patternTo: '$1****$3$4',
+  })
+  @Api.field(v.email())
+  email3: string;
+
+  @SensitiveEmail()
+  email4: string;
+
+  @Api.field(
+    v.openapi({
+      serializerTransforms: {
+        'a-serialization:sensitive': {
+          // eslint-disable-next-line
+          patternFrom: /(\w?)(\w+)(\w)(@\w+\.[a-z]+)/,
+          patternTo: '$1****$3$4',
+        },
+      },
+    }),
+    v.email(),
+  )
+  email5: string;
+
+  @Api.field(
+    v.serializerTransform('a-serialization:sensitive', {
+      // eslint-disable-next-line
+      patternFrom: /(\w?)(\w+)(\w)(@\w+\.[a-z]+)/,
+      patternTo: '$1****$3$4',
+    }),
+    v.email(),
+  )
+  email6: string;
+
+  @Api.field(
+    v.serializerSensitive({
+      // eslint-disable-next-line
+      patternFrom: /(\w?)(\w+)(\w)(@\w+\.[a-z]+)/,
+      patternTo: '$1****$3$4',
+    }),
+    v.email(),
+  )
+  email7: string;
+
+  @Api.field()
+  firstName: string;
+
+  @Api.field()
+  lastName: string;
+
+  @Serializer.getter(function (this: DtoSerializerSimple) {
+    return `${this.firstName} ${this.lastName}`;
+  })
+  @Api.field(v.optional())
+  fullName: string;
+
+  @Api.field(v.serializerGetter(function (this: DtoSerializerSimple) {
+    return `${this.firstName} ${this.lastName}`;
+  }), v.optional())
+  fullName2: string;
+
+  @Api.field(v.optional())
+  get fullName3(): string {
+    return `${this.firstName} ${this.lastName}`;
+  }
+}

package/src/index.ts

@@ -1 +1,2 @@
 export * from './.metadata/index.ts';
+export * from './lib/index.ts';

package/src/lib/index.ts

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

package/src/lib/serializer.ts

@@ -0,0 +1,9 @@
+import { Serializer } from 'vona-module-a-serialization';
+
+export function SensitiveEmail(): PropertyDecorator {
+  return Serializer.sensitive({
+    // eslint-disable-next-line
+    patternFrom: /(\w?)(\w+)(\w)(@\w+\.[a-z]+)/,
+    patternTo: '$1****$3$4',
+  });
+}

package/test/serializer.test.ts

@@ -0,0 +1,64 @@
+import type { DtoSerializerArray, DtoSerializerLazy, DtoSerializerSimple } from 'vona-module-test-vona';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('serializer.test.ts', () => {
+  const dataSimple = {
+    password: '123456',
+    password2: '123456',
+    email: 'kevin@cabloy.com',
+    email2: 'kevin@cabloy.com',
+    email3: 'kevin@cabloy.com',
+    email4: 'kevin@cabloy.com',
+    email5: 'kevin@cabloy.com',
+    email6: 'kevin@cabloy.com',
+    email7: 'kevin@cabloy.com',
+    firstName: 'k',
+    lastName: 'v',
+  } as DtoSerializerSimple;
+  it('action:serializerSimple', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const res: DtoSerializerSimple = await app.bean.executor.performAction('post', '/test/vona/serializer/echoSimple', {
+        body: dataSimple,
+      });
+      assert.equal(res.password, undefined);
+      assert.equal(res.password2, undefined);
+      assert.equal(res.email, 'k****n@cabloy.com');
+      assert.equal(res.email2, 'k****n@cabloy.com');
+      assert.equal(res.email3, 'k****n@cabloy.com');
+      assert.equal(res.email4, 'k****n@cabloy.com');
+      assert.equal(res.email5, 'k****n@cabloy.com');
+      assert.equal(res.email6, 'k****n@cabloy.com');
+      assert.equal(res.email7, 'k****n@cabloy.com');
+      assert.equal(res.fullName, 'k v');
+      assert.equal(res.fullName2, 'k v');
+      assert.equal(res.fullName3, 'k v');
+    });
+  });
+  it('action:serializerArray', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const res: DtoSerializerArray[] = await app.bean.executor.performAction('post', '/test/vona/serializer/echoArray', {
+        body: [{ simples: [dataSimple], simplesLazy: [dataSimple] }],
+      });
+      assert.equal(res[0].simples[0].password, '111111');
+      assert.equal(res[0].simples[0].password2, undefined);
+      assert.equal(res[0].simplesLazy[0].password, '111111');
+      assert.equal(res[0].simplesLazy[0].password2, undefined);
+    });
+  });
+  it('action:serializerLazy', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const res: DtoSerializerLazy = await app.bean.executor.performAction('post', '/test/vona/serializer/echoLazy', {
+        body: {
+          simple: dataSimple,
+          simpleLazy: dataSimple,
+        },
+      });
+      assert.equal(res.simple.password, '111111');
+      assert.equal(res.simple.password2, undefined);
+      assert.equal(res.simpleLazy.password, '111111');
+      assert.equal(res.simpleLazy.password2, undefined);
+    });
+  });
+});

package/dist/dto/serializerTest.d.ts

@@ -1,6 +0,0 @@
-import type { IDecoratorDtoOptions } from 'vona-module-a-web';
-export interface IDtoOptionsSerializerTest extends IDecoratorDtoOptions {
-}
-export declare class DtoSerializerTest {
-    password: string;
-}

package/src/dto/serializerTest.ts

@@ -1,13 +0,0 @@
-import type { IDecoratorDtoOptions } from 'vona-module-a-web';
-import { Api, v } from 'vona-module-a-openapi';
-import { Serializer } from 'vona-module-a-serialization';
-import { Dto } from 'vona-module-a-web';
-
-export interface IDtoOptionsSerializerTest extends IDecoratorDtoOptions {}
-
-@Dto<IDtoOptionsSerializerTest>()
-export class DtoSerializerTest {
-  @Serializer.exclude()
-  @Api.field(v.min(6))
-  password: string;
-}