vona-module-test-vona 5.0.38 → 5.0.41

package/src/dto/user.ts

@@ -0,0 +1,19 @@
+import type { TableIdentity } from 'vona-module-a-orm';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+import { $locale } from '../.metadata/index.ts';
+
+export interface IDtoOptionsUser extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsUser>({ openapi: { title: $locale('User') } })
+export class DtoUser {
+  @Api.field(v.title($locale('UserId')), v.tableIdentity())
+  id: TableIdentity;
+
+  @Api.field(v.min(3))
+  name: string;
+
+  @Api.field()
+  married: boolean;
+}

package/src/dto/userCreate.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsUserCreate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsUserCreate>({ independent: true })
+export class DtoUserCreate extends $Dto.create('test-vona:user', { include: { roles: true, posts: true } }) {}

package/src/dto/userLazy.ts

@@ -0,0 +1,18 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+import { DtoRoleLazy } from './roleLazy.ts';
+
+export interface IDtoOptionsUserLazy extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsUserLazy>()
+export class DtoUserLazy {
+  @Api.field()
+  name: string;
+
+  @Api.field(v.lazy(v.optional(), () => DtoUserLazy))
+  user?: DtoUserLazy;
+
+  @Api.field(v.optional(), v.array(v.lazy(() => DtoRoleLazy)))
+  roles?: DtoRoleLazy[];
+}

package/src/dto/userUpdate.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsUserUpdate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsUserUpdate>()
+export class DtoUserUpdate extends $Dto.update('test-vona:user', { include: { posts: true } }) {}

package/src/entity/category.ts

@@ -0,0 +1,14 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+export interface IEntityOptionsCategory extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsCategory>('testVonaCategory')
+export class EntityCategory extends EntityBase {
+  @Api.field()
+  name: string;
+
+  @Api.field(v.optional(), v.tableIdentity())
+  categoryIdParent?: TableIdentity;
+}

package/src/entity/order.ts

@@ -0,0 +1,18 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { $locale } from '../.metadata/index.ts';
+
+export interface IEntityOptionsOrder extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsOrder>('testVonaOrder', { openapi: { title: $locale('Order') } })
+export class EntityOrder extends EntityBase {
+  @Api.field(v.openapi({ title: $locale('OrderNo') }), v.default(''), v.min(3))
+  orderNo: string;
+
+  @Api.field(v.openapi({ title: $locale('Remark') }), v.optional())
+  remark?: string;
+
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+}

package/src/entity/post.ts

@@ -0,0 +1,17 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+export interface IEntityOptionsPost extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsPost>('testVonaPost')
+export class EntityPost extends EntityBase {
+  @Api.field()
+  title: string;
+
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(v.optional())
+  stars?: number;
+}

package/src/entity/postContent.ts

@@ -0,0 +1,14 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+export interface IEntityOptionsPostContent extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsPostContent>('testVonaPostContent')
+export class EntityPostContent extends EntityBase {
+  @Api.field()
+  content: string;
+
+  @Api.field(v.tableIdentity())
+  postId: TableIdentity;
+}

package/src/entity/product.ts

@@ -0,0 +1,24 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { $locale } from '../.metadata/index.ts';
+
+export interface IEntityOptionsProduct extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsProduct>('testVonaProduct', { independent: true })
+export class EntityProduct extends EntityBase {
+  @Api.field(v.openapi({ title: $locale('Name') }))
+  name: string;
+
+  @Api.field(v.title($locale('Price')))
+  price: number;
+
+  @Api.field(v.title($locale('Quantity')))
+  quantity: number;
+
+  @Api.field(v.title($locale('Amount')))
+  amount: number;
+
+  @Api.field(v.tableIdentity())
+  orderId: TableIdentity;
+}

package/src/entity/role.ts

@@ -0,0 +1,11 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { Api } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+export interface IEntityOptionsRole extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsRole>('testVonaRole')
+export class EntityRole extends EntityBase {
+  @Api.field()
+  name: string;
+}

package/src/entity/roleUser.ts

