vona-module-test-vona 5.0.49 → 5.0.50

package/dist/service/post.d.ts

@@ -9,7 +9,7 @@ export declare class ServicePost extends BeanBase {
         };
         with?: Record<string, unknown>;
         distinct?: boolean | keyof import("vona-module-test-vona").EntityPost | (keyof import("vona-module-test-vona").EntityPost)[] | undefined;
-        columns?: "iid" | "id" | "createdAt" | "updatedAt" | "deleted" | "*" | "title" | "userId" | "stars" | ("iid" | "id" | "createdAt" | "updatedAt" | "deleted" | "*" | "title" | "userId" | "stars")[] | undefined;
+        columns?: "title" | "id" | "iid" | "createdAt" | "updatedAt" | "deleted" | "*" | "userId" | "stars" | ("title" | "id" | "iid" | "createdAt" | "updatedAt" | "deleted" | "*" | "userId" | "stars")[] | undefined;
         where?: import("vona-module-a-orm").TypeModelWhereInner<{
             "testVonaPostContent.content": string;
             "testVonaPostContent.postId": TableIdentity;
@@ -100,7 +100,7 @@ export declare class ServicePost extends BeanBase {
         };
     }, undefined, 50>[]>;
     select2(): Promise<import("vona-module-a-orm").TypeModelRelationResult_Normal<import("vona-module-test-vona").EntityPost, ModelPost, {
-        columns: ("id" | "title" | "userId")[];
+        columns: ("title" | "id" | "userId")[];
         where: {
             id: {
                 _gt_: number;

package/package.json

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

package/src/.metadata/index.ts

@@ -1330,6 +1330,7 @@ export interface IModuleSummerCache {
 /** dto: begin */
 export * from '../dto/categoryTree.ts';
 export * from '../dto/orderCreate.ts';
+export * from '../dto/orderQuery.ts';
 export * from '../dto/orderResult.ts';
 export * from '../dto/orderUpdate.ts';
 export * from '../dto/postCreate.ts';
@@ -1344,6 +1345,7 @@ export * from '../dto/userLazy.ts';
 export * from '../dto/userUpdate.ts';
 import type { IDtoOptionsCategoryTree } from '../dto/categoryTree.ts';
 import type { IDtoOptionsOrderCreate } from '../dto/orderCreate.ts';
+import type { IDtoOptionsOrderQuery } from '../dto/orderQuery.ts';
 import type { IDtoOptionsOrderResult } from '../dto/orderResult.ts';
 import type { IDtoOptionsOrderUpdate } from '../dto/orderUpdate.ts';
 import type { IDtoOptionsPostCreate } from '../dto/postCreate.ts';
@@ -1362,6 +1364,7 @@ declare module 'vona-module-a-web' {
     export interface IDtoRecord {
       'test-vona:categoryTree': IDtoOptionsCategoryTree;
 'test-vona:orderCreate': IDtoOptionsOrderCreate;
+'test-vona:orderQuery': IDtoOptionsOrderQuery;
 'test-vona:orderResult': IDtoOptionsOrderResult;
 'test-vona:orderUpdate': IDtoOptionsOrderUpdate;
 'test-vona:postCreate': IDtoOptionsPostCreate;
@@ -1385,6 +1388,7 @@ declare module 'vona-module-test-vona' {
 /** dto: begin */
 import type { DtoCategoryTree } from '../dto/categoryTree.ts';
 import type { DtoOrderCreate } from '../dto/orderCreate.ts';
+import type { DtoOrderQuery } from '../dto/orderQuery.ts';
 import type { DtoOrderResult } from '../dto/orderResult.ts';
 import type { DtoOrderUpdate } from '../dto/orderUpdate.ts';
 import type { DtoPostCreate } from '../dto/postCreate.ts';
@@ -1407,6 +1411,10 @@ declare module 'vona-module-test-vona' {
       fields?: TypeEntityOptionsFields<DtoOrderCreate, IDtoOptionsOrderCreate[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsOrderQuery {
+      fields?: TypeEntityOptionsFields<DtoOrderQuery, IDtoOptionsOrderQuery[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsOrderResult {
       fields?: TypeEntityOptionsFields<DtoOrderResult, IDtoOptionsOrderResult[TypeSymbolKeyFieldsMore]>;
     }

package/src/config/locale/en-us.ts

@@ -1,7 +1,7 @@
 export default {
   Name: 'Name',
   User: 'User',
-  UserId: 'User Id',
+  UserId: 'User ID',
   Test: 'Test',
   TestHelloWorld: 'Hello World',
   TestApples: '%d apples',

package/src/config/locale/zh-cn.ts

@@ -1,7 +1,7 @@
 export default {
   Name: '名称',
   User: '用户',
-  UserId: '用户Id',
+  UserId: '用户ID',
   Test: '测试',
   TestHelloWorld: '您好，世界',
   TestApples: '%d个苹果',

package/src/controller/captcha.ts

@@ -1,6 +1,6 @@
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import { BeanBase } from 'vona';
-import { Aspect } from 'vona-module-a-aspect';
+import { Captcha } from 'vona-module-a-captcha';
 import { Passport } from 'vona-module-a-user';
 import { Arg, Controller, Web } from 'vona-module-a-web';
 import { DtoSignin } from '../dto/signin.ts';
@@ -11,7 +11,7 @@ export interface IControllerOptionsCaptcha extends IDecoratorControllerOptions {
 export class ControllerCaptcha extends BeanBase {
   @Web.post('signin')
   @Passport.public()
-  @Aspect.middleware('a-captcha:captcha', { scene: 'a-captchasimple:simple' })
+  @Captcha.verify({ scene: 'a-captchasimple:simple' })
   async signin(@Arg.body() _user: DtoSignin) {
   }
 }

package/src/controller/onion.ts

@@ -42,7 +42,7 @@ export class ControllerOnion extends BeanBase {
   @Web.post('echo2/:userId/:userName')
   // @Aspect.middlewareGlobal('a-core:gate', { gate: { mode: 'dev' } })
   @Aspect.guardGlobal('a-user:passport', { public: true })
-  // echo2(@Arg.query(v.object(DtoUser, { passthrough: false, strict: false })) book: Partial<DtoUser>) {
+  // echo2(@Arg.query(v.object(DtoUser, { loose: false, strict: false })) book: Partial<DtoUser>) {
   echo2(
     @Arg.param('userId', v.title($locale('UserId')), v.example('example:1')) _userId: number,
     @Arg.param('userName', v.title($locale('UserId')), v.example('example:1')) _userName: string,

package/src/controller/order.ts

@@ -1,17 +1,39 @@
-import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import type { VonaContext } from 'vona';
+import type { IQueryParams } from 'vona-module-a-orm';
+import type { IDecoratorControllerOptions, IPipeOptionsQueryTransformInfo } from 'vona-module-a-web';
+import type { ModelOrder } from '../model/order.ts';
 import { BeanBase } from 'vona';
 import { Api, v } from 'vona-module-a-openapi';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+import { DtoOrderCreate } from '../dto/orderCreate.ts';
+import { DtoOrderQuery } from '../dto/orderQuery.ts';
 import { DtoOrderResult } from '../dto/orderResult.ts';
 
 export interface IControllerOptionsOrder extends IDecoratorControllerOptions {}
 
+function myCustomQueryTransform(_ctx: VonaContext, info: IPipeOptionsQueryTransformInfo): boolean | undefined {
+  if (info.key === 'userName') {
+    info.params.where[info.fullName] = info.value;
+    return true;
+  }
+  return undefined;
+}
+
 @Controller<IControllerOptionsOrder>('order')
 export class ControllerOrder extends BeanBase {
+  @Web.post('create')
+  @Api.body(DtoOrderResult)
+  async create(@Arg.body(DtoOrderCreate) data: DtoOrderCreate) {
+    return await this.scope.model.order.insert(data);
+  }
+
   @Web.get('findAll')
   @Api.body(v.array(DtoOrderResult))
-  async findAll(): Promise<DtoOrderResult[]> {
+  async findAll(
+    @Arg.queryPro(DtoOrderQuery, myCustomQueryTransform) params: IQueryParams<ModelOrder>,
+  ): Promise<DtoOrderResult[]> {
     return this.scope.model.order.select({
+      ...params,
       include: {
         products: true,
       },

package/src/controller/post.ts

@@ -1,5 +1,5 @@
 import type { IQueryParams } from 'vona-module-a-orm';
-import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+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';
@@ -19,13 +19,14 @@ export class ControllerPost extends BeanBase {
     return params;
   }
 
+  findManyQueryTransform(_info: IPipeOptionsQueryTransformInfo): boolean | undefined {
+    return undefined;
+  }
+
   @Web.get('findMany')
   @Api.body(DtoPostQueryRes)
   @Passport.public()
   async findMany(@Arg.queryPro(DtoPostQuery) params: IQueryParams<ModelPost>) {
-    if (!params.orders) {
-      params.orders = [['testVonaPost.createdAt', 'desc']];
-    }
     return await this.scope.service.post.findMany(params);
   }
 }

package/src/controller/upload.ts

@@ -2,9 +2,8 @@ import type { IUploadField, IUploadFile } from 'vona-module-a-upload';
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import assert from 'node:assert';
 import { BeanBase } from 'vona';
-import { Aspect } from 'vona-module-a-aspect';
 import { Api, v } from 'vona-module-a-openapi';
-import { SymbolUploadValue } from 'vona-module-a-upload';
+import { File, SymbolUploadValue } from 'vona-module-a-upload';
 import { Passport } from 'vona-module-a-user';
 import { Arg, Controller, Web } from 'vona-module-a-web';
 import { z } from 'zod';
@@ -15,7 +14,7 @@ export interface IControllerOptionsUpload extends IDecoratorControllerOptions {}
 export class ControllerUpload extends BeanBase {
   @Web.post('fields')
   @Passport.public()
-  @Aspect.interceptor('a-upload:upload')
+  @File.upload()
   @Api.contentType('application/json')
   fields(
     @Arg.fields() fields: IUploadField[],
@@ -30,7 +29,7 @@ export class ControllerUpload extends BeanBase {
 
   @Web.post('file')
   @Passport.public()
-  @Aspect.interceptor('a-upload:upload')
+  @File.upload()
   @Api.contentType('application/json')
   file(@Arg.field('name', v.default('zhennann')) name: string, @Arg.file('welcome') file: IUploadFile) {
     assert.equal(name, 'zhennann');
@@ -40,7 +39,7 @@ export class ControllerUpload extends BeanBase {
 
   @Web.post('files')
   @Passport.public()
-  @Aspect.interceptor('a-upload:upload')
+  @File.upload()
   @Api.contentType('application/json')
   files(
     @Arg.files(v.title('more files')) files: IUploadFile[],

package/src/dto/orderQuery.ts

@@ -0,0 +1,28 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { $Dto, $tableName } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { EntityOrder } from '../entity/order.ts';
+import { EntityUser } from '../entity/user.ts';
+
+export interface IDtoOptionsOrderQuery extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsOrderQuery>({
+  openapi: {
+    query: {
+      table: $tableName(EntityOrder),
+    },
+  },
+})
+export class DtoOrderQuery
+  extends $Dto.query(EntityOrder, ['orderNo', 'remark']) {
+  @Api.field(v.optional(), v.openapi({
+    query: {
+      table: $tableName(EntityUser),
+      joinType: 'innerJoin',
+      joinOn: ['userId', 'testVonaUser.id'],
+      originalName: 'name',
+    },
+  }))
+  userName?: string;
+}

package/src/dto/postQuery.ts

@@ -1,22 +1,21 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 import { Api, v } from 'vona-module-a-openapi';
-import { $Dto } from 'vona-module-a-orm';
+import { $Dto, $tableName } from 'vona-module-a-orm';
 import { Dto } from 'vona-module-a-web';
 import { EntityPost } from '../entity/post.ts';
 
 export interface IDtoOptionsPostQuery extends IDecoratorDtoOptions {}
 
-@Dto<IDtoOptionsPostQuery>()
+@Dto<IDtoOptionsPostQuery>({
+  openapi: { query: { table: $tableName(EntityPost) } },
+})
 export class DtoPostQuery extends $Dto.queryPage(EntityPost, ['title']) {
   @Api.field(v.optional(), v.openapi({
     query: {
-      join: {
-        type: 'innerJoin',
-        table: 'testVonaUser',
-        on: ['userId', 'testVonaUser.id'],
-      },
+      table: 'testVonaUser',
+      joinOn: ['userId', 'testVonaUser.id'],
       originalName: 'name',
-      op: '_eq_',
+      op: '_eqI_',
     },
   }))
   userName?: string;

package/src/dto/signin.ts

@@ -1,3 +1,4 @@
+import type { DtoCaptchaVerify } from 'vona-module-a-captcha';
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 import { Api, v } from 'vona-module-a-openapi';
 import { Dto } from 'vona-module-a-web';
@@ -11,4 +12,7 @@ export class DtoSignin {
 
   @Api.field(v.min(3))
   password: string;
+
+  @Api.field(v.captcha({ scene: 'a-captchasimple:simple' }))
+  captcha: DtoCaptchaVerify;
 }

package/test/authSimple.test.ts

@@ -37,6 +37,7 @@ describe('authSimple.test.ts', () => {
       // login again
       const jwt2 = await app.bean.authSimple.authenticate(
         { username: 'admin', password: '123456' },
+        'login',
         'default',
       );
       assert.equal(!!jwt2?.accessToken, true);

package/test/captcha.test.ts

@@ -8,7 +8,7 @@ describe('captcha.test.ts', () => {
   // scene/provider
   const sceneName = 'a-captchasimple:simple';
   const providerName = 'a-captchasimple:imageText';
-  it('action:captcha', async () => {
+  it('action:captcha:error', async () => {
     await app.bean.executor.mockCtx(async () => {
       // create
       const captcha = await app.bean.captcha.create(sceneName);
@@ -21,12 +21,27 @@ describe('captcha.test.ts', () => {
       // verify: false
       const verifiedFalse = await app.bean.captcha.verify(captcha.id, `${token}!`, sceneName);
       assert.equal(verifiedFalse, false);
+      // verify: false
+      const verifiedFalse2 = await app.bean.captcha.verify(captcha.id, token, sceneName);
+      assert.equal(verifiedFalse2, false);
+    });
+  });
+  it('action:captcha:ok', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // create
+      const captcha = await app.bean.captcha.create(sceneName);
+      assert.equal(captcha.provider, providerName);
+      // get
+      const captchaData = await app.bean.captcha.getCaptchaData(captcha.id);
+      assert.equal(captchaData?.provider, providerName);
+      // token
+      const token = captchaData?.token;
       // verify: true
       const verifiedTrue = await app.bean.captcha.verify(captcha.id, token, sceneName);
       assert.equal(verifiedTrue, true);
     });
   });
-  it('action:captcha api', async () => {
+  it('action:captcha api:error', async () => {
     await app.bean.executor.mockCtx(async () => {
       // create
       const captcha: ICaptchaData = await app.bean.executor.performAction('post', '/captcha/create', {
@@ -56,6 +71,38 @@ describe('captcha.test.ts', () => {
         });
       });
       assert.equal(error?.code, 403);
+      // verifyImmediate: error again
+      const [_2, error2] = await catchError(() => {
+        return app.bean.executor.performAction('post', '/captcha/verifyImmediate', {
+          body: {
+            id: captcha2.id,
+            token: captchaData?.token,
+          },
+        });
+      });
+      assert.equal(error2?.code, 403);
+    });
+  });
+  it('action:captcha api:ok', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // create
+      const captcha: ICaptchaData = await app.bean.executor.performAction('post', '/captcha/create', {
+        body: {
+          scene: sceneName,
+        },
+      });
+      assert.equal(captcha.provider, providerName);
+      // refresh
+      const captcha2: ICaptchaData = await app.bean.executor.performAction('post', '/captcha/refresh', {
+        body: {
+          id: captcha.id,
+          scene: sceneName,
+        },
+      });
+      assert.equal(captcha2.provider, providerName);
+      assert.equal(captcha2.id, captcha.id);
+      // get token
+      const captchaData = await app.bean.captcha.getCaptchaData(captcha2.id);
       // verifyImmediate: ok
       const tokenSecondary = await app.bean.executor.performAction('post', '/captcha/verifyImmediate', {
         body: {

package/test/database/dtoAggregate.test.ts

@@ -1,3 +1,5 @@
+import type { TypeDecoratorRules } from 'vona-module-a-openapiutils';
+import type z from 'zod';
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
@@ -16,15 +18,16 @@ describe('dtoAggregate.test.ts', () => {
         // max: 'age',
         // min: 'age',
       });
-      let rules: any;
+      let rules: TypeDecoratorRules;
       rules = getTargetDecoratorRules(DtoUserAggr.prototype);
-      assert.equal(rules.count_all._def.typeName, 'ZodOptional');
-      assert.equal(rules.count_all._def.innerType._def.typeName, 'ZodUnion');
-      assert.equal(rules.count_all._def.innerType._def.options[0]._def.typeName, 'ZodString');
-      assert.equal(rules.count_all._def.innerType._def.options[1]._def.typeName, 'ZodNumber');
-      assert.equal(rules.count_age._def.typeName, 'ZodOptional');
-      assert.equal(rules.sum_age._def.typeName, 'ZodOptional');
-      assert.equal(rules.avg_age._def.typeName, 'ZodOptional');
+      assert.equal(rules.count_all?.type === 'optional', true);
+      const rule_count_all = (rules.count_all as z.ZodOptional)?.def.innerType as z.ZodUnion;
+      assert.equal(rule_count_all.type === 'union', true);
+      assert.equal((rule_count_all.def.options[0] as z.ZodType).type === 'string', true);
+      assert.equal((rule_count_all.def.options[1] as z.ZodType).type === 'number', true);
+      assert.equal(rules.count_age?.type === 'optional', true);
+      assert.equal(rules.sum_age?.type === 'optional', true);
+      assert.equal(rules.avg_age?.type === 'optional', true);
       assert.equal(rules.max_age, undefined);
       assert.equal(rules.min_age, undefined);
       // aggr: usersStats: posts: autoload
@@ -33,10 +36,10 @@ describe('dtoAggregate.test.ts', () => {
         include: { roles: true },
       });
       rules = getTargetDecoratorRules(DtoUserStats.prototype);
-      assert.equal(rules.name._def.typeName, 'ZodString');
+      assert.equal(rules.name?.type === 'string', true);
       assert.equal(rules.iid, undefined);
-      assert.equal(rules.posts._def.typeName, 'ZodOptional');
-      assert.equal(rules.roles._def.typeName, 'ZodOptional');
+      assert.equal(rules.posts?.type === 'optional', true);
+      assert.equal(rules.roles?.type === 'optional', true);
     });
   });
 });

package/test/database/dtoGet.test.ts

@@ -1,3 +1,4 @@
+import type { TypeDecoratorRules } from 'vona-module-a-openapiutils';
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
@@ -33,21 +34,21 @@ describe('dtoGet.test.ts', () => {
           }),
         },
       });
-      const rules: any = getTargetDecoratorRules(DtoPostNew.prototype);
-      assert.equal(['ZodString', 'ZodNumber'].includes(rules.id._def.typeName), true);
-      assert.equal(rules.title._def.typeName, 'ZodString');
-      assert.equal(['ZodString', 'ZodNumber'].includes(rules.userId._def.typeName), true);
+      const rules: TypeDecoratorRules = getTargetDecoratorRules(DtoPostNew.prototype);
+      assert.equal(['string', 'number'].includes(rules.id?.type as string), true);
+      assert.equal(rules.title?.type === 'string', true);
+      assert.equal(['string', 'number'].includes(rules.userId?.type as string), true);
       assert.equal(rules.iid, undefined);
-      assert.equal(rules.postContent._def.typeName, 'ZodOptional');
-      assert.equal(rules.user._def.typeName, 'ZodOptional');
-      assert.equal(rules.user3._def.typeName, 'ZodOptional');
+      assert.equal(rules.postContent?.type === 'optional', true);
+      assert.equal(rules.user?.type === 'optional', true);
+      assert.equal(rules.user3?.type === 'optional', true);
     });
   });
   it('action:dtoGet:categoryTree', async () => {
     await app.bean.executor.mockCtx(async () => {
       const DtoCategoryTree = $Dto.get('test-vona:category', { columns: ['id', 'name'], include: { children: { columns: ['id'] } } });
-      const rules: any = getTargetDecoratorRules(DtoCategoryTree.prototype);
-      assert.equal(rules.children._def.typeName, 'ZodEffects');
+      const rules: TypeDecoratorRules = getTargetDecoratorRules(DtoCategoryTree.prototype);
+      assert.equal(rules.children?.type === 'pipe', true);
       assert.equal(rules.iid, undefined);
       const DtoCategoryChain = $Dto.get('test-vona:categoryChain', { columns: ['id', 'name', 'categoryIdParent'] });
       const _apiJson = await app.bean.scope('a-openapi').service.openapi.generateJsonOfClass(DtoCategoryChain);

package/test/database/dtoGroup.test.ts

@@ -1,3 +1,5 @@
+import type { TypeDecoratorRules } from 'vona-module-a-openapiutils';
+import type z from 'zod';
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
@@ -15,16 +17,17 @@ describe('dtoGroup.test.ts', () => {
         // max: 'age',
         // min: 'age',
       });
-      let rules: any;
+      let rules: TypeDecoratorRules;
       rules = getTargetDecoratorRules(DtoUserAggr.prototype);
-      assert.equal(rules.name._def.typeName, 'ZodString');
-      assert.equal(rules.count_all._def.typeName, 'ZodOptional');
-      assert.equal(rules.count_all._def.innerType._def.typeName, 'ZodUnion');
-      assert.equal(rules.count_all._def.innerType._def.options[0]._def.typeName, 'ZodString');
-      assert.equal(rules.count_all._def.innerType._def.options[1]._def.typeName, 'ZodNumber');
-      assert.equal(rules.count_age._def.typeName, 'ZodOptional');
-      assert.equal(rules.sum_age._def.typeName, 'ZodOptional');
-      assert.equal(rules.avg_age._def.typeName, 'ZodOptional');
+      assert.equal(rules.name?.type === 'string', true);
+      assert.equal(rules.count_all?.type === 'optional', true);
+      const rule_count_all = (rules.count_all as z.ZodOptional)?.def.innerType as z.ZodUnion;
+      assert.equal(rule_count_all.type === 'union', true);
+      assert.equal((rule_count_all.def.options[0] as z.ZodType).type === 'string', true);
+      assert.equal((rule_count_all.def.options[1] as z.ZodType).type === 'number', true);
+      assert.equal(rules.count_age?.type === 'optional', true);
+      assert.equal(rules.sum_age?.type === 'optional', true);
+      assert.equal(rules.avg_age?.type === 'optional', true);
       assert.equal(rules.max_age, undefined);
       assert.equal(rules.min_age, undefined);
       // group: userStats: posts: autoload
@@ -33,10 +36,10 @@ describe('dtoGroup.test.ts', () => {
         include: { roles: true },
       });
       rules = getTargetDecoratorRules(DtoUserStats.prototype);
-      assert.equal(rules.name._def.typeName, 'ZodString');
+      assert.equal(rules.name?.type === 'string', true);
       assert.equal(rules.iid, undefined);
-      assert.equal(rules.posts._def.typeName, 'ZodEffects');
-      assert.equal(rules.roles._def.typeName, 'ZodEffects');
+      assert.equal(rules.posts?.type === 'pipe', true);
+      assert.equal(rules.roles?.type === 'pipe', true);
     });
   });
 });

package/test/database/dtoLazy.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
-import { OpenApiGeneratorV31, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { OpenApiGeneratorV31, OpenAPIRegistry } from '@cabloy/zod-to-openapi';
 import { appResource, cast } from 'vona';
 import { app } from 'vona-mock';
 import { $schema } from 'vona-module-a-openapi';

package/test/database/dtoMutate.test.ts

@@ -1,3 +1,4 @@
+import type { TypeDecoratorRules } from 'vona-module-a-openapiutils';
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
@@ -12,15 +13,15 @@ describe('dtoMutate.test.ts', () => {
       const DtoUserCreate = $Dto.create('test-vona:user', {
         include: { posts: true },
       });
-      let rules: any;
+      let rules: TypeDecoratorRules;
       rules = getTargetDecoratorRules(DtoUserCreate.prototype);
-      assert.equal(rules.name._def.typeName, 'ZodString');
+      assert.equal(rules.name?.type === 'string', true);
       assert.equal(rules.id, undefined);
       assert.equal(rules.iid, undefined);
       assert.equal(rules.deleted, undefined);
       assert.equal(rules.createdAt, undefined);
       assert.equal(rules.updatedAt, undefined);
-      assert.equal(rules.posts._def.typeName, 'ZodOptional');
+      assert.equal(rules.posts?.type === 'optional', true);
       // update
       const DtoUserUpdate = $Dto.update('test-vona:user', {
         with: {
@@ -28,13 +29,13 @@ describe('dtoMutate.test.ts', () => {
         },
       });
       rules = getTargetDecoratorRules(DtoUserUpdate.prototype);
-      assert.equal(rules.name._def.typeName, 'ZodString'); // ZodOptional
+      assert.equal(rules.name?.type === 'string', true); // ZodOptional
       assert.equal(rules.id, undefined);
       assert.equal(rules.iid, undefined);
       assert.equal(rules.deleted, undefined);
       assert.equal(rules.createdAt, undefined);
       assert.equal(rules.updatedAt, undefined);
-      assert.equal(rules.posts._def.typeName, 'ZodOptional');
+      assert.equal(rules.posts?.type === 'optional', true);
       // create: not mutate post(belongsTo)
       const DtoPostCreate = $Dto.create('test-vona:post', {
         include: {
@@ -43,10 +44,10 @@ describe('dtoMutate.test.ts', () => {
         },
       });
       rules = getTargetDecoratorRules(DtoPostCreate.prototype);
-      assert.equal(rules.title._def.typeName, 'ZodString'); // ZodOptional
-      assert.equal(rules.stars._def.typeName, 'ZodOptional');
-      assert.equal(['ZodString', 'ZodNumber'].includes(rules.userId._def.typeName), true);
-      assert.equal(rules.postContent._def.typeName, 'ZodOptional');
+      assert.equal(rules.title?.type === 'string', true); // ZodOptional
+      assert.equal(rules.stars?.type === 'optional', true);
+      assert.equal(['string', 'number'].includes(rules.userId?.type as string), true);
+      assert.equal(rules.postContent?.type === 'optional', true);
       assert.equal(rules.user, undefined);
       assert.equal(rules.id, undefined);
     });

package/test/database/dtoQuery.test.ts

@@ -16,7 +16,8 @@ describe('dtoQuery.test.ts', () => {
               _gt_: 12,
             },
           },
-          orders: [['testVonaPost.createdAt', 'desc']],
+          // orders: [['userName', 'asc']],
+          // orders: [['testVonaPost.createdAt', 'asc']],
           pageNo: 2,
           pageSize: 30,
           title: 'ai',
@@ -27,7 +28,7 @@ describe('dtoQuery.test.ts', () => {
       assert.deepEqual(resEcho.where, {
         'stars': { _gt_: 12 },
         'title': { _includesI_: 'ai' },
-        'testVonaUser.name': 'tom',
+        'testVonaUser.name': { _eqI_: 'tom' },
       });
       assert.deepEqual(resEcho.orders, [['testVonaPost.createdAt', 'desc']]);
       assert.equal(resEcho.offset, 30);

package/test/database/modelWhere.test.ts

@@ -6,6 +6,7 @@ import { app } from 'vona-mock';
 describe('modelWhere.test.ts', () => {
   it('action:modelWhere', async () => {
     await app.bean.executor.mockCtx(async () => {
+      if (app.bean.database.current.dialectName !== 'pg') return;
       const scopeTest = app.bean.scope('test-vona');
       // ref
       let builder = scopeTest.model.post.builder();

package/test/mail.test.ts

@@ -0,0 +1,14 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('mail.test.ts', () => {
+  it('action:mail', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.mail.send({
+        to: 'someone@cabloy.com',
+        subject: 'this is a test mail',
+        text: 'message body!',
+      });
+    });
+  });
+});