vona-module-test-vona 5.0.41 → 5.0.43

package/dist/service/category.d.ts

@@ -0,0 +1,5 @@
+import { BeanBase } from 'vona';
+export declare class ServiceCategory extends BeanBase {
+    categoryTreeReverse(): Promise<void>;
+    categoryTree(): Promise<void>;
+}

package/dist/service/post.d.ts

@@ -5,8 +5,8 @@ export declare class ServicePost extends BeanBase {
     relationHasOne(): Promise<void>;
     transaction(): Promise<void>;
     transactionManually(): Promise<void>;
-    create(): Promise<Required<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost, import("vona-module-a-orm").IModelInsertOptions<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost>>>>;
-    createBulk(): Promise<Required<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost, import("vona-module-a-orm").IModelInsertOptions<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost>>>[]>;
+    create(): Promise<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost, import("vona-module-a-orm").IModelInsertOptions<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost>, true>>;
+    createBulk(): Promise<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost, import("vona-module-a-orm").IModelInsertOptions<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost>, true>[]>;
     update(): Promise<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost, import("vona-module-a-orm").IModelUpdateOptions<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost>>>;
     update2(): Promise<import("vona-module-a-orm").TypeModelMutateRelationData<import("vona-module-test-vona").EntityPost, import("vona-module-test-vona").ModelPost, {
         where: {

package/dist/service/user.d.ts

@@ -0,0 +1,4 @@
+import { BeanBase } from 'vona';
+export declare class ServiceUser extends BeanBase {
+    relationBelongsToMany(): Promise<void>;
+}

package/package.json

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

package/src/.metadata/index.ts

@@ -511,8 +511,8 @@ roles: IModelRelationBelongsToMany<'test-vona:roleUser', 'test-vona:role', false
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityCategory,ModelCategory, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityCategory,ModelCategory>>(items: TypeModelMutateRelationData<EntityCategory,ModelCategory, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityCategory,ModelCategory>>(data: TypeModelMutateRelationData<EntityCategory,ModelCategory, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategory, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityCategory,ModelCategory>>(items: TypeModelMutateRelationData<EntityCategory,ModelCategory, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategory, T>[]>;
       delete<T extends IModelDeleteOptions<EntityCategory,ModelCategory>>(where?: TypeModelWhere<EntityCategory>, options?: T): Promise<void>;
@@ -530,8 +530,8 @@ export interface ModelCategoryChain {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityCategory,ModelCategoryChain>>(items: TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityCategory,ModelCategoryChain>>(data: TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>, options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityCategory,ModelCategoryChain>>(items: TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityCategory,ModelCategoryChain, T>[]>;
       delete<T extends IModelDeleteOptions<EntityCategory,ModelCategoryChain>>(where?: TypeModelWhere<EntityCategory>, options?: T): Promise<void>;
@@ -549,8 +549,8 @@ export interface ModelOrder {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityOrder,ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityOrder,ModelOrder>>(data: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityOrder,ModelOrder>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrder, T>[]>;
       delete<T extends IModelDeleteOptions<EntityOrder,ModelOrder>>(where?: TypeModelWhere<EntityOrder>, options?: T): Promise<void>;
@@ -568,8 +568,8 @@ export interface ModelOrderStats {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityOrder,ModelOrderStats>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityOrder,ModelOrderStats>>(data: TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityOrder,ModelOrderStats>>(items: TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityOrder,ModelOrderStats, T>[]>;
       delete<T extends IModelDeleteOptions<EntityOrder,ModelOrderStats>>(where?: TypeModelWhere<EntityOrder>, options?: T): Promise<void>;
@@ -587,8 +587,8 @@ export interface ModelPost {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityPost,ModelPost, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityPost,ModelPost>>(items: TypeModelMutateRelationData<EntityPost,ModelPost, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityPost,ModelPost>>(data: TypeModelMutateRelationData<EntityPost,ModelPost, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPost,ModelPost, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityPost,ModelPost>>(items: TypeModelMutateRelationData<EntityPost,ModelPost, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPost,ModelPost, T>[]>;
       delete<T extends IModelDeleteOptions<EntityPost,ModelPost>>(where?: TypeModelWhere<EntityPost>, options?: T): Promise<void>;
@@ -606,8 +606,8 @@ export interface ModelPostContent {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityPostContent,ModelPostContent>>(items: TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityPostContent,ModelPostContent>>(data: TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>, options?: T): Promise<TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityPostContent,ModelPostContent>>(items: TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityPostContent,ModelPostContent, T>[]>;
       delete<T extends IModelDeleteOptions<EntityPostContent,ModelPostContent>>(where?: TypeModelWhere<EntityPostContent>, options?: T): Promise<void>;
@@ -625,8 +625,8 @@ export interface ModelProduct {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityProduct,ModelProduct, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityProduct,ModelProduct>>(items: TypeModelMutateRelationData<EntityProduct,ModelProduct, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityProduct,ModelProduct>>(data: TypeModelMutateRelationData<EntityProduct,ModelProduct, T>, options?: T): Promise<TypeModelMutateRelationData<EntityProduct,ModelProduct, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityProduct,ModelProduct>>(items: TypeModelMutateRelationData<EntityProduct,ModelProduct, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityProduct,ModelProduct, T>[]>;
       delete<T extends IModelDeleteOptions<EntityProduct,ModelProduct>>(where?: TypeModelWhere<EntityProduct>, options?: T): Promise<void>;
@@ -644,8 +644,8 @@ export interface ModelRole {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityRole,ModelRole, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityRole,ModelRole>>(items: TypeModelMutateRelationData<EntityRole,ModelRole, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityRole,ModelRole>>(data: TypeModelMutateRelationData<EntityRole,ModelRole, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRole,ModelRole, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityRole,ModelRole>>(items: TypeModelMutateRelationData<EntityRole,ModelRole, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRole,ModelRole, T>[]>;
       delete<T extends IModelDeleteOptions<EntityRole,ModelRole>>(where?: TypeModelWhere<EntityRole>, options?: T): Promise<void>;
@@ -663,8 +663,8 @@ export interface ModelRoleUser {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityRoleUser,ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityRoleUser,ModelRoleUser>>(data: TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityRoleUser,ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>[]>;
       delete<T extends IModelDeleteOptions<EntityRoleUser,ModelRoleUser>>(where?: TypeModelWhere<EntityRoleUser>, options?: T): Promise<void>;
@@ -682,8 +682,8 @@ export interface ModelTest {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityTest,ModelTest, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityTest,ModelTest>>(items: TypeModelMutateRelationData<EntityTest,ModelTest, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityTest,ModelTest>>(data: TypeModelMutateRelationData<EntityTest,ModelTest, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTest, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityTest,ModelTest>>(items: TypeModelMutateRelationData<EntityTest,ModelTest, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTest, T>[]>;
       delete<T extends IModelDeleteOptions<EntityTest,ModelTest>>(where?: TypeModelWhere<EntityTest>, options?: T): Promise<void>;
@@ -701,8 +701,8 @@ export interface ModelTestDynamicTable {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityTest,ModelTestDynamicTable>>(items: TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityTest,ModelTestDynamicTable>>(data: TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>, options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityTest,ModelTestDynamicTable>>(items: TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityTest,ModelTestDynamicTable, T>[]>;
       delete<T extends IModelDeleteOptions<EntityTest,ModelTestDynamicTable>>(where?: TypeModelWhere<EntityTest>, options?: T): Promise<void>;
@@ -720,8 +720,8 @@ export interface ModelUser {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityUser,ModelUser, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityUser,ModelUser>>(items: TypeModelMutateRelationData<EntityUser,ModelUser, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityUser,ModelUser>>(data: TypeModelMutateRelationData<EntityUser,ModelUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUser, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityUser,ModelUser>>(items: TypeModelMutateRelationData<EntityUser,ModelUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUser, T>[]>;
       delete<T extends IModelDeleteOptions<EntityUser,ModelUser>>(where?: TypeModelWhere<EntityUser>, options?: T): Promise<void>;
@@ -739,8 +739,8 @@ export interface ModelUserStats {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityUser,ModelUserStats, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityUser,ModelUserStats>>(items: TypeModelMutateRelationData<EntityUser,ModelUserStats, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityUser,ModelUserStats>>(data: TypeModelMutateRelationData<EntityUser,ModelUserStats, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStats, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityUser,ModelUserStats>>(items: TypeModelMutateRelationData<EntityUser,ModelUserStats, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStats, T>[]>;
       delete<T extends IModelDeleteOptions<EntityUser,ModelUserStats>>(where?: TypeModelWhere<EntityUser>, options?: T): Promise<void>;
@@ -758,8 +758,8 @@ export interface ModelUserStatsGroup {
       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>[]>;
       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<Required<TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>>>;
-      insertBulk<T extends IModelInsertOptions<EntityUser,ModelUserStatsGroup>>(items: TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<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>[]>;
       update<T extends IModelUpdateOptions<EntityUser,ModelUserStatsGroup>>(data: TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>>;
       updateBulk<T extends IModelUpdateOptions<EntityUser,ModelUserStatsGroup>>(items: TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUserStatsGroup, T>[]>;
       delete<T extends IModelDeleteOptions<EntityUser,ModelUserStatsGroup>>(where?: TypeModelWhere<EntityUser>, options?: T): Promise<void>;
@@ -818,6 +818,7 @@ declare module 'vona' {
 /** service: begin */
 export * from '../service/aopMethod.ts';
 export * from '../service/caching.ts';
+export * from '../service/category.ts';
 export * from '../service/order.ts';
 export * from '../service/post.ts';
 export * from '../service/test.ts';
@@ -825,6 +826,7 @@ export * from '../service/testApp.ts';
 export * from '../service/testClass.ts';
 export * from '../service/testData.ts';
 export * from '../service/transaction.ts';
+export * from '../service/user.ts';
 
 import 'vona';
 declare module 'vona-module-a-bean' {
@@ -832,6 +834,7 @@ declare module 'vona-module-a-bean' {
     export interface IServiceRecord {
       'test-vona:aopMethod': never;
 'test-vona:caching': never;
+'test-vona:category': never;
 'test-vona:order': never;
 'test-vona:post': never;
 'test-vona:test': never;
@@ -839,6 +842,7 @@ declare module 'vona-module-a-bean' {
 'test-vona:testClass': never;
 'test-vona:testData': never;
 'test-vona:transaction': never;
+'test-vona:user': never;
     }
 
   
@@ -865,6 +869,16 @@ declare module 'vona-module-test-vona' {
             get $onionName(): 'test-vona:caching';
           }
 
+        export interface ServiceCategory {
+          /** @internal */
+          get scope(): ScopeModuleTestVona;
+        }
+
+          export interface ServiceCategory {
+            get $beanFullName(): 'test-vona.service.category';
+            get $onionName(): 'test-vona:category';
+          }
+
         export interface ServiceOrder {
           /** @internal */
           get scope(): ScopeModuleTestVona;
@@ -933,12 +947,23 @@ declare module 'vona-module-test-vona' {
           export interface ServiceTransaction {
             get $beanFullName(): 'test-vona.service.transaction';
             get $onionName(): 'test-vona:transaction';
+          }
+
+        export interface ServiceUser {
+          /** @internal */
+          get scope(): ScopeModuleTestVona;
+        }
+
+          export interface ServiceUser {
+            get $beanFullName(): 'test-vona.service.user';
+            get $onionName(): 'test-vona:user';
           } 
 }
 /** service: end */
 /** service: begin */
 import type { ServiceAopMethod } from '../service/aopMethod.ts';
 import type { ServiceCaching } from '../service/caching.ts';
+import type { ServiceCategory } from '../service/category.ts';
 import type { ServiceOrder } from '../service/order.ts';
 import type { ServicePost } from '../service/post.ts';
 import type { ServiceTest } from '../service/test.ts';
@@ -946,9 +971,11 @@ import type { ServiceTestApp } from '../service/testApp.ts';
 import type { ServiceTestClass } from '../service/testClass.ts';
 import type { ServiceTestData } from '../service/testData.ts';
 import type { ServiceTransaction } from '../service/transaction.ts';
+import type { ServiceUser } from '../service/user.ts';
 export interface IModuleService {
   'aopMethod': ServiceAopMethod;
 'caching': ServiceCaching;
+'category': ServiceCategory;
 'order': ServiceOrder;
 'post': ServicePost;
 'test': ServiceTest;
@@ -956,6 +983,7 @@ export interface IModuleService {
 'testClass': ServiceTestClass;
 'testData': ServiceTestData;
 'transaction': ServiceTransaction;
+'user': ServiceUser;
 }
 /** service: end */
 /** service: begin */
@@ -965,6 +993,7 @@ declare module 'vona' {
   export interface IBeanRecordGeneral {
     'test-vona.service.aopMethod': ServiceAopMethod;
 'test-vona.service.caching': ServiceCaching;
+'test-vona.service.category': ServiceCategory;
 'test-vona.service.order': ServiceOrder;
 'test-vona.service.post': ServicePost;
 'test-vona.service.test': ServiceTest;
@@ -972,6 +1001,7 @@ declare module 'vona' {
 'test-vona.service.testClass': ServiceTestClass;
 'test-vona.service.testData': ServiceTestData;
 'test-vona.service.transaction': ServiceTransaction;
+'test-vona.service.user': ServiceUser;
   }
 }
 /** service: end */

package/src/bean/queue.test.ts

@@ -13,6 +13,8 @@ export class QueueTest
   extends BeanQueueBase<TypeQueueTestJobData, TypeQueueTestJobResult>
   implements IQueueExecute<TypeQueueTestJobData, TypeQueueTestJobResult> {
   async execute(data: TypeQueueTestJobData, _options?: IQueuePushOptions): Promise<TypeQueueTestJobResult> {
-    return data.a + data.b;
+    const res = data.a + data.b;
+    this.$logger.silly(`queue test worker done: ${data.a} + ${data.b} = ${res}`);
+    return res;
   }
 }

package/src/controller/queue.ts

@@ -14,12 +14,13 @@ export class ControllerQueue extends BeanBase {
   @Passport.public()
   async pushAsync() {
     const res = await this.scope.queue.test.pushAsync({ a: 1, b: 2 });
+    this.$logger.silly(`queue test await done: 1 + 2 = ${res}`);
     assert.equal(res, 3);
   }
 
   @Web.post('push')
   @Passport.public()
   push() {
-    this.scope.queue.test.push({ a: 1, b: 2 });
+    this.scope.queue.test.push({ a: 2, b: 3 });
   }
 }

package/src/model/category.ts

@@ -8,7 +8,10 @@ export interface IModelOptionsCategory extends IDecoratorModelOptions<EntityCate
 @Model<IModelOptionsCategory>({
   entity: EntityCategory,
   relations: {
-    children: $relation.hasMany(() => ModelCategory, 'categoryIdParent', { autoload: true, columns: ['id', 'name'] }),
+    children: $relation.hasMany(() => ModelCategory, 'categoryIdParent', {
+      autoload: true,
+      columns: ['id', 'name'],
+    }),
   },
   cache: {
     modelsClear: () => ModelCategoryChain,

package/src/service/category.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceCategory extends BeanBase {
+  async categoryTreeReverse() {
+    // create
+    const treeCreate = await this.scope.model.category.insert({
+      name: 'Category-1',
+      children: [
+        {
+          name: 'Category-1-1',
+          children: [
+            { name: 'Category-1-1-1' },
+          ],
+        },
+        {
+          name: 'Category-1-2',
+        },
+      ],
+    });
+    // 'Category-1-1-1'
+    const subCategoryId = treeCreate.children?.[0].children?.[0].id;
+    // get: reverse
+    const subCategory = await this.scope.model.categoryChain.get({
+      id: subCategoryId,
+    });
+    assert.equal(subCategory?.parent?.parent?.id, treeCreate.id);
+  }
+
+  async categoryTree() {
+    // create
+    const treeCreate = await this.scope.model.category.insert({
+      name: 'Category-1',
+      children: [
+        {
+          name: 'Category-1-1',
+          children: [
+            { name: 'Category-1-1-1' },
+          ],
+        },
+        {
+          name: 'Category-1-2',
+        },
+      ],
+    });
+    // get
+    const tree = await this.scope.model.category.get({
+      id: treeCreate.id,
+    });
+    assert.equal(tree?.children.length, 2);
+    assert.equal(tree?.children[0].children.length, 1);
+    // update
+    await this.scope.model.category.update({
+      id: treeCreate.id,
+      name: 'Category-1-Update',
+      children: [
+        // create
+        { name: 'Category-1-3' },
+        // update
+        { id: treeCreate.children?.[0].id, name: 'Category-1-1-Update' },
+        // delete
+        { id: treeCreate.children?.[1].id, deleted: true },
+      ],
+    });
+    // delete
+    await this.scope.model.category.delete({
+      id: treeCreate.id,
+    });
+  }
+}

package/src/service/order.ts

@@ -39,9 +39,9 @@ export class ServiceOrder extends BeanBase {
           // create product: Peach
           { name: 'Peach' },
           // update product: Apple
-          { id: orderCreate.products[0].id, name: 'Apple-Update' },
+          { id: orderCreate.products?.[0].id, name: 'Apple-Update' },
           // delete product: Pear
-          { id: orderCreate.products[1].id, deleted: true },
+          { id: orderCreate.products?.[1].id, deleted: true },
         ],
       },
       {

package/src/service/user.ts

@@ -0,0 +1,68 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceUser extends BeanBase {
+  async relationBelongsToMany() {
+    // insert: roles
+    const roles = await this.scope.model.role.insertBulk([
+      { name: 'role-family' },
+      { name: 'role-friend' },
+    ]);
+    const roleIdFamily = roles[0].id;
+    const roleIdFriend = roles[1].id;
+    // insert: user
+    const userCreate = await this.scope.model.user.insert(
+      {
+        name: 'Tom',
+        roles: [{
+          id: roleIdFamily,
+        }],
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+    // get: user
+    await this.scope.model.user.get(
+      {
+        id: userCreate.id,
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+    // update: user
+    await this.scope.model.user.update(
+      {
+        id: userCreate.id,
+        roles: [
+          // delete
+          { id: roleIdFamily, deleted: true },
+          // insert
+          { id: roleIdFriend },
+        ],
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+    // delete: user
+    await this.scope.model.user.delete(
+      {
+        id: userCreate.id,
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+  }
+}