@@ -0,0 +1,14 @@
+import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+export interface IEntityOptionsRoleUser extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsRoleUser>('testVonaRoleUser')
+export class EntityRoleUser extends EntityBase {
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  roleId: TableIdentity;
+}

package/src/entity/test.ts

@@ -0,0 +1,18 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { $locale } from '../.metadata/index.ts';
+
+export interface IEntityOptionsTest extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsTest>('testVonaTest', { openapi: { title: $locale('Test') } })
+export class EntityTest extends EntityBase {
+  @Api.field(v.title($locale('Test')))
+  title: string;
+
+  @Api.field()
+  description: string;
+
+  @Api.field(v.default(() => { return new Date(); }))
+  testDate: Date;
+}

package/src/entity/user.ts

@@ -0,0 +1,17 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+export interface IEntityOptionsUser extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsUser>('testVonaUser')
+export class EntityUser extends EntityBase {
+  @Api.field()
+  name: string;
+
+  @Api.field(v.optional())
+  age?: number;
+
+  @Api.field(v.optional())
+  scores?: number;
+}

package/src/index.ts

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

package/src/model/category.ts

@@ -0,0 +1,17 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { ModelCategoryChain } from 'vona-module-test-vona';
+import { EntityCategory } from '../entity/category.ts';
+
+export interface IModelOptionsCategory extends IDecoratorModelOptions<EntityCategory> {}
+
+@Model<IModelOptionsCategory>({
+  entity: EntityCategory,
+  relations: {
+    children: $relation.hasMany(() => ModelCategory, 'categoryIdParent', { autoload: true, columns: ['id', 'name'] }),
+  },
+  cache: {
+    modelsClear: () => ModelCategoryChain,
+  },
+})
+export class ModelCategory extends BeanModelBase<EntityCategory> {}

package/src/model/categoryChain.ts

@@ -0,0 +1,16 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityCategory } from '../entity/category.ts';
+
+export interface IModelOptionsCategoryChain extends IDecoratorModelOptions<EntityCategory> {}
+
+@Model<IModelOptionsCategoryChain>({
+  entity: EntityCategory,
+  relations: {
+    parent: $relation.belongsTo(() => ModelCategoryChain, () => ModelCategoryChain, 'categoryIdParent', {
+      autoload: true,
+      columns: ['id', 'name', 'categoryIdParent'],
+    }),
+  },
+})
+export class ModelCategoryChain extends BeanModelBase<EntityCategory> {}

package/src/model/order.ts

@@ -0,0 +1,26 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityOrder } from '../entity/order.ts';
+import { ModelOrderStats } from './orderStats.ts';
+import { ModelProduct } from './product.ts';
+import { ModelUser } from './user.ts';
+
+export interface IModelOptionsOrder extends IDecoratorModelOptions<EntityOrder> {}
+
+@Model<IModelOptionsOrder>({
+  entity: EntityOrder,
+  relations: {
+    user: $relation.belongsTo(() => ModelOrder, () => ModelUser, 'userId', {
+      autoload: true,
+      columns: ['id', 'name'],
+    }),
+    products: $relation.hasMany(() => ModelProduct, 'orderId', {
+      autoload: true,
+      columns: ['id', 'name', 'price', 'quantity', 'amount'],
+    }),
+  },
+  cache: {
+    modelsClear: () => ModelOrderStats,
+  },
+})
+export class ModelOrder extends BeanModelBase<EntityOrder> {}

package/src/model/orderStats.ts

@@ -0,0 +1,27 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityOrder } from '../entity/order.ts';
+import { ModelProduct } from './product.ts';
+
+export interface IModelOptionsOrderStats extends IDecoratorModelOptions<EntityOrder> {}
+
+@Model<IModelOptionsOrderStats>({
+  entity: EntityOrder,
+  relations: {
+    productStats: $relation.hasMany(() => ModelProduct, 'orderId', {
+      autoload: true,
+      aggrs: {
+        count: '*',
+        sum: 'amount',
+      },
+    }),
+    productsGroups: $relation.hasMany(() => ModelProduct, 'orderId', {
+      groups: 'id',
+      aggrs: {
+        count: '*',
+        sum: 'amount',
+      },
+    }),
+  },
+})
+export class ModelOrderStats extends BeanModelBase<EntityOrder> {}

