cabloy 5.1.136 → 5.1.138

package/vona/src/suite/a-home/modules/home-user/src/bean/cacheRedis.activation.ts

@@ -0,0 +1,21 @@
+import type { TableIdentity } from 'table-identity';
+
+import { CacheRedis, ServiceCacheRedisBase } from 'vona-module-a-cache';
+
+export type TCacheRedisActivationKey = string;
+
+export interface TCacheRedisActivationData {
+  purpose: 'account-activation';
+  userId: TableIdentity;
+  consumerPath: '/home/user/activation';
+  email: string;
+}
+
+@CacheRedis({
+  ttl: 15 * 60 * 1000,
+  disableTransactionCompensate: true,
+})
+export class CacheRedisActivation extends ServiceCacheRedisBase<
+  TCacheRedisActivationKey,
+  TCacheRedisActivationData
+> {}

package/vona/src/suite/a-home/modules/home-user/src/bean/cacheRedis.activationCurrent.ts

@@ -0,0 +1,15 @@
+import type { TableIdentity } from 'table-identity';
+
+import { CacheRedis, ServiceCacheRedisBase } from 'vona-module-a-cache';
+
+export type TCacheRedisActivationCurrentKey = TableIdentity;
+export type TCacheRedisActivationCurrentData = string;
+
+@CacheRedis({
+  ttl: 15 * 60 * 1000,
+  disableTransactionCompensate: true,
+})
+export class CacheRedisActivationCurrent extends ServiceCacheRedisBase<
+  TCacheRedisActivationCurrentKey,
+  TCacheRedisActivationCurrentData
+> {}

package/vona/src/{suite-vendor/a-vona/modules/a-mailconfirm → suite/a-home/modules/home-user}/src/bean/cacheRedis.passwordReset.ts

@@ -1,14 +1,18 @@
 import type { TableIdentity } from 'table-identity';
 
-import { ServiceCacheRedisBase, CacheRedis } from 'vona-module-a-cache';
+import { CacheRedis, ServiceCacheRedisBase } from 'vona-module-a-cache';
 
 export type TCacheRedisPasswordResetKey = string;
+
 export interface TCacheRedisPasswordResetData {
+  purpose: 'password-reset';
   userId: TableIdentity;
+  consumerPath: '/home/user/password-reset';
 }
 
 @CacheRedis({
-  ttl: 30 * 60 * 1000, // 30 minutes
+  ttl: 15 * 60 * 1000,
+  disableTransactionCompensate: true,
 })
 export class CacheRedisPasswordReset extends ServiceCacheRedisBase<
   TCacheRedisPasswordResetKey,

package/vona/src/suite/a-home/modules/home-user/src/bean/cacheRedis.passwordResetCurrent.ts

@@ -0,0 +1,15 @@
+import type { TableIdentity } from 'table-identity';
+
+import { CacheRedis, ServiceCacheRedisBase } from 'vona-module-a-cache';
+
+export type TCacheRedisPasswordResetCurrentKey = TableIdentity;
+export type TCacheRedisPasswordResetCurrentData = string;
+
+@CacheRedis({
+  ttl: 15 * 60 * 1000,
+  disableTransactionCompensate: true,
+})
+export class CacheRedisPasswordResetCurrent extends ServiceCacheRedisBase<
+  TCacheRedisPasswordResetCurrentKey,
+  TCacheRedisPasswordResetCurrentData
+> {}

package/vona/src/suite/a-home/modules/home-user/src/bean/cacheRedis.passwordResetRecipient.ts

@@ -0,0 +1,13 @@
+import { CacheRedis, ServiceCacheRedisBase } from 'vona-module-a-cache';
+
+export type TCacheRedisPasswordResetRecipientKey = string;
+export type TCacheRedisPasswordResetRecipientData = true;
+
+@CacheRedis({
+  ttl: 60 * 1000,
+  disableTransactionCompensate: true,
+})
+export class CacheRedisPasswordResetRecipient extends ServiceCacheRedisBase<
+  TCacheRedisPasswordResetRecipientKey,
+  TCacheRedisPasswordResetRecipientData
+> {}

package/vona/src/suite/a-home/modules/home-user/src/bean/cacheRedis.passwordSet.ts

