vona-cli-set-api 1.0.498 → 1.1.3

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/eventListener.emailConfirmCallback.ts

@@ -0,0 +1,23 @@
+import type { IEventExecute, NextEvent } from 'vona-module-a-event';
+import type { TypeEventEmailConfirmCallbackData, TypeEventEmailConfirmCallbackResult } from 'vona-module-a-mailconfirm';
+
+import { BeanBase } from 'vona';
+import { EventListener } from 'vona-module-a-event';
+
+type TypeEventData = TypeEventEmailConfirmCallbackData;
+type TypeEventResult = TypeEventEmailConfirmCallbackResult;
+
+@EventListener({ match: 'a-mailconfirm:emailConfirmCallback' })
+export class EventListenerEmailConfirmCallback extends BeanBase implements IEventExecute<TypeEventData, TypeEventResult> {
+  async execute(data: TypeEventData, _next: NextEvent<TypeEventData, TypeEventResult>): Promise<TypeEventResult> {
+    // check cache
+    if (!data) {
+      return this.scope.locale.ConfirmationEmailExpired();
+    }
+    // activate
+    const user = await this.bean.user.findOneById(data.userId);
+    await this.bean.user.activate(user!);
+    // ok
+    return this.scope.locale.ConfirmationEmailSucceeded();
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/eventListener.passwordResetCallback.ts

@@ -0,0 +1,21 @@
+import type { IEventExecute, NextEvent } from 'vona-module-a-event';
+import type { TypeEventPasswordResetCallbackData, TypeEventPasswordResetCallbackResult } from 'vona-module-a-mailconfirm';
+
+import { BeanBase } from 'vona';
+import { EventListener } from 'vona-module-a-event';
+
+type TypeEventData = TypeEventPasswordResetCallbackData;
+type TypeEventResult = TypeEventPasswordResetCallbackResult;
+
+@EventListener({ match: 'a-mailconfirm:passwordResetCallback' })
+export class EventListenerPasswordResetCallback extends BeanBase implements IEventExecute<TypeEventData, TypeEventResult> {
+  async execute(data: TypeEventData, _next: NextEvent<TypeEventData, TypeEventResult>): Promise<TypeEventResult> {
+    // check cache
+    if (!data) {
+      return this.scope.locale.PasswordResetEmailExpired();
+    }
+    // maybe mock captcha token2 to do secendary verify
+    // todo: redirect to frontend
+    throw new Error('Not Implemented');
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/eventListener.register.ts

@@ -0,0 +1,21 @@
+import type { IEventExecute, NextEvent } from 'vona-module-a-event';
+import type { IUser, TypeEventRegisterData, TypeEventRegisterResult } from 'vona-module-a-user';
+
+import { BeanBase } from 'vona';
+import { EventListener } from 'vona-module-a-event';
+
+type TypeEventData = TypeEventRegisterData;
+type TypeEventResult = TypeEventRegisterResult;
+
+@EventListener({ match: 'a-user:register' })
+export class EventListenerRegister extends BeanBase implements IEventExecute<TypeEventData, TypeEventResult> {
+  async execute(data: TypeEventData, next: NextEvent<TypeEventData, TypeEventResult>): Promise<TypeEventResult> {
+    // next: registered
+    const user = (await next()) as IUser;
+    // mail: activate
+    if (!data.autoActivate && user.email) {
+      await this.bean.mailConfirm.emailConfirm(user);
+    }
+    return user;
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/meta.index.ts

@@ -0,0 +1,14 @@
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+import { $tableColumns } from 'vona-module-a-ormutils';
+
+@Meta<IMetaOptionsIndex>({
+  indexes: {
+    ...$tableColumns('homeUser', 'name'),
+    ...$tableColumns('homeRole', 'name'),
+    ...$tableColumns('homeRoleUser', ['userId', 'roleId']),
+  },
+})
+export class MetaIndex extends BeanBase {}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/meta.version.ts

@@ -0,0 +1,63 @@
+import type { IMetaVersionInit, IMetaVersionInitOptions, 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, IMetaVersionInit {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version === 1) {
+      // homeRole
+      const entityRole = this.scope.entity.role;
+      await this.bean.model.createTable(entityRole.$table, table => {
+        table.comment(entityRole.$comment.$table);
+        table.basicFields();
+        table.string(entityRole.name, 255).comment(entityRole.$comment.name);
+      });
+      // homeUser
+      const entityUser = this.scope.entity.user;
+      await this.bean.model.createTable(entityUser.$table, table => {
+        table.comment(entityUser.$comment.$table);
+        table.basicFields();
+        table.string(entityUser.name, 255).comment(entityUser.$comment.name);
+        table.string(entityUser.avatar, 255).comment(entityUser.$comment.avatar);
+        table.string(entityUser.email, 255).comment(entityUser.$comment.email);
+        table.string(entityUser.mobile, 255).comment(entityUser.$comment.mobile);
+        table.boolean(entityUser.activated).defaultTo(entityUser.$default.activated).comment(entityUser.$comment.activated);
+        table.string(entityUser.locale, 255).comment(entityUser.$comment.locale);
+        table.string(entityUser.tz, 255).comment(entityUser.$comment.tz);
+      });
+      // homeRoleUser
+      const entityRoleUser = this.scope.entity.roleUser;
+      await this.bean.model.createTable(entityRoleUser.$table, table => {
+        table.basicFields();
+        table.tableIdentity('userId');
+        table.tableIdentity('roleId');
+      });
+    }
+  }
+
+  async init(options: IMetaVersionInitOptions) {
+    if (options.version === 1) {
+      // role: admin
+      if (!this.scope.config.disableRoleAdmin) {
+        await this.scope.model.role.insert({
+          name: 'admin',
+        });
+      }
+      // user: admin
+      if (!this.scope.config.disableUserAdmin) {
+        await this.bean.authSimple.authenticate(
+          {
+            username: 'admin',
+            password: options.password || this.scope.config.passwordDefault.admin,
+            avatar: ':emoji:flower',
+            confirmed: true,
+          },
+          'register',
+          'default',
+        );
+      }
+    }
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/zodRefine.emailUnique.ts

@@ -0,0 +1,21 @@
+import type { IDecoratorZodRefineOptions, IZodRefineExecute, TypeRefinementCtx } from 'vona-module-a-zod';
+
+import { BeanBase } from 'vona';
+import { ZodRefine } from 'vona-module-a-zod';
+
+export type TypeZodRefineEmailUniqueData = string;
+
+export interface IZodRefineOptionsEmailUnique extends IDecoratorZodRefineOptions {}
+
+@ZodRefine<IZodRefineOptionsEmailUnique>()
+export class ZodRefineEmailUnique extends BeanBase implements IZodRefineExecute<TypeZodRefineEmailUniqueData> {
+  async execute(value: TypeZodRefineEmailUniqueData, refinementCtx: TypeRefinementCtx, _options: IZodRefineOptionsEmailUnique) {
+    const user = await this.scope.model.user.getByEmailEqI(value);
+    if (user) {
+      refinementCtx.addIssue({
+        code: 'custom',
+        message: this.scope.locale.EmailExists(),
+      });
+    }
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/zodRefine.passwordConfirm.ts

@@ -0,0 +1,24 @@
+import type { IDecoratorZodRefineOptions, IZodRefineExecute, TypeRefinementCtx } from 'vona-module-a-zod';
+
+import { BeanBase } from 'vona';
+import { ZodRefine } from 'vona-module-a-zod';
+
+export interface TypeZodRefinePasswordConfirmData {
+  password: string;
+  passwordConfirm: string;
+}
+
+export interface IZodRefineOptionsPasswordConfirm extends IDecoratorZodRefineOptions {}
+
+@ZodRefine<IZodRefineOptionsPasswordConfirm>()
+export class ZodRefinePasswordConfirm extends BeanBase implements IZodRefineExecute<TypeZodRefinePasswordConfirmData> {
+  async execute(value: TypeZodRefinePasswordConfirmData, refinementCtx: TypeRefinementCtx, _options: IZodRefineOptionsPasswordConfirm) {
+    if (value.password !== value.passwordConfirm) {
+      refinementCtx.addIssue({
+        code: 'custom',
+        message: this.scope.locale.PasswordsNotMatch(),
+        path: ['passwordConfirm'],
+      });
+    }
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/bean/zodRefine.usernameUnique.ts

@@ -0,0 +1,21 @@
+import type { IDecoratorZodRefineOptions, IZodRefineExecute, TypeRefinementCtx } from 'vona-module-a-zod';
+
+import { BeanBase } from 'vona';
+import { ZodRefine } from 'vona-module-a-zod';
+
+export type TypeZodRefineUsernameUniqueData = string;
+
+export interface IZodRefineOptionsUsernameUnique extends IDecoratorZodRefineOptions {}
+
+@ZodRefine<IZodRefineOptionsUsernameUnique>()
+export class ZodRefineUsernameUnique extends BeanBase implements IZodRefineExecute<TypeZodRefineUsernameUniqueData> {
+  async execute(value: TypeZodRefineUsernameUniqueData, refinementCtx: TypeRefinementCtx, _options: IZodRefineOptionsUsernameUnique) {
+    const user = await this.bean.user.findOneByName(value);
+    if (user) {
+      refinementCtx.addIssue({
+        code: 'custom',
+        message: this.scope.locale.UsernameExists(),
+      });
+    }
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/config/config.ts

@@ -0,0 +1,11 @@
+import type { VonaApplication } from 'vona';
+
+export function config(_app: VonaApplication) {
+  return {
+    passwordDefault: {
+      admin: '123456',
+    },
+    disableRoleAdmin: false,
+    disableUserAdmin: false,
+  };
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/config/locale/en-us.ts

@@ -0,0 +1,18 @@
+export default {
+  ConfirmationEmailExpired: 'This email confirmation link has expired',
+  ConfirmationEmailSucceeded: 'Your email address has been confirmed',
+  PasswordResetEmailExpired: 'This password reset link has expired',
+  Role: 'Role',
+  RoleName: 'Role Name',
+  User: 'User',
+  UserName: 'User Name',
+  UserAvatar: 'Avatar',
+  UserEmail: 'Email',
+  UserMobile: 'Mobile',
+  UserActivated: 'Activated',
+  UserLocale: 'Language',
+  UserTz: 'Timezone',
+  UsernameExists: 'Username Exists',
+  EmailExists: 'Email Exists',
+  PasswordsNotMatch: 'Passwords do not match',
+};

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/config/locale/zh-cn.ts

@@ -0,0 +1,18 @@
+export default {
+  ConfirmationEmailExpired: '确认邮件链接已经过期',
+  ConfirmationEmailSucceeded: '您的邮件地址已经确认',
+  PasswordResetEmailExpired: '重置密码链接已经过期',
+  Role: '角色',
+  RoleName: '角色名',
+  User: '用户',
+  UserName: '用户名',
+  UserAvatar: '头像',
+  UserEmail: '电子邮件',
+  UserMobile: '手机号',
+  UserActivated: '已激活',
+  UserLocale: '语言',
+  UserTz: '时区',
+  UsernameExists: '用户名已存在',
+  EmailExists: '电子邮件已存在',
+  PasswordsNotMatch: '密码不一致',
+};

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/controller/passport.ts

@@ -0,0 +1,138 @@
+import type { DtoAuth, IAuthenticateOptions, IAuthProviderRecord } from 'vona-module-a-auth';
+import type { IJwtToken } from 'vona-module-a-jwt';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Core } from 'vona-module-a-core';
+import { DtoJwtToken } from 'vona-module-a-jwt';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Passport } from 'vona-module-a-user';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+import { z } from 'zod';
+
+import type { EntityRole } from '../entity/role.ts';
+import type { EntityUser } from '../entity/user.ts';
+
+import { DtoLogin } from '../dto/login.ts';
+import { DtoPassport } from '../dto/passport.ts';
+import { DtoPassportJwt } from '../dto/passportJwt.ts';
+import { DtoRegister } from '../dto/register.ts';
+
+export interface IControllerOptionsPassport extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsPassport>('passport')
+export class ControllerPassport extends BeanBase {
+  @Web.get('current')
+  @Passport.public()
+  @Api.body(v.optional(), v.object(DtoPassport))
+  current(): DtoPassport | undefined {
+    return this._combineDtoPassport();
+  }
+
+  @Web.post('logout')
+  async logout() {
+    return await this.bean.passport.signout();
+  }
+
+  @Web.post('register')
+  @Passport.public()
+  @Core.captchaVerify({ scene: 'captcha-simple:simple' })
+  @Api.body(v.object(DtoPassportJwt))
+  async register(@Arg.body() data: DtoRegister) {
+    const jwt = await this.bean.authSimple.authenticate(data, 'register', 'default');
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.post('login')
+  @Passport.public()
+  @Core.captchaVerify({ scene: 'captcha-simple:simple' })
+  @Api.body(v.object(DtoPassportJwt))
+  async login(@Arg.body() data: DtoLogin): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.authSimple.authenticate(data, 'login', 'default');
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.get('login/:module/:providerName/:clientName?')
+  @Passport.public()
+  async loginOauth<T extends keyof IAuthProviderRecord>(
+    @Arg.param('module') module: string,
+    @Arg.param('providerName') providerName: string,
+    @Arg.param('clientName', z.string().optional()) clientName?: IAuthenticateOptions<IAuthProviderRecord[T]>['clientName'],
+    @Arg.query('redirect', v.optional()) redirect?: string,
+  ) {
+    // only support oauth, so not return jwt to client
+    await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
+      state: { intention: 'login', redirect },
+      clientName,
+    });
+  }
+
+  @Web.get('associate/:module/:providerName/:clientName?')
+  @Api.body(v.object(DtoPassportJwt))
+  async associate<T extends keyof IAuthProviderRecord>(
+    @Arg.param('module') module: string,
+    @Arg.param('providerName') providerName: string,
+    @Arg.param('clientName', z.string().optional()) clientName?: IAuthenticateOptions<IAuthProviderRecord[T]>['clientName'],
+    @Arg.query('redirect', v.optional()) redirect?: string,
+  ): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
+      state: { intention: 'associate', redirect },
+      clientName,
+    });
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.get('migrate/:module/:providerName/:clientName?')
+  @Api.body(v.object(DtoPassportJwt))
+  async migrate<T extends keyof IAuthProviderRecord>(
+    @Arg.param('module') module: string,
+    @Arg.param('providerName') providerName: string,
+    @Arg.param('clientName', z.string().optional()) clientName?: IAuthenticateOptions<IAuthProviderRecord[T]>['clientName'],
+    @Arg.query('redirect', v.optional()) redirect?: string,
+  ): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
+      state: { intention: 'migrate', redirect },
+      clientName,
+    });
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.post('refreshAuthToken')
+  @Passport.public()
+  @Api.body(v.object(DtoJwtToken))
+  async refreshAuthToken(@Arg.body('refreshToken') refreshToken: string): Promise<DtoJwtToken> {
+    return await this.bean.passport.refreshAuthToken(refreshToken);
+  }
+
+  @Web.post('createPassportJwtFromOauthCode')
+  @Passport.public()
+  @Api.body(v.object(DtoPassportJwt))
+  async createPassportJwtFromOauthCode(@Arg.body('code') code: string): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.passport.createAuthTokenFromOauthCode(code);
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.post('createTempAuthToken')
+  @Api.body(z.string())
+  async createTempAuthToken(@Arg.query('path', v.optional()) path?: string): Promise<string> {
+    return await this.bean.passport.createTempAuthToken({ path });
+  }
+
+  private _combineDtoPassportJwt(jwt?: IJwtToken): DtoPassportJwt {
+    if (!jwt) this.app.throw(403);
+    return {
+      passport: this._combineDtoPassport()!,
+      jwt: jwt as DtoJwtToken,
+    };
+  }
+
+  private _combineDtoPassport(): DtoPassport | undefined {
+    const passport = this.bean.passport.current;
+    if (!passport || !passport.auth) return;
+    return {
+      user: passport.user as EntityUser,
+      auth: passport.auth as DtoAuth,
+      roles: passport.roles as EntityRole[],
+    };
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/dto/login.ts

@@ -0,0 +1,19 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { DtoCaptchaVerify } from 'vona-module-a-captcha';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsLogin extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsLogin>()
+export class DtoLogin {
+  @Api.field(v.required(), v.min(3), v.trim())
+  username: string;
+
+  @Api.field(v.required(), v.min(6))
+  password: string;
+
+  @Api.field(v.required(), v.rest({ iconPrefix: ':editor:code-block' }), v.component('captcha'))
+  captcha: DtoCaptchaVerify;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/dto/passport.ts

@@ -0,0 +1,22 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { DtoAuth } from 'vona-module-a-auth';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { EntityRole } from 'vona-module-home-user';
+
+import { EntityUser } from '../entity/user.ts';
+
+export interface IDtoOptionsPassport extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPassport>()
+export class DtoPassport {
+  @Api.field()
+  user: EntityUser;
+
+  @Api.field()
+  auth: DtoAuth;
+
+  @Api.field(v.array(EntityRole))
+  roles: EntityRole[];
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/dto/passportJwt.ts

@@ -0,0 +1,18 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { DtoJwtToken } from 'vona-module-a-jwt';
+import { Api } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+import { DtoPassport } from './passport.ts';
+
+export interface IDtoOptionsPassportJwt extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPassportJwt>()
+export class DtoPassportJwt {
+  @Api.field()
+  passport: DtoPassport;
+
+  @Api.field()
+  jwt: DtoJwtToken;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/dto/register.ts

@@ -0,0 +1,27 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { DtoCaptchaVerify } from 'vona-module-a-captcha';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsRegister extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsRegister>({
+  pipes: v.refine('home-user:passwordConfirm'),
+})
+export class DtoRegister {
+  @Api.field(v.refine('home-user:usernameUnique'), v.min(3), v.trim())
+  username: string;
+
+  @Api.field(v.refine('home-user:emailUnique'), v.email(), v.trim())
+  email: string;
+
+  @Api.field(v.min(6), v.max(20))
+  password: string;
+
+  @Api.field(v.min(6), v.max(20))
+  passwordConfirm: string;
+
+  @Api.field(v.component('captcha'))
+  captcha: DtoCaptchaVerify;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/entity/role.ts

@@ -0,0 +1,15 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import type { IRole } from 'vona-module-a-user';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsRole extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsRole>('homeRole', { openapi: { title: $locale('Role') } })
+export class EntityRole extends EntityBase implements IRole {
+  @Api.field(v.title($locale('RoleName')))
+  name: string;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/entity/roleUser.ts

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

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/entity/user.ts

@@ -0,0 +1,35 @@
+import type { ILocaleRecord } from 'vona';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import type { IUser } from 'vona-module-a-user';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsUser extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsUser>('homeUser', { openapi: { title: $locale('User') } })
+export class EntityUser extends EntityBase implements IUser {
+  @Api.field(v.title($locale('UserName')))
+  name: string;
+
+  @Api.field(v.title($locale('UserAvatar')), v.optional())
+  avatar?: string;
+
+  @Api.field(v.title($locale('UserEmail')), v.optional())
+  email?: string;
+
+  @Api.field(v.title($locale('UserMobile')), v.optional())
+  mobile?: string;
+
+  @Api.field(v.title($locale('UserActivated')), v.default(false))
+  activated?: boolean;
+
+  @Api.field(v.title($locale('UserLocale')), z.string().optional())
+  locale?: keyof ILocaleRecord | undefined;
+
+  @Api.field(v.title($locale('UserTz')), v.optional())
+  tz?: string;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/index.ts

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

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/model/role.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityRole } from '../entity/role.ts';
+
+export interface IModelOptionsRole extends IDecoratorModelOptions<EntityRole> {}
+
+@Model<IModelOptionsRole>({ entity: EntityRole })
+export class ModelRole extends BeanModelBase<EntityRole> {}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/model/roleUser.ts

@@ -0,0 +1,10 @@
+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/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/model/user.ts

@@ -0,0 +1,26 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityUser } from '../entity/user.ts';
+import { ModelRole } from './role.ts';
+import { ModelRoleUser } from './roleUser.ts';
+
+export interface IModelOptionsUser extends IDecoratorModelOptions<EntityUser> {}
+
+@Model<IModelOptionsUser>({
+  entity: EntityUser,
+  relations: {
+    roles: $relation.belongsToMany(
+      () => ModelRoleUser,
+      () => ModelRole,
+      'userId',
+      'roleId',
+    ),
+  },
+})
+export class ModelUser extends BeanModelBase<EntityUser> {
+  getByEmailEqI(email: string) {
+    return this.get({ email: { _eqI_: email } });
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-user/src/service/passportAdapter.ts

@@ -0,0 +1,34 @@
+import type { IPassport, IPassportAdapter } from 'vona-module-a-user';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { IPayloadDataOfPassport } from '../types/jwt.ts';
+
+@Service()
+export class ServicePassportAdapter extends BeanBase implements IPassportAdapter {
+  async isAdmin(passport: IPassport | undefined): Promise<boolean> {
+    if (!passport) return false;
+    if (passport.roles?.some(role => role.name === 'admin')) return true;
+    return false;
+  }
+
+  async setCurrent(passport: IPassport | undefined): Promise<IPassport | undefined> {
+    return passport;
+  }
+
+  async serialize(passport: IPassport): Promise<IPayloadDataOfPassport> {
+    const userId = passport.user!.id;
+    const authId = passport.auth!.id;
+    return { userId, authId };
+  }
+
+  async deserialize(payloadData: IPayloadDataOfPassport): Promise<IPassport | undefined> {
+    const user = await this.bean.user.findOneById(payloadData.userId);
+    if (!user) return;
+    const auth = await this.bean.auth.findOne({ id: payloadData.authId });
+    if (!auth) return;
+    const roles = await this.bean.role.findAllByUserId(payloadData.userId);
+    return { user, auth, roles };
+  }
+}