package/src/model/post.ts

@@ -0,0 +1,16 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityPost } from '../entity/post.ts';
+import { ModelPostContent } from './postContent.ts';
+import { ModelUser } from './user.ts';
+
+export interface IModelOptionsPost extends IDecoratorModelOptions<EntityPost> {}
+
+@Model<IModelOptionsPost>({
+  entity: EntityPost,
+  relations: {
+    postContent: $relation.hasOne(ModelPostContent, 'postId', { columns: ['id', 'content'] }),
+    user: $relation.belongsTo(() => ModelPost, () => ModelUser, 'userId', { autoload: true, columns: ['id', 'name'] }),
+  },
+})
+export class ModelPost extends BeanModelBase<EntityPost> {}

package/src/model/postContent.ts

@@ -0,0 +1,17 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityPostContent } from '../entity/postContent.ts';
+import { ModelPost } from './post.ts';
+
+export interface IModelOptionsPostContent extends IDecoratorModelOptions<EntityPostContent> {}
+
+@Model<IModelOptionsPostContent>({
+  entity: EntityPostContent,
+  relations: {
+    post: $relation.belongsTo(() => ModelPostContent, () => ModelPost, 'postId'),
+  },
+  cache: {
+    modelsClear: () => ModelPost,
+  },
+})
+export class ModelPostContent extends BeanModelBase<EntityPostContent> {}

package/src/model/product.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityProduct } from '../entity/product.ts';
+
+export interface IModelOptionsProduct extends IDecoratorModelOptions<EntityProduct> {}
+
+@Model<IModelOptionsProduct>({ entity: EntityProduct })
+export class ModelProduct extends BeanModelBase<EntityProduct> {}

package/src/model/role.ts

@@ -0,0 +1,15 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityRole } from '../entity/role.ts';
+import { ModelRoleUser } from './roleUser.ts';
+import { ModelUser } from './user.ts';
+
+export interface IModelOptionsRole extends IDecoratorModelOptions<EntityRole> {}
+
+@Model<IModelOptionsRole>({
+  entity: EntityRole,
+  relations: {
+    users: $relation.belongsToMany(() => ModelRoleUser, () => ModelUser, 'roleId', 'userId', { columns: ['id', 'name'] }),
+  },
+})
+export class ModelRole extends BeanModelBase<EntityRole> {}

package/src/model/roleUser.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityRoleUser } from '../entity/roleUser.ts';
+
+export interface IModelOptionsRoleUser extends IDecoratorModelOptions<EntityRoleUser> {}
+
+@Model<IModelOptionsRoleUser>({ entity: EntityRoleUser })
+export class ModelRoleUser extends BeanModelBase<EntityRoleUser> {}

package/src/model/test.ts

@@ -0,0 +1,8 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityTest } from '../entity/test.ts';
+
+export interface IModelOptionsTest extends IDecoratorModelOptions<EntityTest> {}
+
+@Model<IModelOptionsTest>({ entity: EntityTest, client: 'default' })
+export class ModelTest extends BeanModelBase<EntityTest> {}

package/src/model/testDynamicTable.ts

@@ -0,0 +1,21 @@
+import type { VonaContext } from 'vona';
+import type { IDecoratorModelOptions, ITableRecord } from 'vona-module-a-orm';
+import moment from 'moment';
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityTest } from '../entity/test.ts';
+
+export interface IModelOptionsTestDynamicTable extends IDecoratorModelOptions<EntityTest> {}
+
+@Model<IModelOptionsTestDynamicTable>({
+  entity: EntityTest,
+  table(ctx: VonaContext, defaultTable: keyof ITableRecord) {
+    if (ctx.instanceName !== '') return defaultTable;
+    return `${defaultTable}_${moment().format('YYYYMMDD')}`;
+  },
+  softDeletionPrune: {
+    handler: async (_ctx, _modelInstance: ModelTestDynamicTable) => {
+      // do nothing
+    },
+  },
+})
+export class ModelTestDynamicTable extends BeanModelBase<EntityTest> {}