@@ -0,0 +1,22 @@
+import type { TableIdentity } from 'table-identity';
+
+import { CacheRedis, ServiceCacheRedisBase } from 'vona-module-a-cache';
+
+export type TCacheRedisPasswordSetKey = string;
+
+export interface TCacheRedisPasswordSetData {
+  purpose: 'password-set';
+  userId: TableIdentity;
+  consumerPath: '/home/user/password-set';
+  email: string;
+  pendingEmail?: string;
+}
+
+@CacheRedis({
+  ttl: 15 * 60 * 1000,
+  disableTransactionCompensate: true,
+})
+export class CacheRedisPasswordSet extends ServiceCacheRedisBase<
+  TCacheRedisPasswordSetKey,
+  TCacheRedisPasswordSetData
+> {}

package/vona/src/suite/a-home/modules/home-user/src/bean/cacheRedis.passwordSetCurrent.ts

@@ -0,0 +1,15 @@
+import type { TableIdentity } from 'table-identity';
+
+import { CacheRedis, ServiceCacheRedisBase } from 'vona-module-a-cache';
+
+export type TCacheRedisPasswordSetCurrentKey = TableIdentity;
+export type TCacheRedisPasswordSetCurrentData = string;
+
+@CacheRedis({
+  ttl: 15 * 60 * 1000,
+  disableTransactionCompensate: true,
+})
+export class CacheRedisPasswordSetCurrent extends ServiceCacheRedisBase<
+  TCacheRedisPasswordSetCurrentKey,
+  TCacheRedisPasswordSetCurrentData
+> {}

package/vona/src/suite/a-home/modules/home-user/src/bean/imageScene.homeUserAvatar.ts

@@ -0,0 +1,18 @@
+import { BeanBase } from 'vona';
+import { ImageScene } from 'vona-module-a-image';
+
+@ImageScene({
+  public: true,
+  upload: {
+    maxSize: 2 * 1024 * 1024,
+    mimeTypes: ['image/jpeg', 'image/png', 'image/webp'],
+    extensions: ['.jpg', '.jpeg', '.png', '.webp'],
+    multiple: false,
+  },
+  meta: ctx => {
+    const user = ctx.state.passport?.user;
+    if (!user || user.anonymous) return ctx.app.throw(401);
+    return { ownerUserId: user.id.toString() };
+  },
+})
+export class ImageSceneHomeUserAvatar extends BeanBase {}

package/vona/src/suite/a-home/modules/home-user/src/bean/meta.redlock.ts

@@ -0,0 +1,18 @@
+import { Meta } from 'vona-module-a-meta';
+import { BeanRedlockBase } from 'vona-module-a-redlock';
+
+export type TypeRedlockLockResource =
+  | `homeUser.account.passwordMutation.${string}`
+  | `homeUser.account.passwordSetIssue.${string}`
+  | `homeUser.account.passwordSetConsume.${string}`
+  | `homeUser.account.passwordSetCandidate.${string}`
+  | `homeUser.account.passwordResetConsume.${string}`
+  | `homeUser.account.activationMutation.${string}`
+  | `homeUser.account.activationConsume.${string}`;
+export type TypeRedlockLockIsolateResource = never;
+
+@Meta()
+export class MetaRedlock extends BeanRedlockBase<
+  TypeRedlockLockResource,
+  TypeRedlockLockIsolateResource
+> {}

package/vona/src/suite/a-home/modules/home-user/src/bean/meta.version.ts

@@ -70,7 +70,6 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate, IMetaVe
           clientOptions: {
             username: 'admin',
             password: options.password || this.scope.config.passwordDefault.admin,
-            avatar: ':emoji:flower',
             confirmed: true,
           },
           state: { intention: 'register' },

package/vona/src/suite/a-home/modules/home-user/src/bean/zodRefine.passwordConfirm.ts

@@ -8,11 +8,14 @@ import { BeanBase } from 'vona';
 import { ZodRefine } from 'vona-module-a-zod';
 
 export interface TypeZodRefinePasswordConfirmData {
-  password: string;
+  password?: string;
+  newPassword?: string;
   passwordConfirm: string;
 }
 
