vona-module-test-vona 5.0.39 → 5.0.41

package/src/controller/cacheRedis.ts

@@ -0,0 +1,55 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import assert from 'node:assert';
+import { sleep } from '@cabloy/utils';
+import { BeanBase, retry } from 'vona';
+import { Api } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsCacheRedis extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsCacheRedis>({ path: 'cacheRedis', meta: { mode: 'test' } })
+@Api.exclude()
+@Passport.public()
+export class ControllerCacheRedis extends BeanBase {
+  @Web.post()
+  async redis() {
+    let res;
+    let value;
+
+    // getset
+    value = await this.scope.cacheRedis.test.getset('zhen.nann');
+    assert.equal(value, undefined);
+
+    value = await this.scope.cacheRedis.test.getset('zhennann');
+    assert.equal(value, 'zhen.nann');
+
+    // has
+    res = await this.scope.cacheRedis.test.has();
+    assert.equal(res, true);
+
+    // get
+    value = await this.scope.cacheRedis.test.get();
+    assert.equal(value, 'zhennann');
+
+    // del
+    await this.scope.cacheRedis.test.del();
+    res = await this.scope.cacheRedis.test.has();
+    assert.equal(res, false);
+
+    // set again
+    await this.scope.cacheRedis.test.set('zhennann'); // will be expired after 1s
+
+    // get
+    value = await this.scope.cacheRedis.test.get();
+    assert.equal(value, 'zhennann');
+
+    // peek after timeout
+    await sleep(900);
+    await retry({ retries: 3 }, async () => {
+      await sleep(100);
+      value = await this.scope.cacheRedis.test.peek();
+      assert.equal(value, undefined);
+    });
+  }
+}

package/src/controller/dtoTest.ts