package/src/model/user.ts

@@ -0,0 +1,21 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityUser } from '../entity/user.ts';
+import { ModelPost } from './post.ts';
+import { ModelPostContent } from './postContent.ts';
+import { ModelUserStats } from './userStats.ts';
+import { ModelUserStatsGroup } from './userStatsGroup.ts';
+
+export interface IModelOptionsUser extends IDecoratorModelOptions<EntityUser> {}
+
+@Model<IModelOptionsUser>({
+  entity: EntityUser,
+  relations: {
+    posts: $relation.hasMany(() => ModelPost, 'userId', { columns: ['id', 'title'] }, ['test-vona:user', ModelPostContent]),
+    roles: $relation.belongsToMany('test-vona:roleUser', 'test-vona:role', 'userId', 'roleId', { columns: ['id', 'name'] }),
+  },
+  cache: {
+    modelsClear: [() => ModelUserStats, () => ModelUserStatsGroup],
+  },
+})
+export class ModelUser extends BeanModelBase<EntityUser> {}

package/src/model/userStats.ts

@@ -0,0 +1,15 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityUser } from '../entity/user.ts';
+import { ModelPost } from './post.ts';
+
+export interface IModelOptionsUserStats extends IDecoratorModelOptions<EntityUser> {}
+
+@Model<IModelOptionsUserStats>({
+  entity: EntityUser,
+  relations: {
+    posts: $relation.hasMany(() => ModelPost, 'userId', { autoload: true, aggrs: { count: ['*', 'title'], sum: 'stars' } }),
+    roles: $relation.belongsToMany('test-vona:roleUser', 'test-vona:role', 'userId', 'roleId', { aggrs: { count: '*' } }),
+  },
+})
+export class ModelUserStats extends BeanModelBase<EntityUser> {}

package/src/model/userStatsGroup.ts

@@ -0,0 +1,15 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+import { EntityUser } from '../entity/user.ts';
+import { ModelPost } from './post.ts';
+
+export interface IModelOptionsUserStatsGroup extends IDecoratorModelOptions<EntityUser> {}
+
+@Model<IModelOptionsUserStatsGroup>({
+  entity: EntityUser,
+  relations: {
+    posts: $relation.hasMany(() => ModelPost, 'userId', { autoload: true, groups: ['title'], aggrs: { count: ['*', 'title'], sum: 'stars' }, orders: [['title', 'desc']] }, undefined, true),
+    roles: $relation.belongsToMany('test-vona:roleUser', 'test-vona:role', 'userId', 'roleId', { groups: ['name'], aggrs: { count: '*' }, orders: [['name', 'asc']] }, undefined, true),
+  },
+})
+export class ModelUserStatsGroup extends BeanModelBase<EntityUser> {}

package/src/service/aopMethod.ts

@@ -0,0 +1,38 @@
+import { BeanBase } from 'vona';
+import { Aspect } from 'vona-module-a-aspect';
+import { Service } from 'vona-module-a-bean';
+
+class ServiceAopMethodBase extends BeanBase {
+  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
+  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
+  testSyncBase() {
+    return 'hello';
+  }
+}
+
+@Service()
+export class ServiceAopMethod extends ServiceAopMethodBase {
+  private _name: string = '';
+
+  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
+  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
+  testSync() {
+    return 'hello';
+  }
+
+  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
+  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
+  async testAsync() {
+    return 'hello';
+  }
+
+  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
+  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
+  get name() {
+    return this._name;
+  }
+
+  set name(value) {
+    this._name = value;
+  }
+}

package/src/service/caching.ts

