vona-cli-set-api 1.0.172 → 1.0.176

package/cli/templates/create/project/basic/boilerplate/_.gitignore

@@ -32,7 +32,6 @@ src/backend/typing/mine.d.ts
 # auto created
 .rollup.cache
 .temp-dynamic-*
-/cabloy.json
 /package.json
 
 /docker-compose

package/cli/templates/create/project/basic/boilerplate/env/.env

@@ -40,7 +40,7 @@ BUILD_COPY_RELEASE =
 TEST_CONCURRENCY = true
 TEST_ONLY = false
 TEST_WHYISNODERUNNING = false
-TEST_PATTERNS_IGNORE = '**/test-vona/test/cache/cacheMem.test.ts,**/test-vona/test/cache/cacheRedis.test.ts,**/test-vona/test/cache/summer.test.ts'
+TEST_PATTERNS_IGNORE = '**/test-vona/test/cache/cacheMem.test.ts,**/test-vona/test/cache/cacheRedis.test.ts,**/test-vona/test/cache/summer.test.ts,**/test-vona/test/mail.test.ts'
 
 # database
 

package/cli/templates/create/project/basic/boilerplate/package.original.json

@@ -22,7 +22,7 @@
     "node": ">=24.1.0"
   },
   "scripts": {
-    "init": "pnpm install --no-frozen-lockfile && npm run prerun && pnpm install --no-frozen-lockfile",
+    "init": "pnpm install --no-frozen-lockfile && npm run prerun && pnpm install --no-frozen-lockfile && pnpm dedupe",
     "demo": "vona :bin:demo --flavor=normal",
     "db:reset": "npm run prerun && vona :bin:dbReset --flavor=normal",
     "dev": "npm run prerun && vona :bin:dev --workers=2 --flavor=normal",
@@ -45,10 +45,10 @@
     }
   },
   "dependencies": {
-    "vona": "^5.0.102"
+    "vona": "^5.0.104"
   },
   "devDependencies": {
     "@cabloy/lint": "^5.0.16",
-    "eslint": "^9.20.1"
+    "eslint": "^9.35.0"
   }
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-base/src/.metadata/index.ts

@@ -81,6 +81,9 @@ declare module 'vona-module-a-web' {
 
 }
 /** controller: end */
+/** main: begin */
+export * from '../main.ts';
+/** main: end */
 /** scope: begin */
 import { BeanScopeBase, type BeanScopeUtil } from 'vona';
 import { Scope } from 'vona-module-a-bean';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-base/src/main.ts

@@ -0,0 +1,16 @@
+import type { IModuleMain } from 'vona';
+import { BeanSimple } from 'vona';
+import { en, zhCN } from 'zod/locales';
+
+export class Main extends BeanSimple implements IModuleMain {
+  async moduleLoading() {}
+  async moduleLoaded() {
+    const localeErrors = {
+      'en-us': en,
+      'zh-cn': zhCN,
+    };
+    this.app.util.setLocaleErrors(localeErrors, this.bean.scope('a-i18n').config.i18n.defaultLocale);
+  }
+
+  async configLoaded(_config: any) {}
+}

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

@@ -1,6 +1,7 @@
 /* eslint-disable */
 import type { TypeEntityMeta,TypeModelsClassLikeGeneral,TypeSymbolKeyFieldsMore,IModelRelationBelongsToMany } from 'vona-module-a-orm';
 import type { TypeEntityOptionsFields,TypeControllerOptionsActions } from 'vona-module-a-openapi';
+import type { TableIdentity } from 'table-identity';
 /** entity: begin */
 export * from '../entity/role.ts';
 export * from '../entity/roleUser.ts';
@@ -135,7 +136,7 @@ declare module 'vona' {
 }
 /** model: end */
 /** model: begin */
