vona-module-test-vona 5.0.44 → 5.0.46

package/dist/service/post.d.ts

@@ -1,7 +1,65 @@
 import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
 import { BeanBase } from 'vona';
 import { ModelPost } from '../model/post.ts';
 export declare class ServicePost extends BeanBase {
+    findMany(params: IQueryParams<ModelPost>): Promise<import("vona-module-a-orm").TypeModelSelectAndCount<import("vona-module-test-vona").EntityPost, ModelPost, {
+        include: {
+            postContent: true;
+        };
+        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;
+        where?: import("vona-module-a-orm").TypeModelWhereInner<{
+            "testVonaPostContent.content": string;
+            "testVonaPostContent.postId": TableIdentity;
+            "testVonaPostContent.id": TableIdentity;
+            "testVonaPostContent.createdAt": Date;
+            "testVonaPostContent.updatedAt": Date;
+            "testVonaPostContent.deleted": boolean;
+            "testVonaPostContent.iid": number;
+        } & {
+            "testVonaPost.title": string;
+            "testVonaPost.userId": TableIdentity;
+            "testVonaPost.stars"?: number | undefined;
+            "testVonaPost.id": TableIdentity;
+            "testVonaPost.createdAt": Date;
+            "testVonaPost.updatedAt": Date;
+            "testVonaPost.deleted": boolean;
+            "testVonaPost.iid": number;
+        } & import("vona-module-test-vona").EntityPost> | import("vona-module-a-orm").TypeModelWhereInner<{
+            "testVonaUser.name": string;
+            "testVonaUser.age"?: number | undefined;
+            "testVonaUser.scores"?: number | undefined;
+            "testVonaUser.id": TableIdentity;
+            "testVonaUser.createdAt": Date;
+            "testVonaUser.updatedAt": Date;
+            "testVonaUser.deleted": boolean;
+            "testVonaUser.iid": number;
+        } & {
+            "testVonaPost.title": string;
+            "testVonaPost.userId": TableIdentity;
+            "testVonaPost.stars"?: number | undefined;
+            "testVonaPost.id": TableIdentity;
+            "testVonaPost.createdAt": Date;
+            "testVonaPost.updatedAt": Date;
+            "testVonaPost.deleted": boolean;
+            "testVonaPost.iid": number;
+        } & import("vona-module-test-vona").EntityPost> | undefined;
+        joins?: import("vona-module-a-orm").IModelSelectParamsJoin<import("vona-module-test-vona").EntityPost, import("vona").TypeRecordValues<{
+            postContent: "testVonaPostContent";
+            user: "testVonaUser";
+        }>, import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelPost> | import("vona").TypeRecordValues<{
+            postContent: "testVonaPostContent.content" | "testVonaPostContent.postId" | "testVonaPostContent.id" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.iid";
+            user: "testVonaUser.name" | "testVonaUser.age" | "testVonaUser.scores" | "testVonaUser.id" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.iid";
+        }>>[] | undefined;
+        orders?: import("vona-module-a-orm").IModelSelectParamsOrder<import("vona-module-a-orm").TypeEntityTableColumnNamesOfModelSelf<ModelPost> | import("vona").TypeRecordValues<{
+            postContent: "testVonaPostContent.content" | "testVonaPostContent.postId" | "testVonaPostContent.id" | "testVonaPostContent.createdAt" | "testVonaPostContent.updatedAt" | "testVonaPostContent.deleted" | "testVonaPostContent.iid";
+            user: "testVonaUser.name" | "testVonaUser.age" | "testVonaUser.scores" | "testVonaUser.id" | "testVonaUser.createdAt" | "testVonaUser.updatedAt" | "testVonaUser.deleted" | "testVonaUser.iid";
+        }>>[] | undefined;
+        limit?: number;
+        offset?: number;
+    }, undefined, undefined, undefined, 50>>;
     group(): Promise<({
         userId: TableIdentity;
     } & import("vona-module-a-orm").TypeRecordAggrsValuesToObject<import("vona-module-a-orm").TypeRecordAggrsValues<{

package/dist/service/user.d.ts

@@ -1,4 +1,17 @@
 import { BeanBase } from 'vona';
 export declare class ServiceUser extends BeanBase {
+    userStats(): Promise<import("vona-module-a-orm").TypeRecordAggrsValuesToObject<import("vona-module-a-orm").TypeRecordAggrsValues<{
+        count: "count_all";
+        sum: "sum_scores";
+        max: "max_age";
+        min: "min_age";
+    }>>>;
+    findUsers(): Promise<import("vona-module-a-orm").TypeModelRelationResult_Normal<import("vona-module-test-vona").EntityUser, import("vona-module-test-vona").ModelUser, {
+        where: {
+            age: {
+                _gt_: number;
+            };
+        };
+    }, undefined, 50>[]>;
     relationBelongsToMany(): Promise<void>;
 }

package/package.json

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

package/src/.metadata/index.ts

@@ -445,7 +445,7 @@ declare module 'vona' {
 }
 /** model: end */
 /** model: begin */
-import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TableIdentity, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TableIdentity, TypeModelSelectAndCount, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
 import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
 declare module 'vona-module-test-vona' {
   export interface IModelOptionsCategory {
@@ -510,6 +510,7 @@ roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false
       [SymbolKeyModelOptions]: IModelOptionsCategory;
       get<T extends IModelGetOptions<EntityCategory,ModelCategory>>(where: TypeModelWhere<EntityCategory>, options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T> | undefined>;
       mget<T extends IModelGetOptions<EntityCategory,ModelCategory>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityCategory,ModelCategory,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityCategory, ModelCategory, T>>;
       select<T extends IModelSelectParams<EntityCategory,ModelCategory,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityCategory, ModelCategory, T>[]>;
       insert<T extends IModelInsertOptions<EntityCategory,ModelCategory>>(data?: TypeModelMutateRelationData<EntityCategory,ModelCategory, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategory, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityCategory,ModelCategory>>(items: TypeModelMutateRelationData<EntityCategory,ModelCategory, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategory, T, true>[]>;
@@ -529,6 +530,7 @@ export interface ModelCategoryChain {
       [SymbolKeyModelOptions]: IModelOptionsCategoryChain;
       get<T extends IModelGetOptions<EntityCategory,ModelCategoryChain>>(where: TypeModelWhere<EntityCategory>, options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategoryChain, T> | undefined>;
       mget<T extends IModelGetOptions<EntityCategory,ModelCategoryChain>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityCategory, ModelCategoryChain, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityCategory,ModelCategoryChain,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityCategory, ModelCategoryChain, T>>;
       select<T extends IModelSelectParams<EntityCategory,ModelCategoryChain,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityCategory, ModelCategoryChain, T>[]>;
       insert<T extends IModelInsertOptions<EntityCategory,ModelCategoryChain>>(data?: TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityCategory,ModelCategoryChain>>(items: TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T, true>[]>;
@@ -548,6 +550,7 @@ export interface ModelOrder {
       [SymbolKeyModelOptions]: IModelOptionsOrder;
       get<T extends IModelGetOptions<EntityOrder,ModelOrder>>(where: TypeModelWhere<EntityOrder>, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T> | undefined>;
       mget<T extends IModelGetOptions<EntityOrder,ModelOrder>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityOrder, ModelOrder, T>>;
       select<T extends IModelSelectParams<EntityOrder,ModelOrder,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityOrder, ModelOrder, T>[]>;
       insert<T extends IModelInsertOptions<EntityOrder,ModelOrder>>(data?: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityOrder,ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T, true>[]>;
@@ -567,6 +570,7 @@ export interface ModelOrderStats {
       [SymbolKeyModelOptions]: IModelOptionsOrderStats;
       get<T extends IModelGetOptions<EntityOrder,ModelOrderStats>>(where: TypeModelWhere<EntityOrder>, options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrderStats, T> | undefined>;
       mget<T extends IModelGetOptions<EntityOrder,ModelOrderStats>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityOrder, ModelOrderStats, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityOrder,ModelOrderStats,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityOrder, ModelOrderStats, T>>;
       select<T extends IModelSelectParams<EntityOrder,ModelOrderStats,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityOrder, ModelOrderStats, T>[]>;
       insert<T extends IModelInsertOptions<EntityOrder,ModelOrderStats>>(data?: TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityOrder,ModelOrderStats>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T, true>[]>;
@@ -586,6 +590,7 @@ export interface ModelPost {
       [SymbolKeyModelOptions]: IModelOptionsPost;
       get<T extends IModelGetOptions<EntityPost,ModelPost>>(where: TypeModelWhere<EntityPost>, options?: T): Promise<TypeModelRelationResult<EntityPost, ModelPost, T> | undefined>;
       mget<T extends IModelGetOptions<EntityPost,ModelPost>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityPost, ModelPost, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityPost,ModelPost,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityPost, ModelPost, T>>;
       select<T extends IModelSelectParams<EntityPost,ModelPost,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityPost, ModelPost, T>[]>;
       insert<T extends IModelInsertOptions<EntityPost,ModelPost>>(data?: TypeModelMutateRelationData<EntityPost,ModelPost, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPost,ModelPost, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityPost,ModelPost>>(items: TypeModelMutateRelationData<EntityPost,ModelPost, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPost,ModelPost, T, true>[]>;
@@ -605,6 +610,7 @@ export interface ModelPostContent {
       [SymbolKeyModelOptions]: IModelOptionsPostContent;
       get<T extends IModelGetOptions<EntityPostContent,ModelPostContent>>(where: TypeModelWhere<EntityPostContent>, options?: T): Promise<TypeModelRelationResult<EntityPostContent, ModelPostContent, T> | undefined>;
       mget<T extends IModelGetOptions<EntityPostContent,ModelPostContent>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityPostContent, ModelPostContent, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityPostContent,ModelPostContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityPostContent, ModelPostContent, T>>;
       select<T extends IModelSelectParams<EntityPostContent,ModelPostContent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityPostContent, ModelPostContent, T>[]>;
       insert<T extends IModelInsertOptions<EntityPostContent,ModelPostContent>>(data?: TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityPostContent,ModelPostContent>>(items: TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T, true>[]>;
@@ -624,6 +630,7 @@ export interface ModelProduct {
       [SymbolKeyModelOptions]: IModelOptionsProduct;
       get<T extends IModelGetOptions<EntityProduct,ModelProduct>>(where: TypeModelWhere<EntityProduct>, options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T> | undefined>;
       mget<T extends IModelGetOptions<EntityProduct,ModelProduct>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityProduct,ModelProduct,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityProduct, ModelProduct, T>>;
       select<T extends IModelSelectParams<EntityProduct,ModelProduct,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityProduct, ModelProduct, T>[]>;
       insert<T extends IModelInsertOptions<EntityProduct,ModelProduct>>(data?: TypeModelMutateRelationData<EntityProduct,ModelProduct, T>, options?: T): Promise<TypeModelMutateRelationData<EntityProduct,ModelProduct, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityProduct,ModelProduct>>(items: TypeModelMutateRelationData<EntityProduct,ModelProduct, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityProduct,ModelProduct, T, true>[]>;
@@ -643,6 +650,7 @@ export interface ModelRole {
       [SymbolKeyModelOptions]: IModelOptionsRole;
       get<T extends IModelGetOptions<EntityRole,ModelRole>>(where: TypeModelWhere<EntityRole>, options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T> | undefined>;
       mget<T extends IModelGetOptions<EntityRole,ModelRole>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityRole,ModelRole,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityRole, ModelRole, T>>;
       select<T extends IModelSelectParams<EntityRole,ModelRole,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
       insert<T extends IModelInsertOptions<EntityRole,ModelRole>>(data?: TypeModelMutateRelationData<EntityRole,ModelRole, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRole,ModelRole, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityRole,ModelRole>>(items: TypeModelMutateRelationData<EntityRole,ModelRole, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRole,ModelRole, T, true>[]>;
@@ -662,6 +670,7 @@ export interface ModelRoleUser {
       [SymbolKeyModelOptions]: IModelOptionsRoleUser;
       get<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(where: TypeModelWhere<EntityRoleUser>, options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T> | undefined>;
       mget<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityRoleUser,ModelRoleUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityRoleUser, ModelRoleUser, T>>;
       select<T extends IModelSelectParams<EntityRoleUser,ModelRoleUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
       insert<T extends IModelInsertOptions<EntityRoleUser,ModelRoleUser>>(data?: TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityRoleUser,ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T, true>[]>;
@@ -681,6 +690,7 @@ export interface ModelTest {
       [SymbolKeyModelOptions]: IModelOptionsTest;
       get<T extends IModelGetOptions<EntityTest,ModelTest>>(where: TypeModelWhere<EntityTest>, options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTest, T> | undefined>;
       mget<T extends IModelGetOptions<EntityTest,ModelTest>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTest, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityTest,ModelTest,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityTest, ModelTest, T>>;
       select<T extends IModelSelectParams<EntityTest,ModelTest,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityTest, ModelTest, T>[]>;
       insert<T extends IModelInsertOptions<EntityTest,ModelTest>>(data?: TypeModelMutateRelationData<EntityTest,ModelTest, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTest, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityTest,ModelTest>>(items: TypeModelMutateRelationData<EntityTest,ModelTest, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTest, T, true>[]>;
@@ -700,6 +710,7 @@ export interface ModelTestDynamicTable {
       [SymbolKeyModelOptions]: IModelOptionsTestDynamicTable;
       get<T extends IModelGetOptions<EntityTest,ModelTestDynamicTable>>(where: TypeModelWhere<EntityTest>, options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTestDynamicTable, T> | undefined>;
       mget<T extends IModelGetOptions<EntityTest,ModelTestDynamicTable>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityTest, ModelTestDynamicTable, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityTest,ModelTestDynamicTable,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityTest, ModelTestDynamicTable, T>>;
       select<T extends IModelSelectParams<EntityTest,ModelTestDynamicTable,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityTest, ModelTestDynamicTable, T>[]>;
       insert<T extends IModelInsertOptions<EntityTest,ModelTestDynamicTable>>(data?: TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityTest,ModelTestDynamicTable>>(items: TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T, true>[]>;
@@ -719,6 +730,7 @@ export interface ModelUser {
       [SymbolKeyModelOptions]: IModelOptionsUser;
       get<T extends IModelGetOptions<EntityUser,ModelUser>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T> | undefined>;
       mget<T extends IModelGetOptions<EntityUser,ModelUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityUser,ModelUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityUser, ModelUser, T>>;
       select<T extends IModelSelectParams<EntityUser,ModelUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
       insert<T extends IModelInsertOptions<EntityUser,ModelUser>>(data?: TypeModelMutateRelationData<EntityUser,ModelUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUser, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityUser,ModelUser>>(items: TypeModelMutateRelationData<EntityUser,ModelUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUser, T, true>[]>;
@@ -738,6 +750,7 @@ export interface ModelUserStats {
       [SymbolKeyModelOptions]: IModelOptionsUserStats;
       get<T extends IModelGetOptions<EntityUser,ModelUserStats>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStats, T> | undefined>;
       mget<T extends IModelGetOptions<EntityUser,ModelUserStats>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStats, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityUser,ModelUserStats,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityUser, ModelUserStats, T>>;
       select<T extends IModelSelectParams<EntityUser,ModelUserStats,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUserStats, T>[]>;
       insert<T extends IModelInsertOptions<EntityUser,ModelUserStats>>(data?: TypeModelMutateRelationData<EntityUser,ModelUserStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStats, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityUser,ModelUserStats>>(items: TypeModelMutateRelationData<EntityUser,ModelUserStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStats, T, true>[]>;
@@ -757,6 +770,7 @@ export interface ModelUserStatsGroup {
       [SymbolKeyModelOptions]: IModelOptionsUserStatsGroup;
       get<T extends IModelGetOptions<EntityUser,ModelUserStatsGroup>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStatsGroup, T> | undefined>;
       mget<T extends IModelGetOptions<EntityUser,ModelUserStatsGroup>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUserStatsGroup, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityUser,ModelUserStatsGroup,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityUser, ModelUserStatsGroup, T>>;
       select<T extends IModelSelectParams<EntityUser,ModelUserStatsGroup,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUserStatsGroup, T>[]>;
       insert<T extends IModelInsertOptions<EntityUser,ModelUserStatsGroup>>(data?: TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityUser,ModelUserStatsGroup>>(items: TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T, true>[]>;
@@ -1318,6 +1332,8 @@ export * from '../dto/orderCreate.ts';
 export * from '../dto/orderResult.ts';
 export * from '../dto/orderUpdate.ts';
 export * from '../dto/postCreate.ts';
+export * from '../dto/postQuery.ts';
+export * from '../dto/postQueryRes.ts';
 export * from '../dto/profile.ts';
 export * from '../dto/roleLazy.ts';
 export * from '../dto/signin.ts';
@@ -1330,6 +1346,8 @@ import type { IDtoOptionsOrderCreate } from '../dto/orderCreate.ts';
 import type { IDtoOptionsOrderResult } from '../dto/orderResult.ts';
 import type { IDtoOptionsOrderUpdate } from '../dto/orderUpdate.ts';
 import type { IDtoOptionsPostCreate } from '../dto/postCreate.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 { IDtoOptionsSignin } from '../dto/signin.ts';
@@ -1346,6 +1364,8 @@ declare module 'vona-module-a-web' {
 'test-vona:orderResult': IDtoOptionsOrderResult;
 'test-vona:orderUpdate': IDtoOptionsOrderUpdate;
 'test-vona:postCreate': IDtoOptionsPostCreate;
+'test-vona:postQuery': IDtoOptionsPostQuery;
+'test-vona:postQueryRes': IDtoOptionsPostQueryRes;
 'test-vona:profile': IDtoOptionsProfile;
 'test-vona:roleLazy': IDtoOptionsRoleLazy;
 'test-vona:signin': IDtoOptionsSignin;
@@ -1367,6 +1387,8 @@ import type { DtoOrderCreate } from '../dto/orderCreate.ts';
 import type { DtoOrderResult } from '../dto/orderResult.ts';
 import type { DtoOrderUpdate } from '../dto/orderUpdate.ts';
 import type { DtoPostCreate } from '../dto/postCreate.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 { DtoSignin } from '../dto/signin.ts';
@@ -1396,6 +1418,14 @@ declare module 'vona-module-test-vona' {
       fields?: TypeEntityOptionsFields<DtoPostCreate, IDtoOptionsPostCreate[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsPostQuery {
+      fields?: TypeEntityOptionsFields<DtoPostQuery, IDtoOptionsPostQuery[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsPostQueryRes {
+      fields?: TypeEntityOptionsFields<DtoPostQueryRes, IDtoOptionsPostQueryRes[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsProfile {
       fields?: TypeEntityOptionsFields<DtoProfile, IDtoOptionsProfile[TypeSymbolKeyFieldsMore]>;
     }
@@ -1435,6 +1465,7 @@ export * from '../controller/guardPassport.ts';
 export * from '../controller/onion.ts';
 export * from '../controller/passport.ts';
 export * from '../controller/performAction.ts';
+export * from '../controller/post.ts';
 export * from '../controller/queue.ts';
 export * from '../controller/summer.ts';
 export * from '../controller/tail.ts';
@@ -1449,6 +1480,7 @@ import type { IControllerOptionsGuardPassport } from '../controller/guardPasspor
 import type { IControllerOptionsOnion } from '../controller/onion.ts';
 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 { IControllerOptionsSummer } from '../controller/summer.ts';
 import type { IControllerOptionsTail } from '../controller/tail.ts';
@@ -1467,6 +1499,7 @@ declare module 'vona-module-a-web' {
 'test-vona:onion': IControllerOptionsOnion;
 'test-vona:passport': IControllerOptionsPassport;
 'test-vona:performAction': IControllerOptionsPerformAction;
+'test-vona:post': IControllerOptionsPost;
 'test-vona:queue': IControllerOptionsQueue;
 'test-vona:summer': IControllerOptionsSummer;
 'test-vona:tail': IControllerOptionsTail;
@@ -1568,6 +1601,16 @@ declare module 'vona-module-test-vona' {
             get $onionName(): 'test-vona:performAction';
           }
 
+        export interface ControllerPost {
+          /** @internal */
+          get scope(): ScopeModuleTestVona;
+        }
+
+          export interface ControllerPost {
+            get $beanFullName(): 'test-vona.controller.post';
+            get $onionName(): 'test-vona:post';
+          }
+
         export interface ControllerQueue {
           /** @internal */
           get scope(): ScopeModuleTestVona;
@@ -1639,6 +1682,8 @@ import type { ControllerPassport } from '../controller/passport.ts';
 // @ts-ignore ignore
 import type { ControllerPerformAction } from '../controller/performAction.ts';
 // @ts-ignore ignore
+import type { ControllerPost } from '../controller/post.ts';
+// @ts-ignore ignore
 import type { ControllerQueue } from '../controller/queue.ts';
 // @ts-ignore ignore
 import type { ControllerSummer } from '../controller/summer.ts';
@@ -1686,6 +1731,10 @@ declare module 'vona-module-test-vona' {
       actions?: TypeControllerOptionsActions<ControllerPerformAction>;
     }
 
+    export interface IControllerOptionsPost {
+      actions?: TypeControllerOptionsActions<ControllerPost>;
+    }
+
     export interface IControllerOptionsQueue {
       actions?: TypeControllerOptionsActions<ControllerQueue>;
     }
@@ -1726,6 +1775,8 @@ declare module 'vona-module-a-web' {
 '/test/vona/onion/echo6': undefined;
 '/test/vona/passport/echo/:name': undefined;
 '/test/vona/passport/isAuthenticated': undefined;
+'/test/vona/post/findManyEcho': undefined;
+'/test/vona/post/findMany': undefined;
     }
 export interface IApiPathPostRecord{
         '/test/vona/cacheMem': undefined;

package/src/bean/meta.version.ts

@@ -1,9 +1,9 @@
-import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+import type { IMetaVersionTest, IMetaVersionTestOptions, IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
 import { BeanBase } from 'vona';
 import { Meta } from 'vona-module-a-meta';
 
 @Meta()
-export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate, IMetaVersionTest {
   async update(options: IMetaVersionUpdateOptions) {
     if (options.version === 1) {
       // testVonaTest
@@ -78,4 +78,19 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
       });
     }
   }
+
+  async test(_options: IMetaVersionTestOptions) {
+    // user: Kevin
+    const userKevin = await this.scope.model.user.insert({ name: 'Kevin' });
+    // create: post/postContent
+    await this.scope.model.post.insert({
+      title: 'test:post001',
+      postContent: {
+        content: 'this is a test post!',
+      },
+      userId: userKevin?.id,
+    }, {
+      include: { postContent: true },
+    });
+  }
 }

package/src/controller/captcha.ts

@@ -1,9 +1,8 @@
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import { BeanBase } from 'vona';
 import { Aspect } from 'vona-module-a-aspect';
-import { Arg } from 'vona-module-a-openapi';
 import { Passport } from 'vona-module-a-user';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
 import { DtoSignin } from '../dto/signin.ts';
 
 export interface IControllerOptionsCaptcha extends IDecoratorControllerOptions {}

package/src/controller/dtoTest.ts

@@ -1,8 +1,8 @@
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import { BeanBase } from 'vona';
-import { Api, Arg, v } from 'vona-module-a-openapi';
+import { Api, v } from 'vona-module-a-openapi';
 import { $Dto, TableIdentity } from 'vona-module-a-orm';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
 import { DtoCategoryTree } from '../dto/categoryTree.ts';
 import { DtoUserCreate } from '../dto/userCreate.ts';
 import { DtoUserLazy } from '../dto/userLazy.ts';

package/src/controller/onion.ts

@@ -2,10 +2,10 @@ import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import { BeanBase } from 'vona';
 import { Aspect } from 'vona-module-a-aspect';
 import { Core } from 'vona-module-a-core';
-import { Api, Arg, v } from 'vona-module-a-openapi';
+import { Api, v } from 'vona-module-a-openapi';
 import { Database } from 'vona-module-a-orm';
 import { Passport } from 'vona-module-a-user';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
 import { z } from 'zod';
 import { $locale } from '../.metadata/index.ts';
 import { DtoUser } from '../dto/user.ts';

package/src/controller/passport.ts

@@ -4,9 +4,9 @@ import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import assert from 'node:assert';
 import { BeanBase } from 'vona';
 import { DtoJwtToken } from 'vona-module-a-jwt';
-import { Api, Arg, v } from 'vona-module-a-openapi';
+import { Api, v } from 'vona-module-a-openapi';
 import { $getUserName, Passport } from 'vona-module-a-user';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
 
 export interface IControllerOptionsPassport extends IDecoratorControllerOptions {}
 

package/src/controller/performAction.ts

@@ -1,8 +1,8 @@
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import { BeanBase } from 'vona';
-import { Api, Arg } from 'vona-module-a-openapi';
+import { Api } from 'vona-module-a-openapi';
 import { Passport } from 'vona-module-a-user';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
 
 export interface IControllerOptionsPerformAction extends IDecoratorControllerOptions {}
 

package/src/controller/post.ts

@@ -0,0 +1,31 @@
+import type { IQueryParams } from 'vona-module-a-orm';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import type { ModelPost } from '../model/post.ts';
+import { BeanBase } from 'vona';
+import { Api } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+import { DtoPostQuery } from '../dto/postQuery.ts';
+import { DtoPostQueryRes } from '../dto/postQueryRes.ts';
+
+export interface IControllerOptionsPost extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsPost>('post', { meta: { mode: ['test', 'dev'] } })
+export class ControllerPost extends BeanBase {
+  @Web.get('findManyEcho')
+  @Api.body(DtoPostQueryRes)
+  @Passport.public()
+  findManyEcho(@Arg.queryPro(DtoPostQuery) params: IQueryParams<ModelPost>) {
+    return params;
+  }
+
+  @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/transaction.ts

@@ -1,9 +1,9 @@
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import { BeanBase } from 'vona';
-import { Api, Arg } from 'vona-module-a-openapi';
+import { Api } from 'vona-module-a-openapi';
 import { Database } from 'vona-module-a-orm';
 import { Passport } from 'vona-module-a-user';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
 
 const tableNameFail = '__tempTransactionFail';
 const tableNameSuccess = '__tempTransactionSuccess';

package/src/controller/upload.ts

@@ -3,10 +3,10 @@ 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, Arg, v } from 'vona-module-a-openapi';
+import { Api, v } from 'vona-module-a-openapi';
 import { SymbolUploadValue } from 'vona-module-a-upload';
 import { Passport } from 'vona-module-a-user';
-import { Controller, Web } from 'vona-module-a-web';
+import { Arg, Controller, Web } from 'vona-module-a-web';
 import { z } from 'zod';
 
 export interface IControllerOptionsUpload extends IDecoratorControllerOptions {}

package/src/dto/postQuery.ts

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

package/src/dto/postQueryRes.ts

@@ -0,0 +1,9 @@
+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 IDtoOptionsPostQueryRes extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPostQueryRes>()
+export class DtoPostQueryRes extends $Dto.selectAndCount(() => ModelPost, { include: { postContent: true } }) {}

package/src/service/post.ts

@@ -1,4 +1,5 @@
 import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
 import { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
 import { $relationDynamic, Database } from 'vona-module-a-orm';
@@ -7,6 +8,15 @@ import { ModelPostContent } from '../model/postContent.ts';
 
 @Service()
 export class ServicePost extends BeanBase {
+  async findMany(params: IQueryParams<ModelPost>) {
+    return await this.scope.model.post.selectAndCount(
+      {
+        ...params,
+        include: { postContent: true },
+      },
+    );
+  }
+
   async group() {
     const result = await this.scope.model.post.group({
       groups: 'userId',

package/src/service/user.ts

@@ -6,6 +6,30 @@ import { ModelRoleUser } from '../model/roleUser.ts';
 
 @Service()
 export class ServiceUser extends BeanBase {
+  async userStats() {
+    const userStats = await this.scope.model.user.aggregate({
+      aggrs: {
+        count: '*',
+        sum: 'scores',
+        max: 'age',
+        min: 'age',
+      },
+      where: {
+        scores: { _gt_: 30 },
+      },
+    });
+    return userStats;
+  }
+
+  async findUsers() {
+    const users = await this.scope.model.user.select({
+      where: {
+        age: { _gt_: 18 },
+      },
+    });
+    return users;
+  }
+
   async relationBelongsToMany() {
     // insert: roles
     const roles = await this.scope.model.role.insertBulk([

package/test/captcha.test.ts

@@ -7,7 +7,7 @@ import { app } from 'vona-mock';
 describe('captcha.test.ts', () => {
   // scene/provider
   const sceneName = 'a-captchasimple:simple';
-  const providerName = 'a-captchasimple:simple';
+  const providerName = 'a-captchasimple:imageText';
   it('action:captcha', async () => {
     await app.bean.executor.mockCtx(async () => {
       // create