@@ -0,0 +1,75 @@
+import type { TypeCachingActionOptions } from 'vona-module-a-caching';
+import type { TSummerCacheTestData } from '../bean/summerCache.test.ts';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { getKeyHash } from 'vona-module-a-cache';
+import { Caching } from 'vona-module-a-caching';
+
+function cacheKeyFn(this: ServiceCaching, args: [], prop: string, options: TypeCachingActionOptions): any {
+  return `${this.$beanFullName}_${options.cacheProp ?? prop}_${getKeyHash(args)}`;
+}
+
+@Service()
+export class ServiceCaching extends BeanBase {
+  cacheKey(args: any[], prop: string, options: TypeCachingActionOptions) {
+    return `${this.$beanFullName}_${options.cacheProp ?? prop}_${getKeyHash(args)}`;
+  }
+
+  cacheKeySet(args: any[], prop: string, options: TypeCachingActionOptions) {
+    return `${this.$beanFullName}_${options.cacheProp ?? prop}_${getKeyHash(args.slice(0, -1))}`;
+  }
+
+  cacheValueSet(_value: any, args: any[], _prop: string, _options: TypeCachingActionOptions) {
+    return args[args.length - 1];
+  }
+
+  @Caching.get({ cacheName: 'test-vona:test', cacheProp: 'test', cacheKeyFn: 'cacheKey' })
+  async get(id: number): Promise<TSummerCacheTestData> {
+    return {
+      id,
+      name: `name_${id}`,
+    };
+  }
+
+  @Caching.get({ cacheName: 'test-vona:test', cacheProp: 'test', cacheKeyFn })
+  async get2(_id: number): Promise<TSummerCacheTestData> {
+    return undefined as any;
+  }
+
+  @Caching.get({ cacheName: 'test-vona:test', cacheProp: 'test', cacheKey: 'cel://join([get(self,"$beanFullName"),options.cacheProp,hashkey(args)],"_")' })
+  async get3(_id: number): Promise<TSummerCacheTestData> {
+    return undefined as any;
+  }
+
+  // default cacheKey
+  @Caching.get({ cacheName: 'test-vona:test', cacheProp: 'test' })
+  async get4(_id: number): Promise<TSummerCacheTestData> {
+    return undefined as any;
+  }
+
+  @Caching.set({ cacheName: 'test-vona:test', cacheProp: 'test', cacheKeyFn: 'cacheKeySet', cacheValueFn: 'cacheValueSet' })
+  async set(_id: number, _value: TSummerCacheTestData): Promise<void> {
+    // do nothing
+  }
+
+  //
+  @Caching.set({ cacheName: 'test-vona:test', cacheProp: 'test', cacheKey: 'cel://join([get(self,"$beanFullName"),options.cacheProp,hashkey([args[0]])],"_")', cacheValue: 'cel://{"id": args[1].id, "name": args[1].name}' })
+  async set2(_id: number, _value: TSummerCacheTestData): Promise<void> {
+    // do nothing
+  }
+
+  @Caching.set({ cacheName: 'test-vona:test', cacheProp: 'test', cacheKeyFn: 'cacheKeySet' })
+  async set3(_id: number, value: TSummerCacheTestData): Promise<TSummerCacheTestData> {
+    return value;
+  }
+
+  @Caching.del({ cacheName: 'test-vona:test', cacheProp: 'test' })
+  async del(_id: number): Promise<void> {
+    // do nothing
+  }
+
+  @Caching.clear({ cacheName: 'test-vona:test' })
+  async clear(): Promise<void> {
+    // do nothing
+  }
+}

package/src/service/order.ts

@@ -0,0 +1,65 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceOrder extends BeanBase {
+  async relationHasMany() {
+    // insert
+    const orderCreate = await this.scope.model.order.insert(
+      {
+        orderNo: 'Order001',
+        products: [
+          { name: 'Apple' },
+          { name: 'Pear' },
+        ],
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+    // get
+    await this.scope.model.order.get(
+      {
+        id: orderCreate.id,
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+    // update
+    await this.scope.model.order.update(
+      {
+        id: orderCreate.id,
+        orderNo: 'Order001-Update',
+        products: [
+          // create product: Peach
+          { name: 'Peach' },
+          // update product: Apple
+          { id: orderCreate.products[0].id, name: 'Apple-Update' },
+          // delete product: Pear
+          { id: orderCreate.products[1].id, deleted: true },
+        ],
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+    // delete
+    await this.scope.model.order.delete(
+      {
+        id: orderCreate.id,
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+  }
+}