-import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TableIdentity, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TypeModelSelectAndCount, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
 import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
 declare module 'vona-module-home-user' {
   export interface IModelOptionsUser {
@@ -149,6 +150,7 @@ declare module 'vona-module-home-user' {
       [SymbolKeyModelOptions]: IModelOptionsRole;
       get<T extends IModelGetOptions<EntityRole,ModelRole>>(where: TypeModelWhere<EntityRole>, options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T> | undefined>;
       mget<T extends IModelGetOptions<EntityRole,ModelRole>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityRole,ModelRole,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityRole, ModelRole, T>>;
       select<T extends IModelSelectParams<EntityRole,ModelRole,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
       insert<T extends IModelInsertOptions<EntityRole,ModelRole>>(data?: TypeModelMutateRelationData<EntityRole,ModelRole, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRole,ModelRole, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityRole,ModelRole>>(items: TypeModelMutateRelationData<EntityRole,ModelRole, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRole,ModelRole, T, true>[]>;
@@ -168,6 +170,7 @@ export interface ModelRoleUser {
       [SymbolKeyModelOptions]: IModelOptionsRoleUser;
       get<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(where: TypeModelWhere<EntityRoleUser>, options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T> | undefined>;
       mget<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityRoleUser,ModelRoleUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityRoleUser, ModelRoleUser, T>>;
       select<T extends IModelSelectParams<EntityRoleUser,ModelRoleUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
       insert<T extends IModelInsertOptions<EntityRoleUser,ModelRoleUser>>(data?: TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityRoleUser,ModelRoleUser>>(items: TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityRoleUser,ModelRoleUser, T, true>[]>;
@@ -187,6 +190,7 @@ export interface ModelUser {
       [SymbolKeyModelOptions]: IModelOptionsUser;
       get<T extends IModelGetOptions<EntityUser,ModelUser>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T> | undefined>;
       mget<T extends IModelGetOptions<EntityUser,ModelUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
+      selectAndCount<T extends IModelSelectParams<EntityUser,ModelUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityUser, ModelUser, T>>;
       select<T extends IModelSelectParams<EntityUser,ModelUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
       insert<T extends IModelInsertOptions<EntityUser,ModelUser>>(data?: TypeModelMutateRelationData<EntityUser,ModelUser, T>, options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUser, T, true>>;
       insertBulk<T extends IModelInsertOptions<EntityUser,ModelUser>>(items: TypeModelMutateRelationData<EntityUser,ModelUser, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityUser,ModelUser, T, true>[]>;
@@ -294,6 +298,67 @@ declare module 'vona' {
   }
 }
 /** service: end */
+/** eventListener: begin */
+export * from '../bean/eventListener.activate.ts';
+export * from '../bean/eventListener.emailConfirmCallback.ts';
+export * from '../bean/eventListener.passwordResetCallback.ts';
+export * from '../bean/eventListener.register.ts';
+
+import { type IDecoratorEventListenerOptions } from 'vona-module-a-event';
+declare module 'vona-module-a-event' {
+  
+    export interface IEventListenerRecord {
+      'home-user:activate': IDecoratorEventListenerOptions;
+'home-user:emailConfirmCallback': IDecoratorEventListenerOptions;
+'home-user:passwordResetCallback': IDecoratorEventListenerOptions;
+'home-user:register': IDecoratorEventListenerOptions;
+    }
+
+  
+}
+declare module 'vona-module-home-user' {
+  
+        export interface EventListenerActivate {
+          /** @internal */
+          get scope(): ScopeModuleHomeUser;
+        }
+
+          export interface EventListenerActivate {
+            get $beanFullName(): 'home-user.eventListener.activate';
+            get $onionName(): 'home-user:activate';
+          }
+
+        export interface EventListenerEmailConfirmCallback {
+          /** @internal */
+          get scope(): ScopeModuleHomeUser;
+        }
+
+          export interface EventListenerEmailConfirmCallback {
+            get $beanFullName(): 'home-user.eventListener.emailConfirmCallback';
+            get $onionName(): 'home-user:emailConfirmCallback';
+          }
+
+        export interface EventListenerPasswordResetCallback {
+          /** @internal */
+          get scope(): ScopeModuleHomeUser;
+        }
+
+          export interface EventListenerPasswordResetCallback {
+            get $beanFullName(): 'home-user.eventListener.passwordResetCallback';
+            get $onionName(): 'home-user:passwordResetCallback';
+          }
+
+        export interface EventListenerRegister {
+          /** @internal */
+          get scope(): ScopeModuleHomeUser;
+        }
+
+          export interface EventListenerRegister {
+            get $beanFullName(): 'home-user.eventListener.register';
+            get $onionName(): 'home-user:register';
+          } 
+}
+/** eventListener: end */
 /** meta: begin */
 export * from '../bean/meta.index.ts';
 export * from '../bean/meta.version.ts';
@@ -333,18 +398,24 @@ declare module 'vona-module-home-user' {
 /** meta: end */
 /** dto: begin */
 export * from '../dto/auth.ts';
+export * from '../dto/login.ts';
 export * from '../dto/passport.ts';
 export * from '../dto/passportJwt.ts';
+export * from '../dto/register.ts';
 import type { IDtoOptionsAuth } from '../dto/auth.ts';
+import type { IDtoOptionsLogin } from '../dto/login.ts';
 import type { IDtoOptionsPassport } from '../dto/passport.ts';
 import type { IDtoOptionsPassportJwt } from '../dto/passportJwt.ts';
+import type { IDtoOptionsRegister } from '../dto/register.ts';
 import 'vona';
 declare module 'vona-module-a-web' {
   
     export interface IDtoRecord {
       'home-user:auth': IDtoOptionsAuth;
+'home-user:login': IDtoOptionsLogin;
 'home-user:passport': IDtoOptionsPassport;
 'home-user:passportJwt': IDtoOptionsPassportJwt;
+'home-user:register': IDtoOptionsRegister;
     }
 
   
@@ -355,14 +426,20 @@ declare module 'vona-module-home-user' {
 /** dto: end */
 /** dto: begin */
 import type { DtoAuth } from '../dto/auth.ts';
+import type { DtoLogin } from '../dto/login.ts';
 import type { DtoPassport } from '../dto/passport.ts';
-import type { DtoPassportJwt } from '../dto/passportJwt.ts'; 
+import type { DtoPassportJwt } from '../dto/passportJwt.ts';
+import type { DtoRegister } from '../dto/register.ts'; 
 declare module 'vona-module-home-user' {
   
     export interface IDtoOptionsAuth {
       fields?: TypeEntityOptionsFields<DtoAuth, IDtoOptionsAuth[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsLogin {
+      fields?: TypeEntityOptionsFields<DtoLogin, IDtoOptionsLogin[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsPassport {
       fields?: TypeEntityOptionsFields<DtoPassport, IDtoOptionsPassport[TypeSymbolKeyFieldsMore]>;
     }
@@ -370,6 +447,10 @@ declare module 'vona-module-home-user' {
     export interface IDtoOptionsPassportJwt {
       fields?: TypeEntityOptionsFields<DtoPassportJwt, IDtoOptionsPassportJwt[TypeSymbolKeyFieldsMore]>;
     }
+
+    export interface IDtoOptionsRegister {
+      fields?: TypeEntityOptionsFields<DtoRegister, IDtoOptionsRegister[TypeSymbolKeyFieldsMore]>;
+    }
 }
 /** dto: end */
 /** controller: begin */
@@ -415,6 +496,7 @@ declare module 'vona-module-a-web' {
     }
 export interface IApiPathPostRecord{
         '/home/user/passport/logout': undefined;
+'/home/user/passport/register': undefined;
 '/home/user/passport/login': undefined;
 '/home/user/passport/refreshAuthToken': undefined;
 '/home/user/passport/createPassportJwtFromOauthCode': undefined;
@@ -423,6 +505,57 @@ export interface IApiPathPostRecord{
 
 }
 /** controller: end */
+/** zodRefine: begin */
+export * from '../bean/zodRefine.emailUnique.ts';
+export * from '../bean/zodRefine.passwordConfirm.ts';
+export * from '../bean/zodRefine.usernameUnique.ts';
+import type { IZodRefineOptionsEmailUnique } from '../bean/zodRefine.emailUnique.ts';
+import type { IZodRefineOptionsPasswordConfirm } from '../bean/zodRefine.passwordConfirm.ts';
+import type { IZodRefineOptionsUsernameUnique } from '../bean/zodRefine.usernameUnique.ts';
+import 'vona';
+declare module 'vona-module-a-zod' {
+  
+    export interface IZodRefineRecord {
+      'home-user:emailUnique': IZodRefineOptionsEmailUnique;
+'home-user:passwordConfirm': IZodRefineOptionsPasswordConfirm;
+'home-user:usernameUnique': IZodRefineOptionsUsernameUnique;
+    }
+
+  
+}
+declare module 'vona-module-home-user' {
+  
+        export interface ZodRefineEmailUnique {
+          /** @internal */
+          get scope(): ScopeModuleHomeUser;
+        }
+
+          export interface ZodRefineEmailUnique {
+            get $beanFullName(): 'home-user.zodRefine.emailUnique';
+            get $onionName(): 'home-user:emailUnique';
+          }
+
+        export interface ZodRefinePasswordConfirm {
+          /** @internal */
+          get scope(): ScopeModuleHomeUser;
+        }
+
+          export interface ZodRefinePasswordConfirm {
+            get $beanFullName(): 'home-user.zodRefine.passwordConfirm';
+            get $onionName(): 'home-user:passwordConfirm';
+          }
+
+        export interface ZodRefineUsernameUnique {
+          /** @internal */
+          get scope(): ScopeModuleHomeUser;
+        }
+
+          export interface ZodRefineUsernameUnique {
+            get $beanFullName(): 'home-user.zodRefine.usernameUnique';
+            get $onionName(): 'home-user:usernameUnique';
+          } 
+}
+/** zodRefine: end */
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/bean/eventListener.activate.ts

@@ -0,0 +1,28 @@
+import type { IEventExecute, NextEvent } from 'vona-module-a-event';
+import type { TypeEventActivateData, TypeEventActivateResult } from 'vona-module-a-user';
+import type { IUser } from '../types/user.ts';
+import { BeanBase } from 'vona';
+import { EventListener } from 'vona-module-a-event';
+
+type TypeEventData = TypeEventActivateData;
+type TypeEventResult = TypeEventActivateResult;
+
+@EventListener({ match: 'a-user:activate' })
+export class EventListenerActivate
+  extends BeanBase
+  implements IEventExecute<TypeEventData, TypeEventResult> {
+  async execute(data: TypeEventData, next: NextEvent<TypeEventData, TypeEventResult>): Promise<TypeEventResult> {
+    const user = data as IUser;
+    if (user.name === 'admin') {
+      // role: admin
+      const roleAdmin = await this.scope.model.role.get({ name: 'admin' });
+      // userRole: admin
+      await this.scope.model.roleUser.insert({
+        userId: user.id,
+        roleId: roleAdmin!.id,
+      });
+    }
+    // next
+    return next();
+  }
+}

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

@@ -0,0 +1,24 @@
+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.userInner.findOne({ id: data.userId });
+    await this.bean.userInner.activate(user!);
+    // ok
+    return this.scope.locale.ConfirmationEmailSucceeded();
+  }
+}

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

@@ -0,0 +1,22 @@
+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/basic/boilerplate/src/suite/a-home/modules/home-user/src/bean/eventListener.register.ts

@@ -0,0 +1,23 @@
+import type { IEventExecute, NextEvent } from 'vona-module-a-event';
+import type { TypeEventRegisterData, TypeEventRegisterResult } from 'vona-module-a-user';
+import type { IUser } from '../types/user.ts';
+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.$scope.mailconfirm.service.mail.emailConfirm(user);
+    }
+    return user;
+  }
+}

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

@@ -20,6 +20,9 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate, IMetaVe
         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);
       });
       // homeRoleUser
@@ -35,20 +38,16 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate, IMetaVe
   async init(options: IMetaVersionInitOptions) {
     if (options.version === 1) {
       // role: admin
-      const roleAdmin = await this.scope.model.role.insert({
+      await this.scope.model.role.insert({
         name: 'admin',
       });
       // user: admin
-      const userAdmin = await this.scope.model.user.insert({
-        name: 'admin',
+      await this.bean.authSimple.authenticate({
+        username: 'admin',
+        password: options.password || this.scope.config.passwordDefault.admin,
         avatar: ':emoji:flower',
-        locale: undefined,
-      });
-      // userRole: admin
-      await this.scope.model.roleUser.insert({
-        userId: userAdmin.id,
-        roleId: roleAdmin.id,
-      });
+        confirmed: true,
+      }, 'register', 'default');
     }
   }
 }

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

@@ -0,0 +1,20 @@
+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.get({ email: { _eqI_: value } });
+    if (user) {
+      refinementCtx.addIssue({
+        code: 'custom',
+        message: this.scope.locale.EmailExists(),
+      });
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+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/basic/boilerplate/src/suite/a-home/modules/home-user/src/bean/zodRefine.usernameUnique.ts

@@ -0,0 +1,20 @@
+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.userInner.findOneByName(value);
+    if (user) {
+      refinementCtx.addIssue({
+        code: 'custom',
+        message: this.scope.locale.UsernameExists(),
+      });
+    }
+  }
+}

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

@@ -3,6 +3,9 @@ import type { IServiceRecord } from 'vona-module-a-bean';
 
 export function config(_app: VonaApplication) {
   return {
+    passwordDefault: {
+      admin: '123456',
+    },
     adapter: {
       authInner: 'a-auth:authInnerAdapter' as keyof IServiceRecord,
     },

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

@@ -1,8 +1,17 @@
 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',
+  UsernameExists: 'Username Exists',
+  EmailExists: 'Email Exists',
+  PasswordsNotMatch: 'Passwords do not match',
 };

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

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

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

@@ -4,14 +4,16 @@ import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import type { EntityRole } from '../entity/role.ts';
 import type { EntityUser } from '../entity/user.ts';
 import { BeanBase } from 'vona';
-import { DtoAuthSimple } from 'vona-module-a-authsimple';
+import { Captcha } from 'vona-module-a-captcha';
 import { DtoJwtToken } from 'vona-module-a-jwt';
 import { Api, v } from 'vona-module-a-openapi';
 import { Passport } from 'vona-module-a-user';
 import { Arg, Controller, Web } from 'vona-module-a-web';
 import { z } from 'zod';
+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 {}
 
@@ -29,28 +31,37 @@ export class ControllerPassport extends BeanBase {
     return await this.bean.passport.signout();
   }
 
+  @Web.post('register')
+  @Passport.public()
+  @Captcha.verify({ scene: 'a-captchasimple: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()
+  @Captcha.verify({ scene: 'a-captchasimple:simple' })
   @Api.body(v.object(DtoPassportJwt))
-  async loginSimple(@Arg.body() clientOptions: DtoAuthSimple): Promise<DtoPassportJwt> {
-    const jwt = await this.bean.authSimple.authenticate(clientOptions, 'default');
+  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()
-  @Api.body(v.object(DtoPassportJwt))
-  async login<T extends keyof IAuthProviderRecord>(
+  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,
-  ): Promise<DtoPassportJwt> {
-    const jwt = await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
+  ) {
+    // only support oauth, so not return jwt to client
+    await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
       state: { intention: 'login', redirect },
       clientName,
     });
-    return this._combineDtoPassportJwt(jwt);
   }
 
   @Web.get('associate/:module/:providerName/:clientName?')

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/dto/auth.ts

@@ -1,4 +1,4 @@
-import type { TableIdentity } from 'vona-module-a-orm';
+import type { TableIdentity } from 'table-identity';
 import type { IAuthBase } from 'vona-module-a-user';
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 import { Api, v } from 'vona-module-a-openapi';

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

@@ -0,0 +1,18 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { DtoCaptchaVerify } from 'vona-module-a-captcha';
+import { Api, v } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsLogin extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsLogin>()
+export class DtoLogin {
+  @Api.field(v.min(3), v.trim())
+  username: string;
+
+  @Api.field(v.min(6))
+  password: string;
+
+  @Api.field(v.captcha({ scene: 'a-captchasimple:simple' }))
+  captcha: DtoCaptchaVerify;
+}

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

@@ -0,0 +1,26 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { DtoCaptchaVerify } from 'vona-module-a-captcha';
+import { Api, v } from 'vona-module-a-openapi';
+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.captcha({ scene: 'a-captchasimple:simple' }))
+  captcha: DtoCaptchaVerify;
+}

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

@@ -1,4 +1,5 @@
-import type { IDecoratorEntityOptions, TableIdentity } from 'vona-module-a-orm';
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
 import { Api, v } from 'vona-module-a-openapi';
 import { Entity, EntityBase } from 'vona-module-a-orm';
 

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

@@ -15,6 +15,15 @@ export class EntityUser extends EntityBase {
   @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 ILocaleInfos | undefined;
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/lib/authAdapter.ts

@@ -1,4 +1,4 @@
-import type { TableIdentity } from 'vona-module-a-orm';
+import type { TableIdentity } from 'table-identity';
 import type { IAuthBase } from 'vona-module-a-user';
 import type { IAuth } from '../types/auth.ts';
 import { cast } from 'vona';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/lib/roleAdapter.ts

@@ -1,4 +1,4 @@
-import type { TableIdentity } from 'vona-module-a-orm';
+import type { TableIdentity } from 'table-identity';
 import type { IRoleBase } from 'vona-module-a-user';
 import type { IRole } from '../types/role.ts';
 import { cast } from 'vona';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/lib/userAdapter.ts

@@ -1,11 +1,11 @@
+import type { TableIdentity } from 'table-identity';
 import type { ILocaleInfos } from 'vona';
-import type { TableIdentity } from 'vona-module-a-orm';
 import type { IUserBase } from 'vona-module-a-user';
 import type { IUser } from '../types/user.ts';
 import { cast } from 'vona';
 import { setUserAdapter } from 'vona-module-a-user';
 
-setUserAdapter({ getUserId, getUserName, getUserAvatar, getUserLocale, getUserAnonymous });
+setUserAdapter({ getUserId, getUserName, getUserAvatar, getUserEmail, getUserMobile, getUserActivated, getUserLocale, getUserAnonymous });
 
 function getUserId(user: IUserBase): TableIdentity {
   return cast<IUser>(user).id;
@@ -19,6 +19,18 @@ function getUserAvatar(user: IUserBase): string | undefined {
   return cast<IUser>(user).avatar;
 }
 
+function getUserEmail(user: IUserBase): string | undefined {
+  return cast<IUser>(user).email;
+}
+
+function getUserMobile(user: IUserBase): string | undefined {
+  return cast<IUser>(user).mobile;
+}
+
+function getUserActivated(user: IUserBase): boolean {
+  return cast<IUser>(user).activated;
+}
+
 function getUserLocale(user: IUserBase): keyof ILocaleInfos | undefined {
   return cast<IUser>(user).locale;
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/service/userInnerAdapter.ts

@@ -1,3 +1,4 @@
+import type { TableIdentity } from 'table-identity';
 import type { IAuthUserProfile, IUserBase, IUserInnerAdapter } from 'vona-module-a-user';
 import type { IUser } from '../types/user.ts';
 import { BeanBase } from 'vona';
@@ -5,20 +6,25 @@ import { Service } from 'vona-module-a-bean';
 
 @Service()
 export class ServiceUserInnerAdapter extends BeanBase implements IUserInnerAdapter {
-  async createByProfile(profile: IAuthUserProfile): Promise<IUserBase> {
-    return await this.scope.model.user.insert({
+  async create(user: Partial<IUser>): Promise<IUserBase> {
+    return await this.scope.model.user.insert(user);
+  }
+
+  async userOfProfile(profile: IAuthUserProfile): Promise<IUserBase> {
+    return {
       name: profile.username!,
+      email: profile.emails?.[0].value,
       avatar: profile.photos?.[0].value,
-      locale: undefined,
-    });
+      locale: profile.locale || this.ctx.locale,
+    } as IUser;
   }
 
   async createAnonymous(): Promise<IUserBase> {
-    return { id: -1, name: 'anonymous', avatar: undefined, locale: undefined } as IUserBase;
+    return { id: -1, name: 'anonymous', avatar: undefined, locale: undefined } as IUser;
   }
 
   async findOneByName(name: string): Promise<IUserBase | undefined> {
-    return await this.findOne({ name });
+    return await this.scope.model.user.get({ name: { _eqI_: name } });
   }
 
   async findOne(user: Partial<IUser>): Promise<IUserBase | undefined> {
@@ -32,4 +38,8 @@ export class ServiceUserInnerAdapter extends BeanBase implements IUserInnerAdapt
   async remove(user: Partial<IUser>): Promise<void> {
     await this.scope.model.user.delete(user);
   }
+
+  async setActivated(id: TableIdentity, activated: boolean): Promise<void> {
+    await this.scope.model.user.update({ id, activated });
+  }
 }

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/types/passport.ts

@@ -1,5 +1,5 @@
+import type { TableIdentity } from 'table-identity';
 import type { IPayloadDataBase } from 'vona-module-a-jwt';
-import type { TableIdentity } from 'vona-module-a-orm';
 import type { IPassportBase } from 'vona-module-a-user';
 import type { IAuth } from './auth.ts';
 import type { IUser } from './user.ts';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/types/user.ts

@@ -4,5 +4,8 @@ import type { IUserBase } from 'vona-module-a-user';
 export interface IUser extends IUserBase {
   name: string;
   avatar?: string;
+  email?: string;
+  mobile?: string;
+  activated: boolean;
   locale?: keyof ILocaleInfos | undefined;
 }

package/cli/templates/tools/crud/boilerplate/src/controller/{{resourceName}}.ts_

@@ -1,4 +1,5 @@
-import type { IQueryParams, TableIdentity } from 'vona-module-a-orm';
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 import type { Model<%=argv.resourceNameCapitalize%> } from '../model/<%=argv.resourceName%>.ts';
 import { BeanBase } from 'vona';
@@ -23,9 +24,6 @@ export class Controller<%=argv.resourceNameCapitalize%> extends BeanBase {
   @Web.get()
   @Api.body(Dto<%=argv.resourceNameCapitalize%>QueryRes)
   async findMany(@Arg.queryPro(Dto<%=argv.resourceNameCapitalize%>Query) params: IQueryParams<Model<%=argv.resourceNameCapitalize%>>): Promise<Dto<%=argv.resourceNameCapitalize%>QueryRes> {
-    if (!params.orders) {
-      params.orders = [['<%=argv.moduleResourceName%>.createdAt', 'desc']];
-    }
     return await this.scope.service.<%=argv.resourceName%>.findMany(params);
   }
 

package/cli/templates/tools/crud/boilerplate/src/dto/{{resourceName}}Query.ts_

@@ -1,9 +1,11 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
-import { $Dto } from 'vona-module-a-orm';
+import { $Dto, $tableName } from 'vona-module-a-orm';
 import { Dto } from 'vona-module-a-web';
 import { Entity<%=argv.resourceNameCapitalize%> } from '../entity/<%=argv.resourceName%>.ts';
 
 export interface IDtoOptions<%=argv.resourceNameCapitalize%>Query extends IDecoratorDtoOptions {}
 
-@Dto<IDtoOptions<%=argv.resourceNameCapitalize%>Query>()
+@Dto<IDtoOptions<%=argv.resourceNameCapitalize%>Query>({
+  openapi: { query: { table: $tableName(Entity<%=argv.resourceNameCapitalize%>) } },
+})
 export class Dto<%=argv.resourceNameCapitalize%>Query extends $Dto.queryPage(Entity<%=argv.resourceNameCapitalize%>, ['name']) {}

package/cli/templates/tools/crud/boilerplate/src/service/{{resourceName}}.ts_

@@ -1,4 +1,5 @@
-import type { IQueryParams, TableIdentity } from 'vona-module-a-orm';
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
 import type { Dto<%=argv.resourceNameCapitalize%>Create } from '../dto/<%=argv.resourceName%>Create.ts';
 import type { Dto<%=argv.resourceNameCapitalize%>QueryRes } from '../dto/<%=argv.resourceName%>QueryRes.ts';
 import type { Dto<%=argv.resourceNameCapitalize%>Update } from '../dto/<%=argv.resourceName%>Update.ts';

package/dist/lib/bean/cli.tools.metadata.js

@@ -134,6 +134,7 @@ export class CliToolsMetadata extends BeanCliBase {
     _generatePatch(content) {
         if (!content)
             return content;
+        content = this._generatePatch_resources(content, 'table-identity', ['TableIdentity'], true);
         content = this._generatePatch_resources(content, 'vona-module-a-openapi', ['TypeEntityOptionsFields', 'TypeControllerOptionsActions'], true);
         content = this._generatePatch_resources(content, 'vona-module-a-orm', [
             'TypeEntityMeta',

package/dist/lib/bean/toolsBin/generateEntryFiles.js

@@ -3,6 +3,7 @@ import { getEnvFiles } from '@cabloy/dotenv';
 import chalk from 'chalk';
 import fse from 'fs-extra';
 import { copyTemplateFile, getEnvMeta, resolveTemplatePath } from "../../utils.js";
+import { generateZod } from "./generateZod.js";
 export async function generateEntryFiles(configMeta, configOptions, modulesMeta, env) {
     // config
     await __generateConfig();
@@ -12,6 +13,8 @@ export async function generateEntryFiles(configMeta, configOptions, modulesMeta,
     await __generateEnvJson();
     // app
     await __generateApp();
+    // zod
+    await generateZod(configOptions);
     //////////////////////////////
     async function __generateConfig() {
         // check config

package/dist/lib/bean/toolsBin/generateZod.d.ts

@@ -0,0 +1,2 @@
+import type { VonaBinConfigOptions } from './types.ts';
+export declare function generateZod(configOptions: VonaBinConfigOptions): Promise<void>;

package/dist/lib/bean/toolsBin/generateZod.js

@@ -0,0 +1,48 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import fse from 'fs-extra';
+import { copyTemplateIfNeed, pathToHref } from "../../utils.js";
+const __ImportZodCore = 'zod/v4/core';
+export async function generateZod(configOptions) {
+    await __generateZodCoreUtil(configOptions);
+    await __generateZodCoreSchemas(configOptions);
+}
+async function __generateZodCoreUtil(configOptions) {
+    const pathZodCore = parseZodCorePath(configOptions.appDir);
+    const fileSrc = path.join(pathZodCore, 'util.js');
+    const fileSrcBak = path.join(pathZodCore, 'util-origin.js');
+    copyTemplateIfNeed(fileSrc, fileSrcBak);
+    const content = fse.readFileSync(fileSrcBak).toString();
+    const contentNew = content
+        .replace('export function finalizeIssue', `let __localeAdapterFn;
+export function setLocaleAdapter(localeAdapterFn) {
+  __localeAdapterFn=localeAdapterFn;
+}
+export function finalizeIssue`)
+        .replace('const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??', `const msg = unwrapMessage(iss.inst?._zod.def?.error?.(iss));
+        const message = (__localeAdapterFn?__localeAdapterFn(msg):msg) ??`);
+    fse.writeFileSync(fileSrc, contentNew);
+}
+async function __generateZodCoreSchemas(configOptions) {
+    const pathZodCore = parseZodCorePath(configOptions.appDir);
+    const fileSrc = path.join(pathZodCore, 'schemas.js');
+    const fileSrcBak = path.join(pathZodCore, 'schemas-origin.js');
+    copyTemplateIfNeed(fileSrc, fileSrcBak);
+    const content = fse.readFileSync(fileSrcBak).toString();
+    const contentNew = content
+        .replace('export const $ZodType =', `let __parseAdapterFn;
+export function setParseAdapter(parseAdapterFn) {
+    __parseAdapterFn = parseAdapterFn;
+}
+export const $ZodType =`)
+        .replace('inst._zod.run = inst._zod.parse;', 'inst._zod.run = __parseAdapterFn ? __parseAdapterFn(inst, inst._zod.parse) : inst._zod.parse;')
+        .replace(/inst._zod.run = (\(payload, ctx\) => \{[\s\S]*?return runChecks\(result, checks, ctx\);\s*\};)/, (_, $0) => {
+        return `const __run = ${$0}\ninst._zod.run = __parseAdapterFn ? __parseAdapterFn(inst, __run) : __run;`;
+    });
+    fse.writeFileSync(fileSrc, contentNew);
+}
+function parseZodCorePath(appDir) {
+    const require = createRequire(pathToHref(path.join(appDir, '/')));
+    const fileCoreIndex = require.resolve(__ImportZodCore);
+    return path.dirname(fileCoreIndex);
+}

package/dist/lib/utils.d.ts

@@ -15,3 +15,4 @@ export declare function saveJSONFile(fileName: string, json: object): Promise<vo
 export declare function pathToHref(fileName: string): string;
 export declare function getOutDir(): string;
 export declare function getOutReleasesDir(): string;
+export declare function copyTemplateIfNeed(fileSrc: string, fileDest: string): void;

package/dist/lib/utils.js

@@ -69,3 +69,8 @@ export function getOutDir() {
 export function getOutReleasesDir() {
     return `dist-releases/${process.env.META_FLAVOR}-${process.env.APP_VERSION}`;
 }
+export function copyTemplateIfNeed(fileSrc, fileDest) {
+    if (!fse.existsSync(fileDest)) {
+        fse.copyFileSync(fileSrc, fileDest);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-cli-set-api",
   "type": "module",
-  "version": "1.0.172",
+  "version": "1.0.176",
   "description": "vona cli-set-api",
   "publishConfig": {
     "access": "public"
@@ -61,7 +61,7 @@
     "ts-node": "^10.9.2",
     "urllib": "^4.6.11",
     "uuid": "^11.1.0",
-    "vona-core": "^5.0.48",
+    "vona-core": "^5.0.49",
     "why-is-node-running": "^3.2.2",
     "yargs-parser": "^21.1.1"
   },