@@ -0,0 +1,63 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { Api, Arg, v } from 'vona-module-a-openapi';
+import { $Dto, TableIdentity } from 'vona-module-a-orm';
+import { 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';
+import { DtoUserUpdate } from '../dto/userUpdate.ts';
+
+export interface IControllerOptionsDtoTest extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsDtoTest>('dtoTest', { meta: { mode: ['test', 'dev'] } })
+export class ControllerDtoTest extends BeanBase {
+  @Web.get('getUserLazy')
+  getUserLazy(): DtoUserLazy {
+    return {} as any;
+  }
+
+  @Web.get('getUserDynamic')
+  @Api.body($Dto.get('test-vona:post'))
+  getPostDynamic() {
+  }
+
+  @Web.get('getUserStats')
+  @Api.body($Dto.get('test-vona:userStats'))
+  getUserStats() {
+  }
+
+  @Web.get('getUserStatsGroup')
+  @Api.body($Dto.get('test-vona:userStatsGroup'))
+  getUserStatsGroup() {
+  }
+
+  @Web.post('createUser')
+  createUser(
+    @Arg.body(v.object(DtoUserCreate)) user: DtoUserCreate,
+  ) {
+    return this.scope.model.user.insert(user);
+  }
+
+  @Web.patch('updateUser/:id')
+  updateUser(
+    @Arg.param('id') id: TableIdentity,
+    @Arg.body(v.object(DtoUserUpdate)) user: DtoUserUpdate,
+  ) {
+    return this.scope.model.user.update(user, { where: { id } });
+  }
+
+  @Web.get('getCategoryTree')
+  @Api.body(v.array($Dto.get('test-vona:category', { columns: ['id', 'name'] })))
+  async getCategoryTree() {
+    const items = await this.scope.model.category.select({ columns: ['id', 'name'] });
+    return items;
+  }
+
+  @Web.get('getCategoryTree2')
+  @Api.body(v.array(DtoCategoryTree))
+  async getCategoryTree2() {
+    const items = await this.scope.model.category.select({ columns: ['id', 'name'] });
+    return items;
+  }
+}

package/src/controller/guardPassport.ts

@@ -0,0 +1,25 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsGuardPassport extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsGuardPassport>('guardPassport')
+export class ControllerGuardPassport extends BeanBase {
+  @Web.get('testUserName')
+  @Passport.userName({ name: 'admin' })
+  testUserName() {}
+
+  @Web.get('testUserNameFail')
+  @Passport.userName({ name: 'admin-none' as any })
+  testUserNameFail() {}
+
+  @Web.get('testRoleName')
+  @Passport.roleName({ name: 'admin' })
+  testRoleName() {}
+
+  @Web.get('testRoleNameFail')
+  @Passport.roleName({ name: 'admin-none' as any })
+  testRoleNameFail() {}
+}

package/src/controller/onion.ts

@@ -0,0 +1,92 @@
+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 { Database } from 'vona-module-a-orm';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+import { z } from 'zod';
+import { $locale } from '../.metadata/index.ts';
+import { DtoUser } from '../dto/user.ts';
+
+export interface IControllerOptionsOnion extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsOnion>({ path: 'onion', tags: ['Onion'], meta: { mode: ['dev', 'test'] } })
+export class ControllerOnion extends BeanBase {
+  @Web.get('/')
+  @Aspect.aopMethod('a-orm:transaction', { enable: true, meta: { mode: 'dev' } })
+  @Aspect.guardGlobal('a-user:passport', { public: true })
+  index() {
+    return this.ctx.db.inTransaction;
+    // return 'Hello Vona';
+  }
+
+  @Web.post('//echo')
+  @Aspect.guardGlobal('a-user:passport', { public: true })
+  @Aspect.middlewareGlobal('a-core:gate', { gate: { mode: 'dev' } })
+  @Core.gate({ gate: { mode: 'dev' } })
+  @Aspect.aopMethod('a-orm:transaction', { isolationLevel: 'SERIALIZABLE', readOnly: true })
+  @Database.transaction({ isolationLevel: 'READ_COMMITTED', readOnly: false })
+  @Api.body(v.optional(), z.string())
+  echo(
+    @Arg.query('id', v.default(0), z.number()) id: number,
+    temp: string,
+    @Arg.query('name', z.number().optional()) name: string,
+    @Arg.body(v.title($locale('User')), z.object({ id: z.number().openapi({ title: $locale('UserId') }) }))
+    _user: DtoUser,
+  ): string | undefined {
+    return `echo: ${id}:${temp}:${name}`;
+  }
+
+  @Web.post('echo2/:userId/:userName')
+  // @Aspect.middlewareGlobal('a-core:gate', { gate: { mode: 'dev' } })
+  @Aspect.guardGlobal('a-user:passport', { public: true })
+  // echo2(@Arg.query(v.object(DtoUser, { passthrough: false, strict: false })) book: Partial<DtoUser>) {
+  echo2(
+    @Arg.param('userId', v.title($locale('UserId')), v.example('example:1')) _userId: number,
+    @Arg.param('userName', v.title($locale('UserId')), v.example('example:1')) _userName: string,
+    @Arg.query(DtoUser) _user: DtoUser,
+    @Arg.body(v.title($locale('User')), z.object({ id: z.number().openapi({ title: $locale('UserId') }) }))
+    user: DtoUser,
+  ): DtoUser {
+    // const ctx = this.app.currentContext;
+    // this.$logger.silly(ctx === this.ctx);
+    return user;
+  }
+
+  @Web.get('echo3/:userId')
+  @Aspect.guardGlobal('a-user:passport', { public: true })
+  echo3(
+    @Arg.param('userId') _userId: number,
+    @Arg.query('id', v.optional()) id: number,
+    @Arg.headers('Accept', v.title($locale('UserId'))) accept: string,
+  ) {
+    this.$logger.silly(this.ctx.path);
+    // const ctx = this.app.currentContext;
+    // this.$logger.silly(ctx === this.ctx);
+    return `${id}:${accept}`;
+  }
+
+  @Web.post('echo4')
+  @Aspect.guardGlobal('a-user:passport', { public: true })
+  @Aspect.filterGlobal('a-error:error', { enable: true, logs: { 422: true } })
+  @Api.body(v.array(DtoUser))
+  echo4(@Arg.body(v.optional(), v.array(), v.object(DtoUser)) users: DtoUser[]): DtoUser[] {
+    return users;
+  }
+
+  @Web.get('echo5')
+  @Passport.public()
+  echo5(@Arg.query('ids', v.default([1]), v.array(Number, { separator: '-' })) ids: number[]) {
+    // const ctx = this.app.currentContext;
+    // this.$logger.silly(ctx === this.ctx);
+    return ids;
+  }
+
+  @Web.get('echo6')
+  @Passport.admin()
+  echo6() {
+    return this.bean.passport.isAuthenticated;
+  }
+}

package/src/controller/passport.ts

@@ -0,0 +1,48 @@
+import type { IJwtToken } from 'vona-module-a-jwt';
+import type { IUserBase, IUserNameRecord } from 'vona-module-a-user';
+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 { $getUserName, Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsPassport extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsPassport>({ path: 'passport', meta: { mode: 'test' } })
+@Api.exclude()
+export class ControllerPassport extends BeanBase {
+  @Web.get('echo/:name')
+  @Passport.public()
+  echo(@Arg.param('name') name: string, @Arg.user() user: IUserBase) {
+    assert.equal(name, 'admin');
+    assert.equal($getUserName(user), 'admin');
+    return { name, user };
+  }
+
+  @Web.post('login')
+  @Api.body(v.object(DtoJwtToken))
+  @Passport.public()
+  async login(@Arg.body('name') name: string): Promise<IJwtToken> {
+    const jwt = await this.bean.passport.signinMock(name as keyof IUserNameRecord);
+    return jwt;
+  }
+
+  @Web.get('isAuthenticated')
+  isAuthenticated(): boolean {
+    return this.bean.passport.isAuthenticated;
+  }
+
+  @Web.post('refresh')
+  @Api.body(v.object(DtoJwtToken))
+  @Passport.public()
+  async refresh(@Arg.body('refreshToken') refreshToken: string): Promise<IJwtToken> {
+    return await this.bean.passport.refreshAuthToken(refreshToken);
+  }
+
+  @Web.post('logout')
+  async logout() {
+    return await this.bean.passport.signout();
+  }
+}

package/src/controller/performAction.ts

@@ -0,0 +1,18 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { Api, Arg } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsPerformAction extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsPerformAction>({ path: 'performAction', meta: { mode: 'test' } })
+@Api.exclude()
+export class ControllerPerformAction extends BeanBase {
+  @Web.post('echo')
+  @Passport.public()
+  echo(@Arg.body('id') id: number) {
+    const url = this.scope.util.combineApiPath('performAction/echo');
+    return { id, url };
+  }
+}

package/src/controller/queue.ts

@@ -0,0 +1,25 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import assert from 'node:assert';
+import { BeanBase } from 'vona';
+import { Api } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsQueue extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsQueue>({ path: 'queue', meta: { mode: 'test' } })
+@Api.exclude()
+export class ControllerQueue extends BeanBase {
+  @Web.post('pushAsync')
+  @Passport.public()
+  async pushAsync() {
+    const res = await this.scope.queue.test.pushAsync({ a: 1, b: 2 });
+    assert.equal(res, 3);
+  }
+
+  @Web.post('push')
+  @Passport.public()
+  push() {
+    this.scope.queue.test.push({ a: 1, b: 2 });
+  }
+}

package/src/controller/summer.ts

@@ -0,0 +1,125 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import type { SummerCacheTest, TSummerCacheTestData } from '../bean/summerCache.test.ts';
+import assert from 'node:assert';
+import { sleep } from '@cabloy/utils';
+import { BeanBase, retry } from 'vona';
+import { Api } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+import { __ThisModule__ } from '../.metadata/this.ts';
+
+export interface IControllerOptionsSummer extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsSummer>({ path: 'summer', meta: { mode: 'test' } })
+@Api.exclude()
+export class ControllerSummer extends BeanBase {
+  @Web.post()
+  @Passport.public()
+  async test() {
+    // name
+    const name = 'test';
+    const key1 = { id: 1 };
+    const key2 = { id: 2 };
+    const key3 = { id: 3 };
+
+    // getCache
+    const cache = this.scope.summerCache.test;
+    assert.equal(!!cache, true);
+    let cacheOtherModule = this.$scope.testVona.summerCache.test;
+    assert.equal(cache, cacheOtherModule);
+    cacheOtherModule = this.bean.summer.cache(`${__ThisModule__}.summerCache.${name}`) as SummerCacheTest;
+    assert.equal(cache, cacheOtherModule);
+
+    let value: TSummerCacheTestData | null | undefined;
+    let values: Array<TSummerCacheTestData | null | undefined>;
+
+    // get: peek
+    value = await cache.peek(key1);
+    assert.equal(value, undefined);
+
+    // get
+    value = await cache.get(key1);
+    assert.equal(value?.id, key1.id);
+
+    // get: peek
+    value = await cache.peek(key1);
+    assert.equal(value?.id, key1.id);
+    value = await cache.peek(key1, { mode: 'mem' });
+    assert.equal(value?.id, key1.id);
+    value = await cache.peek(key1, { mode: 'redis' });
+    assert.equal(value?.id, key1.id);
+
+    // get: peek sleep for mem stale
+    await sleep(900);
+
+    // get: peek again
+    value = await cache.peek(key1, { mode: 'redis' });
+    assert.equal(value?.id, key1.id);
+    await retry({ retries: 3 }, async () => {
+      await sleep(100);
+      value = await cache.peek(key1, { mode: 'mem' });
+      assert.equal(value, undefined);
+    });
+
+    // get: peek sleep for redis stale
+    await sleep(1900);
+
+    // get: peek again
+    await retry({ retries: 3 }, async () => {
+      await sleep(100);
+      value = await cache.peek(key1, { mode: 'redis' });
+      assert.equal(value, undefined);
+    });
+    value = await cache.peek(key1, { mode: 'mem' });
+    assert.equal(value, undefined);
+
+    // mget
+    //   mem cache graph: key1
+    value = await cache.get(key1);
+    assert.equal(value?.id, key1.id);
+    //   mem cache graph: key2 key3
+    values = await cache.mget([key1, key2, key3]); // todo: maybe has bug
+    assert.equal(values[0]?.id, key1.id); // todo: maybe has bug
+    assert.equal(values[1]?.id, key2.id);
+    assert.equal(values[2]?.id, key3.id);
+    //   mem cache graph: key3 key1
+    values = await cache.mget([key1, key2, key3]);
+    assert.equal(values[0]?.id, key1.id);
+    assert.equal(values[1]?.id, key2.id);
+    assert.equal(values[2]?.id, key3.id);
+
+    // mget: peek
+    value = await cache.peek(key2, { mode: 'redis' });
+    assert.equal(value?.id, key2.id);
+    value = await cache.peek(key2, { mode: 'mem' });
+    assert.equal(value, undefined);
+
+    // del
+    await cache.del(key1);
+    await cache.del(key2);
+
+    // mdel
+    await cache.mdel([key1, key2, key3]);
+
+    // mdel: peek
+    value = await cache.peek(key3, { mode: 'redis' });
+    assert.equal(value, undefined);
+    value = await cache.peek(key3, { mode: 'mem' });
+    assert.equal(value, undefined);
+
+    // clear
+    values = await cache.mget([key1, key2, key3]);
+    assert.equal(values[2]?.id, key3.id);
+    value = await cache.peek(key3, { mode: 'redis' });
+    assert.equal(value?.id, key3.id);
+    value = await cache.peek(key3, { mode: 'mem' });
+    assert.equal(value?.id, key3.id);
+
+    await cache.clear();
+
+    value = await cache.peek(key3, { mode: 'redis' });
+    assert.equal(value, undefined);
+    value = await cache.peek(key3, { mode: 'mem' });
+    assert.equal(value, undefined);
+  }
+}

package/src/controller/tail.ts

@@ -0,0 +1,32 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import assert from 'node:assert';
+import { BeanBase, cast } from 'vona';
+import { Api } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsTail extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsTail>({ path: 'tail', meta: { mode: 'test' } })
+@Api.exclude()
+export class ControllerTail extends BeanBase {
+  @Web.post()
+  @Passport.public()
+  tail() {
+    // 1
+    cast(this.ctx)._tail_test = 1;
+
+    // tail
+    this.ctx.db.commit(() => {
+      assert.equal(cast(this.ctx)._tail_test_als_caller, undefined);
+      assert.equal(cast(this.ctx)._tail_test, 2);
+      this.ctx.db.commit(() => {
+        assert.equal(cast(this.ctx)._tail_test, 3);
+      });
+      cast(this.ctx)._tail_test = 3;
+    });
+
+    // 2
+    cast(this.ctx)._tail_test = 2;
+  }
+}

package/src/controller/transaction.ts

@@ -0,0 +1,29 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import { BeanBase } from 'vona';
+import { Api, Arg } 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';
+
+const tableNameFail = '__tempTransactionFail';
+const tableNameSuccess = '__tempTransactionSuccess';
+export interface IControllerOptionsTransaction extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsTransaction>({ path: 'transaction', meta: { mode: 'test' } })
+@Api.exclude()
+export class ControllerTransaction extends BeanBase {
+  @Web.post('fail')
+  @Database.transaction()
+  @Passport.public()
+  async fail(@Arg.body() item: object) {
+    await this.bean.model.update(`${tableNameFail}` as any, item);
+    await this.bean.model.update(`${tableNameFail}error` as any, item);
+  }
+
+  @Web.post('success')
+  @Database.transaction()
+  @Passport.public()
+  async success(@Arg.body() item: object) {
+    await this.bean.model.update(tableNameSuccess as any, item);
+  }
+}

package/src/controller/upload.ts

@@ -0,0 +1,57 @@
+import type { IUploadField, IUploadFile } from 'vona-module-a-upload';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import assert from 'node:assert';
+import { BeanBase } from 'vona';
+import { Aspect } from 'vona-module-a-aspect';
+import { Api, Arg, 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 { z } from 'zod';
+
+export interface IControllerOptionsUpload extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsUpload>({ path: 'upload', meta: { mode: ['test', 'dev'] } })
+export class ControllerUpload extends BeanBase {
+  @Web.post('fields')
+  @Passport.public()
+  @Aspect.interceptor('a-upload:upload')
+  @Api.contentType('application/json')
+  fields(
+    @Arg.fields() fields: IUploadField[],
+    @Arg.fields('checkes', v.array(z.string())) checkes: string[],
+    @Arg.field('name', v.default('zhennann'), v.title('your name')) name: string,
+  ) {
+    assert.equal(fields.find(item => item.name === 'name')?.value, 'zhennann');
+    assert.equal(checkes.length > 0, true);
+    assert.equal(name, 'zhennann');
+    return this.ctx[SymbolUploadValue];
+  }
+
+  @Web.post('file')
+  @Passport.public()
+  @Aspect.interceptor('a-upload:upload')
+  @Api.contentType('application/json')
+  file(@Arg.field('name', v.default('zhennann')) name: string, @Arg.file('welcome') file: IUploadFile) {
+    assert.equal(name, 'zhennann');
+    assert.equal(file.name, 'welcome');
+    return this.ctx[SymbolUploadValue];
+  }
+
+  @Web.post('files')
+  @Passport.public()
+  @Aspect.interceptor('a-upload:upload')
+  @Api.contentType('application/json')
+  files(
+    @Arg.files(v.title('more files')) files: IUploadFile[],
+    @Arg.files('images', v.title('images')) images: IUploadFile[],
+    @Arg.file('welcome1', v.title('single file')) file1: IUploadFile,
+    @Arg.file('welcome2')file2: IUploadFile,
+  ) {
+    assert.equal(files.find(item => item.name === 'welcome1')?.name, 'welcome1');
+    assert.equal(images.find(item => item.name === 'images')?.name, 'images');
+    assert.equal(file1.name, 'welcome1');
+    assert.equal(file2.name, 'welcome2');
+    return this.ctx[SymbolUploadValue];
+  }
+}

package/src/dto/categoryTree.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 IDtoOptionsCategoryTree extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCategoryTree>()
+export class DtoCategoryTree extends $Dto.get('test-vona:category', { columns: ['id', 'name'] }) {}

package/src/dto/orderCreate.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ModelOrder } from '../model/order.ts';
+
+export interface IDtoOptionsOrderCreate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsOrderCreate>()
+export class DtoOrderCreate
+  extends $Dto.create(() => ModelOrder, { columns: ['orderNo', 'remark'] }) {}

package/src/dto/orderResult.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 { ModelOrder } from '../model/order.ts';
+
+export interface IDtoOptionsOrderResult extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsOrderResult>()
+export class DtoOrderResult extends $Dto.get(() => ModelOrder) {}

package/src/dto/orderUpdate.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 { ModelOrder } from '../model/order.ts';
+
+export interface IDtoOptionsOrderUpdate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsOrderUpdate>()
+export class DtoOrderUpdate extends $Dto.update(() => ModelOrder, { columns: ['orderNo', 'remark'] }) {}

package/src/dto/postCreate.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 IDtoOptionsPostCreate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPostCreate>({ independent: true })
+export class DtoPostCreate extends $Dto.create(() => ModelPost) {}

package/src/dto/profile.ts

@@ -0,0 +1,14 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsProfile extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsProfile>()
+export class DtoProfile {
+  @Api.field()
+  id: number;
+
+  @Api.field(v.email())
+  email: string;
+}

package/src/dto/roleLazy.ts

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