-export interface IZodRefineOptionsPasswordConfirm extends IDecoratorZodRefineOptions {}
+export interface IZodRefineOptionsPasswordConfirm extends IDecoratorZodRefineOptions {
+  passwordField?: 'password' | 'newPassword';
+}
 
 @ZodRefine<IZodRefineOptionsPasswordConfirm>()
 export class ZodRefinePasswordConfirm
@@ -22,9 +25,10 @@ export class ZodRefinePasswordConfirm
   async execute(
     value: TypeZodRefinePasswordConfirmData,
     refinementCtx: TypeRefinementCtx,
-    _options: IZodRefineOptionsPasswordConfirm,
+    options: IZodRefineOptionsPasswordConfirm,
   ) {
-    if (value.password !== value.passwordConfirm) {
+    const passwordField = options.passwordField ?? 'password';
+    if (value[passwordField] !== value.passwordConfirm) {
       refinementCtx.addIssue({
         code: 'custom',
         message: this.scope.locale.PasswordsNotMatch(),

package/vona/src/suite/a-home/modules/home-user/src/config/config.ts

@@ -5,7 +5,16 @@ import { builtinRoles } from './roles.ts';
 export { builtinRoles } from './roles.ts';
 export type { IRoleConfig } from './roles.ts';
 
-export function config(_app: VonaApplication) {
+export interface IHomeUserConfig {
+  passwordDefault: {
+    admin: string;
+  };
+  disableBootstrapSystemAdmin: boolean;
+  disableUserAdmin: boolean;
+  builtinRoles: typeof builtinRoles;
+}
+
+export function config(_app: VonaApplication): IHomeUserConfig {
   return {
     passwordDefault: {
       admin: '123456',

package/vona/src/suite/a-home/modules/home-user/src/config/locale/en-us.ts

@@ -1,7 +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',
+  ActivationEmailSubject: '[{{siteName}}] Account Activation',
+  ActivationEmailBody: `
+Hi {{userName}},
+
+Use the following link to activate your account:
+
+{{link}}
+
+Thanks,
+{{siteName}}
+`,
+  AccountActivationPreparing: 'Preparing account activation…',
+  AccountActivationInvalid: 'This activation link is invalid or has expired.',
+  AccountActivationCompleted: 'Your account has been activated. You can now sign in.',
   Role: 'Role',
   RoleName: 'Role Name',
   RoleTitle: 'Role Title',
@@ -19,5 +30,26 @@ export default {
   UserTz: 'Timezone',
   UsernameExists: 'Username Exists',
   EmailExists: 'Email Exists',
+  Password: 'Password',
+  AccountDisplayName: 'Display name',
+  AccountAvatar: 'Avatar',
+  AccountLocale: 'Locale',
+  AccountTimezone: 'Time zone',
+  CurrentPassword: 'Current Password',
+  NewPassword: 'New Password',
+  PasswordConfirm: 'Confirm Password',
+  Captcha: 'Captcha',
   PasswordsNotMatch: 'Passwords do not match',
+  PasswordSetEmailSubject: 'Set your password',
+  PasswordSetEmailBody: `
+Use the following link to set your password:
+
+{{link}}
+`,
+  PasswordResetEmailSubject: 'Reset your password',
+  PasswordResetEmailBody: `
+Use the following link to reset your password:
+
+{{link}}
+`,
 };

package/vona/src/suite/a-home/modules/home-user/src/config/locale/zh-cn.ts

@@ -1,7 +1,18 @@
 export default {
-  ConfirmationEmailExpired: '确认邮件链接已经过期',
-  ConfirmationEmailSucceeded: '您的邮件地址已经确认',
-  PasswordResetEmailExpired: '重置密码链接已经过期',
+  ActivationEmailSubject: '[{{siteName}}] 激活账户',
+  ActivationEmailBody: `
+您好，{{userName}}：
+
+请使用以下链接激活您的账户：
+
+{{link}}
+
+谢谢，
+{{siteName}}
+`,
+  AccountActivationPreparing: '正在准备账户激活…',
+  AccountActivationInvalid: '激活链接无效或已过期。',
+  AccountActivationCompleted: '您的账户已激活，现在可以登录。',
   Role: '角色',
   RoleName: '角色名',
   RoleTitle: '角色标题',
@@ -19,5 +30,26 @@ export default {
   UserTz: '时区',
   UsernameExists: '用户名已存在',
   EmailExists: '电子邮件已存在',
+  Password: '密码',
+  AccountDisplayName: '显示名称',
+  AccountAvatar: '头像',
+  AccountLocale: '语言区域',
+  AccountTimezone: '时区',
+  CurrentPassword: '当前密码',
+  NewPassword: '新密码',
+  PasswordConfirm: '确认密码',
+  Captcha: '验证码',
   PasswordsNotMatch: '密码不一致',
+  PasswordSetEmailSubject: '设置密码',
+  PasswordSetEmailBody: `
+请使用以下链接设置密码：
+
+{{link}}
+`,
+  PasswordResetEmailSubject: '重置您的密码',
+  PasswordResetEmailBody: `
+请使用以下链接重置密码：
+
+{{link}}
+`,
 };

package/vona/src/suite/a-home/modules/home-user/src/controller/account.ts

@@ -0,0 +1,147 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Core } from 'vona-module-a-core';
+import { Api } from 'vona-module-a-openapiutils';
+import { Passport } from 'vona-module-a-user';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+
+import { DtoAccountActivation } from '../dto/accountActivation.ts';
+import { DtoAccountCurrent } from '../dto/accountCurrent.ts';
+import { DtoAccountPasswordChange } from '../dto/accountPasswordChange.ts';
+import { DtoAccountPasswordReset } from '../dto/accountPasswordReset.ts';
+import { DtoAccountPasswordResetRequest } from '../dto/accountPasswordResetRequest.ts';
+import { DtoAccountPasswordResetRequestResult } from '../dto/accountPasswordResetRequestResult.ts';
+import { DtoAccountPasswordSet } from '../dto/accountPasswordSet.ts';
+import { DtoAccountPasswordSetIssue } from '../dto/accountPasswordSetIssue.ts';
+import { DtoAccountProfileUpdate } from '../dto/accountProfileUpdate.ts';
+import { DtoAccountRelogin } from '../dto/accountRelogin.ts';
+
+export interface IControllerOptionsAccount extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsAccount>({
+  path: 'account',
+  tags: ['HomeUserAccount'],
+})
+export class ControllerAccount extends BeanBase {
+  @Web.get('current')
+  @Api.body(DtoAccountCurrent)
+  async current(): Promise<DtoAccountCurrent> {
+    return await this.scope.service.account.current();
+  }
+
+  @Web.patch('profile')
+  @Api.body(DtoAccountCurrent)
+  async updateProfile(@Arg.body() command: DtoAccountProfileUpdate): Promise<DtoAccountCurrent> {
+    return await this.scope.service.account.updateProfile(command);
+  }
+
+  @Web.post('activation/consume')
+  @Passport.public()
+  @Core.rateLimit({
+    enable: true,
+    rateLimit: {
+      mode: 'enforce',
+      limit: 10,
+      windowMs: 15 * 60 * 1000,
+      key: 'ip',
+      name: 'home-user-account-activation-consume',
+      headers: true,
+    },
+  })
+  async consumeActivation(@Arg.body() command: DtoAccountActivation): Promise<void> {
+    await this.scope.service.account.consumeActivation(command);
+  }
+
+  @Web.post('password/change')
+  @Api.body(DtoAccountRelogin)
+  @Core.rateLimit({
+    enable: true,
+    rateLimit: {
+      mode: 'enforce',
+      limit: 10,
+      windowMs: 15 * 60 * 1000,
+      key: 'subject',
+      name: 'home-user-account-password-change',
+      headers: true,
+    },
+  })
+  async changePassword(@Arg.body() command: DtoAccountPasswordChange): Promise<DtoAccountRelogin> {
+    return await this.scope.service.account.changePassword(command);
+  }
+
+  @Web.post('password-set/issue')
+  @Core.rateLimit({
+    enable: true,
+    rateLimit: {
+      mode: 'enforce',
+      limit: 3,
+      windowMs: 15 * 60 * 1000,
+      key: 'subject',
+      name: 'home-user-account-password-set-issue',
+      headers: true,
+    },
+  })
+  async issuePasswordSetLink(@Arg.body() command: DtoAccountPasswordSetIssue): Promise<void> {
+    await this.scope.service.account.issuePasswordSetLink(command);
+  }
+
+  @Web.post('password-set/consume')
+  @Api.body(DtoAccountRelogin)
+  @Passport.public()
+  @Core.rateLimit({
+    enable: true,
+    rateLimit: {
+      mode: 'enforce',
+      limit: 10,
+      windowMs: 15 * 60 * 1000,
+      key: 'ip',
+      name: 'home-user-account-password-set-consume',
+      headers: true,
+    },
+  })
+  async consumePasswordSet(@Arg.body() command: DtoAccountPasswordSet): Promise<DtoAccountRelogin> {
+    return await this.scope.service.account.consumePasswordSet(command);
+  }
+
+  @Web.post('password-reset/request')
+  @Passport.public()
+  @Core.captchaVerify({ scene: 'captcha-simple:simple' })
+  @Api.body(DtoAccountPasswordResetRequestResult)
+  @Core.rateLimit({
+    enable: true,
+    rateLimit: {
+      mode: 'enforce',
+      limit: 5,
+      windowMs: 15 * 60 * 1000,
+      key: 'ip',
+      name: 'home-user-account-password-reset-request',
+      headers: true,
+    },
+  })
+  async requestPasswordReset(
+    @Arg.body() command: DtoAccountPasswordResetRequest,
+  ): Promise<DtoAccountPasswordResetRequestResult> {
+    return await this.scope.service.account.requestPasswordReset(command);
+  }
+
+  @Web.post('password-reset/consume')
+  @Passport.public()
+  @Api.body(DtoAccountRelogin)
+  @Core.rateLimit({
+    enable: true,
+    rateLimit: {
+      mode: 'enforce',
+      limit: 10,
+      windowMs: 15 * 60 * 1000,
+      key: 'ip',
+      name: 'home-user-account-password-reset-consume',
+      headers: true,
+    },
+  })
+  async consumePasswordReset(
+    @Arg.body() command: DtoAccountPasswordReset,
+  ): Promise<DtoAccountRelogin> {
+    return await this.scope.service.account.consumePasswordReset(command);
+  }
+}

package/vona/src/suite/a-home/modules/home-user/src/controller/passport.ts

@@ -1,5 +1,6 @@
 import type { DtoAuth, IAuthenticateOptions, IAuthProviderRecord } from 'vona-module-a-auth';
 import type { IJwtToken } from 'vona-module-a-jwt';
+import type { IUser } from 'vona-module-a-user';
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 
 import { BeanBase } from 'vona';
@@ -25,11 +26,12 @@ export class ControllerPassport extends BeanBase {
   @Web.get('current')
   @Passport.public()
   @Api.body(v.optional(), v.object(DtoPassport))
-  current(): DtoPassport | undefined {
-    return this._combineDtoPassport();
+  async current(): Promise<DtoPassport | undefined> {
+    return await this._combineDtoPassport();
   }
 
   @Web.post('logout')
+  @Passport.activated('noCheck')
   async logout() {
     return await this.bean.passport.signout();
   }
@@ -44,6 +46,10 @@ export class ControllerPassport extends BeanBase {
       state: { intention: 'register' },
       clientName: 'default',
     });
+    const user = this.bean.passport.current?.user as EntityUser | undefined;
+    if (user && !user.activated && user.email) {
+      await this.scope.service.account.issueActivationLink(user.id, data.consumerUrl);
+    }
     return this._combineDtoPassportJwt(jwt);
   }
 
@@ -132,19 +138,33 @@ export class ControllerPassport extends BeanBase {
     return await this.bean.passport.createTempAuthToken({ path });
   }
 
-  private _combineDtoPassportJwt(jwt?: IJwtToken): DtoPassportJwt {
+  private async _combineDtoPassportJwt(jwt?: IJwtToken): Promise<DtoPassportJwt> {
     if (!jwt) this.app.throw(403);
+    const passport = await this._combineDtoPassport();
+    if (!passport) this.app.throw(403);
     return {
-      passport: this._combineDtoPassport()!,
+      passport,
       jwt: jwt as DtoJwtToken,
     };
   }
 
-  private _combineDtoPassport(): DtoPassport | undefined {
+  private async _combineDtoPassport(): Promise<DtoPassport | undefined> {
     const passport = this.bean.passport.current;
-    if (!passport || !passport.auth) return;
+    const user = passport?.user as (EntityUser & IUser) | undefined;
+    if (!passport || !passport.auth || !user) return;
     return {
-      user: passport.user as EntityUser,
+      user: {
+        id: user.id,
+        name: user.name,
+        avatar: user.avatar,
+        email: user.email,
+        mobile: user.mobile,
+        activated: user.activated,
+        accountStatus: user.accountStatus,
+        locale: user.locale,
+        tz: user.tz,
+        anonymous: user.anonymous,
+      },
       auth: passport.auth as DtoAuth,
       roles: passport.roles as EntityRole[],
     };

package/vona/src/suite/a-home/modules/home-user/src/dto/accountActivation.ts

@@ -0,0 +1,12 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsAccountActivation extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAccountActivation>()
+export class DtoAccountActivation {
+  @Api.field(v.min(32), v.max(255))
+  token: string;
+}

package/vona/src/suite/a-home/modules/home-user/src/dto/accountCurrent.ts

@@ -0,0 +1,31 @@
+import type { ILocaleRecord } from 'vona';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsAccountCurrent extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAccountCurrent>()
+export class DtoAccountCurrent {
+  @Api.field()
+  name: string;
+
+  @Api.field(v.optional())
+  avatar?: string;
+
+  @Api.field(v.optional())
+  locale?: keyof ILocaleRecord;
+
+  @Api.field(v.optional())
+  tz?: string;
+
+  @Api.field()
+  hasSimpleAuth: boolean;
+
+  @Api.field()
+  canSendSetPasswordLink: boolean;
+
+  @Api.field(v.optional())
+  eligibleEmailMasked?: string;
+}

package/vona/src/suite/a-home/modules/home-user/src/dto/accountPasswordChange.ts

@@ -0,0 +1,41 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IDtoOptionsAccountPasswordChange extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAccountPasswordChange>({
+  pipes: v.zodRefine('home-user:passwordConfirm', { passwordField: 'newPassword' }),
+})
+export class DtoAccountPasswordChange {
+  @Api.field(
+    v.title($locale('CurrentPassword')),
+    v.required(),
+    v.min(6),
+    v.max(20),
+    ZovaRender.field('basic-input:formFieldInput', { type: 'password' }),
+  )
+  currentPassword: string;
+
+  @Api.field(
+    v.title($locale('NewPassword')),
+    v.required(),
+    v.min(6),
+    v.max(20),
+    ZovaRender.field('basic-input:formFieldInput', { type: 'password' }),
+  )
+  newPassword: string;
+
+  @Api.field(
+    v.title($locale('PasswordConfirm')),
+    v.required(),
+    v.min(6),
+    v.max(20),
+    ZovaRender.field('basic-input:formFieldInput', { type: 'password' }),
+  )
+  passwordConfirm: string;
+}

package/vona/src/suite/a-home/modules/home-user/src/dto/accountPasswordReset.ts

@@ -0,0 +1,35 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IDtoOptionsAccountPasswordReset extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAccountPasswordReset>({
+  pipes: v.zodRefine('home-user:passwordConfirm', { passwordField: 'newPassword' }),
+})
+export class DtoAccountPasswordReset {
+  @Api.field(v.min(32), v.max(255))
+  token: string;
+
+  @Api.field(
+    v.title($locale('Password')),
+    v.required(),
+    v.min(6),
+    v.max(20),
+    ZovaRender.field('basic-input:formFieldInput', { type: 'password' }),
+  )
+  newPassword: string;
+
+  @Api.field(
+    v.title($locale('PasswordConfirm')),
+    v.required(),
+    v.min(6),
+    v.max(20),
+    ZovaRender.field('basic-input:formFieldInput', { type: 'password' }),
+  )
+  passwordConfirm: string;
+}