cabloy 5.1.179 → 5.1.180

package/vona/src/suite/a-demo/modules/demo-demonstration/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "vona-module-demo-demonstration",
+  "version": "5.0.0",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {
+    "vona-module-a-aspect": "workspace:^",
+    "vona-module-a-user": "workspace:^"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "demo-demonstration",
+  "vonaModule": {
+    "dependencies": {
+      "a-vona": "5.0.0"
+    }
+  }
+}

package/vona/src/suite/a-demo/modules/demo-demonstration/src/.metadata/index.ts

@@ -0,0 +1,68 @@
+// eslint-disable
+/** guard: begin */
+export * from '../bean/guard.demonstration.ts';
+import type { IGuardOptionsDemonstration } from '../bean/guard.demonstration.ts';
+import 'vona-module-a-aspect';
+declare module 'vona-module-a-aspect' {
+
+    export interface IGuardRecordGlobal {
+      'demo-demonstration:demonstration': IGuardOptionsDemonstration;
+    }
+
+
+}
+declare module 'vona-module-demo-demonstration' {
+
+        export interface GuardDemonstration {
+          /** @internal */
+          get scope(): ScopeModuleDemoDemonstration;
+        }
+
+          export interface GuardDemonstration {
+            get $beanFullName(): 'demo-demonstration.guard.demonstration';
+            get $onionName(): 'demo-demonstration:demonstration';
+            get $onionOptions(): IGuardOptionsDemonstration;
+          }
+}
+/** guard: end */
+/** locale: begin */
+import { locales } from './locales.ts';
+/** locale: end */
+/** error: begin */
+export * from '../config/errors.ts';
+import type { errors } from '../config/errors.ts';
+/** error: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleErrors, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleDemoDemonstration extends BeanScopeBase {}
+
+export interface ScopeModuleDemoDemonstration {
+  util: BeanScopeUtil;
+error: TypeModuleErrors<typeof errors>;
+locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'demo-demonstration': ScopeModuleDemoDemonstration;
+  }
+
+  export interface IBeanScopeContainer {
+    demoDemonstration: ScopeModuleDemoDemonstration;
+  }
+
+
+
+  export interface IBeanScopeLocale {
+    'demo-demonstration': (typeof locales)[TypeLocaleBase];
+  }
+
+  export interface IBeanScopeErrors {
+    'demo-demonstration': typeof errors;
+  }
+}
+/** scope: end */

package/vona/src/suite/a-demo/modules/demo-demonstration/src/.metadata/locales.ts

@@ -0,0 +1,18 @@
+import type { TypeLocaleBase } from 'vona';
+
+import { $makeLocaleMagic } from 'vona';
+
+import locale_en_us from '../config/locale/en-us.ts';
+import locale_zh_cn from '../config/locale/zh-cn.ts';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};
+
+export function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(
+  key: K,
+  ...args: any[]
+): any {
+  return $makeLocaleMagic(`demo-demonstration::${key}`, ...args);
+}

package/vona/src/suite/a-demo/modules/demo-demonstration/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'demo-demonstration';
+export { ScopeModuleDemoDemonstration as ScopeModule } from './index.ts';

package/vona/src/suite/a-demo/modules/demo-demonstration/src/bean/guard.demonstration.ts

@@ -0,0 +1,68 @@
+import type { Next } from 'vona';
+import type { IDecoratorGuardOptionsGlobal, IGuardExecute } from 'vona-module-a-aspect';
+
+import { BeanBase, Global, useApp } from 'vona';
+import { Guard } from 'vona-module-a-aspect';
+
+const app = useApp();
+
+const methodsForWrite = ['POST', 'PATCH', 'DELETE', 'PUT'];
+
+export function parseUsernameWhitelist(value: string | undefined): string[] {
+  if (!value) return [];
+  return [
+    ...new Set(
+      value
+        .split(',')
+        .map(item => item.trim())
+        .filter(Boolean),
+    ),
+  ];
+}
+
+export interface IGuardOptionsDemonstration extends IDecoratorGuardOptionsGlobal {
+  methodsForWrite: string[];
+  usernameWhitelist: string[];
+}
+
+@Guard<IGuardOptionsDemonstration>({
+  enable: app.meta.env.DEMONSTRATION_ENABLED === 'true',
+  methodsForWrite,
+  usernameWhitelist: parseUsernameWhitelist(app.meta.env.DEMONSTRATION_USERNAME_WHITELIST),
+  ignore: [
+    '/home/user/passport/logout',
+    '/home/user/passport/register',
+    '/home/user/passport/login',
+    '/home/user/passport/login/:module/:providerName/:clientName?',
+    '/home/user/passport/associate/:module/:providerName/:clientName?',
+    '/home/user/passport/migrate/:module/:providerName/:clientName?',
+    '/home/user/passport/refreshAuthToken',
+    '/home/user/passport/createPassportJwtFromOauthCode',
+    '/home/user/passport/createTempAuthToken',
+    '/auth/passport/callback',
+  ],
+  dependencies: 'a-user:passport',
+})
+@Global()
+export class GuardDemonstration extends BeanBase implements IGuardExecute {
+  async execute(options: IGuardOptionsDemonstration, next: Next): Promise<boolean> {
+    const method = this.ctx.method.toUpperCase();
+    if (!options.methodsForWrite.some(item => item.toUpperCase() === method)) {
+      return next();
+    }
+
+    const user = this.bean.passport.currentUser;
+    if (
+      this.bean.passport.isAuthenticated &&
+      this.bean.passport.isAccountActive &&
+      user &&
+      !user.anonymous &&
+      options.usernameWhitelist.includes(user.name)
+    ) {
+      return next();
+    }
+
+    this.scope.error.WriteForbidden.throw();
+    return false;
+  }
+}

package/vona/src/suite/a-demo/modules/demo-demonstration/src/config/errors.ts

@@ -0,0 +1,6 @@
+export const errors = {
+  WriteForbidden: {
+    code: 1001,
+    status: 403,
+  },
+} as const;

package/vona/src/suite/a-demo/modules/demo-demonstration/src/config/locale/en-us.ts

@@ -0,0 +1,3 @@
+export default {
+  WriteForbidden: 'This operation is forbidden in demonstration mode',
+};

package/vona/src/suite/a-demo/modules/demo-demonstration/src/config/locale/zh-cn.ts

@@ -0,0 +1,3 @@
+export default {
+  WriteForbidden: '在演示模式下禁止此操作',
+};

package/vona/src/suite/a-demo/modules/demo-demonstration/src/index.ts

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

package/vona/src/suite/a-demo/modules/demo-demonstration/src/types/index.ts

@@ -0,0 +1,8 @@
+declare module 'vona' {
+  export interface VonaConfigEnv {
+    DEMONSTRATION_ENABLED: string | undefined;
+    DEMONSTRATION_USERNAME_WHITELIST: string | undefined;
+  }
+}
+
+export {};

package/vona/src/suite/a-demo/modules/demo-demonstration/test/guardDemonstration.test.ts

@@ -0,0 +1,121 @@
+import { catchError } from '@cabloy/utils';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { GuardDemonstration, parseUsernameWhitelist } from 'vona-module-demo-demonstration';
+
+const guardBeanName = 'demo-demonstration.guard.demonstration';
+const businessRoute = {
+  controllerBeanFullName: 'test.controller.business',
+  action: 'write',
+};
+
+function guard() {
+  return app.bean._getBean(guardBeanName as never) as GuardDemonstration;
+}
+
+function setRequest(method: string, route = businessRoute) {
+  Object.defineProperty(app.ctx, 'method', {
+    configurable: true,
+    value: method,
+  });
+  app.ctx.route = route as any;
+  app.ctx.innerAccess = false;
+}
+
+function isGuardEnabledForRoute(routePathRaw: string, enable = true): boolean {
+  const options = app.bean.onion.guard.getOnionOptions('demo-demonstration:demonstration');
+  assert.ok(options);
+  return app.bean.onion.checkOnionOptionsEnabled({ ...options, enable }, routePathRaw);
+}
+
+describe('guardDemonstration.test.ts', () => {
+  it('parses a trimmed, deduplicated username whitelist and exposes localized errors', async () => {
+    assert.deepEqual(parseUsernameWhitelist(' admin, demo, ,admin '), ['admin', 'demo']);
+    assert.deepEqual(parseUsernameWhitelist(undefined), []);
+    assert.deepEqual(parseUsernameWhitelist(''), []);
+
+    await app.bean.executor.mockCtx(async () => {
+      const scopeDemonstration = app.scope('demo-demonstration');
+      assert.equal(
+        scopeDemonstration.locale.WriteForbidden.locale('zh-cn'),
+        '在演示模式下禁止此操作',
+      );
+      assert.equal(
+        scopeDemonstration.locale.WriteForbidden.locale('en-us'),
+        'This operation is forbidden in demonstration mode',
+      );
+    });
+  });
+
+  it('does not select disabled guards and allows read methods', async () => {
+    assert.equal(isGuardEnabledForRoute('/test/business/write', false), false);
+
+    await app.bean.executor.mockCtx(async () => {
+      const bean = guard();
+      setRequest('GET');
+      assert.equal(
+        await bean.execute(
+          { enable: true, methodsForWrite: ['POST'], usernameWhitelist: [] } as any,
+          async () => true,
+        ),
+        true,
+      );
+    });
+  });
+
+  it('rejects non-whitelisted writes with the module error', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock('admin');
+      try {
+        setRequest('POST');
+        const [_, err] = await catchError(() =>
+          guard().execute(
+            { enable: true, methodsForWrite: ['POST'], usernameWhitelist: [] } as any,
+            async () => true,
+          ),
+        );
+        assert.equal(err?.code, 'demo-demonstration:1001');
+        assert.equal(err?.status, 403);
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('allows an authenticated whitelisted user to write', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock('admin');
+      try {
+        setRequest('DELETE');
+        assert.equal(
+          await guard().execute(
+            { enable: true, methodsForWrite: ['DELETE'], usernameWhitelist: ['admin'] } as any,
+            async () => true,
+          ),
+          true,
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('excludes only the configured authentication and OAuth route paths', () => {
+    for (const routePathRaw of [
+      '/home/user/passport/login',
+      '/home/user/passport/login/:module/:providerName/:clientName?',
+      '/home/user/passport/logout',
+      '/home/user/passport/register',
+      '/home/user/passport/associate/:module/:providerName/:clientName?',
+      '/home/user/passport/migrate/:module/:providerName/:clientName?',
+      '/home/user/passport/refreshAuthToken',
+      '/home/user/passport/createPassportJwtFromOauthCode',
+      '/home/user/passport/createTempAuthToken',
+      '/auth/passport/callback',
+    ]) {
+      assert.equal(isGuardEnabledForRoute(routePathRaw), false);
+    }
+    assert.equal(isGuardEnabledForRoute('/test/business/write'), true);
+  });
+});

package/vona/src/suite/a-demo/modules/demo-demonstration/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/vona/src/suite/a-demo/modules/demo-demonstration/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}

package/vona/src/suite/a-demo/package.json

@@ -6,7 +6,8 @@
   "files": [],
   "type": "module",
   "dependencies": {
-    "vona-module-demo-basic": "^5.0.0"
+    "vona-module-demo-basic": "^5.0.0",
+    "vona-module-demo-demonstration": "^5.0.0"
   },
   "title": "a-demo"
 }

package/vona/src/suite/a-demo/tsconfig.json

@@ -4,6 +4,9 @@
   "references": [
     {
       "path": "modules/demo-basic/tsconfig.build.json"
+    },
+    {
+      "path": "modules/demo-demonstration/tsconfig.build.json"
     }
   ],
   "exclude": ["modules"]

package/vona/src/suite/a-training/modules/training-student/src/config/locale/en-us.ts

@@ -19,6 +19,15 @@ export default {
   StudentImage: 'Student Image',
   DossierFiles: 'Dossier Files',
   Summary: 'Summary',
+  StudentController: 'Student Management',
+  StudentCreate: 'Create Student',
+  StudentSelect: 'List Students',
+  StudentView: 'View Student',
+  StudentUpdate: 'Update Student',
+  StudentSummary: 'View Student Summary',
+  StudentDelete: 'Delete Student',
+  StudentDeleteForce: 'Permanently Delete Student',
+  StudentDeleteBulk: 'Bulk Delete Students',
   LevelTitle: 'Level Title',
   DescriptionLength: 'Description Length',
   ForceDelete: 'Force Delete',

package/vona/src/suite/a-training/modules/training-student/src/config/locale/zh-cn.ts

@@ -19,6 +19,15 @@ export default {
   StudentImage: '学生图片',
   DossierFiles: '培训档案附件',
   Summary: '摘要',
+  StudentController: '学生管理',
+  StudentCreate: '创建学生',
+  StudentSelect: '查询学生列表',
+  StudentView: '查看学生',
+  StudentUpdate: '更新学生',
+  StudentSummary: '查看学生摘要',
+  StudentDelete: '删除学生',
+  StudentDeleteForce: '永久删除学生',
+  StudentDeleteBulk: '批量删除学生',
   LevelTitle: '阶段名称',
   DescriptionLength: '描述长度',
   ForceDelete: '强制删除',

package/vona/src/suite/a-training/modules/training-student/src/controller/student.ts

@@ -22,39 +22,41 @@ import { DtoStudentView } from '../dto/studentView.tsx';
 
 export interface IControllerOptionsStudent extends IDecoratorControllerOptions {}
 
-@Controller<IControllerOptionsStudent>('student')
+@Controller<IControllerOptionsStudent>('student', {
+  summary: $locale('StudentController'),
+})
 @Resource()
 export class ControllerStudent extends BeanBase {
-  @Web.post()
+  @Web.post('', { summary: $locale('StudentCreate') })
   @Api.body(v.tableIdentity())
-  @Passport.systemAdmin()
+  @Passport.rbac()
   async create(@Arg.body() student: DtoStudentCreate): Promise<TableIdentity> {
     return (await this.scope.service.student.create(student)).id;
   }
 
-  @Web.get()
+  @Web.get('', { summary: $locale('StudentSelect') })
   @Api.body(DtoStudentSelectRes)
   @Core.serializer()
-  @Passport.systemAdmin()
+  @Passport.rbac()
   async select(
     @Arg.filter(DtoStudentSelectReq) params: IQueryParams<ModelStudent>,
   ): Promise<DtoStudentSelectRes> {
     return await this.scope.service.student.select(params);
   }
 
-  @Web.get(':id')
+  @Web.get(':id', { summary: $locale('StudentView') })
   @Api.body(v.optional(), v.object(DtoStudentView))
   @Core.serializer()
-  @Passport.systemAdmin()
+  @Passport.rbac()
   async view(
     @Arg.param('id', v.tableIdentity()) id: TableIdentity,
   ): Promise<DtoStudentView | undefined> {
     return await this.scope.service.student.view(id);
   }
 
-  @Web.patch(':id')
+  @Web.patch(':id', { summary: $locale('StudentUpdate') })
   @Api.body(z.null())
-  @Passport.systemAdmin()
+  @Passport.rbac()
   async update(
     @Arg.param('id', v.tableIdentity()) id: TableIdentity,
     @Arg.body() student: DtoStudentUpdate,
@@ -62,33 +64,33 @@ export class ControllerStudent extends BeanBase {
     await this.scope.service.student.update(id, student);
   }
 
-  @Web.get('summary/:id')
+  @Web.get('summary/:id', { summary: $locale('StudentSummary') })
   @Api.body(v.optional(), v.object(DtoStudentSummary))
   @Core.serializer()
-  @Passport.systemAdmin()
+  @Passport.rbac({ actionInherit: 'view' })
   async summary(
     @Arg.param('id', v.tableIdentity()) id: TableIdentity,
   ): Promise<DtoStudentSummary | undefined> {
     return await this.scope.service.student.summary(id);
   }
 
-  @Web.post('bulk/delete', { summary: $locale('BulkDelete') })
+  @Web.post('bulk/delete', { summary: $locale('StudentDeleteBulk') })
   @Api.body(z.null())
-  @Passport.systemAdmin()
+  @Passport.rbac({ actionInherit: 'delete' })
   async deleteBulk(@Arg.body() command: DtoStudentDeleteBulk): Promise<void> {
     await this.scope.service.student.deleteBulk(command.ids);
   }
 
-  @Web.delete(':id')
+  @Web.delete(':id', { summary: $locale('StudentDelete') })
   @Api.body(z.null())
-  @Passport.systemAdmin()
+  @Passport.rbac()
   async delete(@Arg.param('id', v.tableIdentity()) id: TableIdentity): Promise<void> {
     await this.scope.service.student.delete(id);
   }
 
-  @Web.delete('deleteForce/:id')
+  @Web.delete('deleteForce/:id', { summary: $locale('StudentDeleteForce') })
   @Api.body(z.null())
-  @Passport.systemAdmin()
+  @Passport.rbac({ actionInherit: 'delete' })
   async deleteForce(@Arg.param('id', v.tableIdentity()) id: TableIdentity): Promise<void> {
     await this.scope.service.student.deleteForce(id);
   }

package/vona/src/suite/a-training/modules/training-student/test/student.test.ts

@@ -2,7 +2,9 @@ import type { DtoStudentSelectRes, EntityStudent } from 'vona-module-training-st
 
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
+import { appMetadata } from 'vona';
 import { app } from 'vona-mock';
+import { SymbolOpenApiOptions } from 'vona-module-a-openapiutils';
 import {
   DtoStudentCreate,
   DtoStudentSelectResItem,
@@ -64,13 +66,39 @@ describe('student.test.ts', { concurrency: false }, () => {
     });
   });
 
-  it('action:student:bulkDeleteOpenapi', async () => {
+  it('action:student:openapiMetadata', async () => {
     await app.bean.executor.mockCtx(async () => {
       const controller = app.bean.onion.controller
         .getOnionsEnabledCached()
         .find(item => item.beanOptions.beanFullName === 'training-student.controller.student')
         ?.beanOptions.beanClass;
       if (!controller) throw new Error('training-student.controller.student not found');
+      const controllerMetadata = appMetadata.getMetadata<any>(SymbolOpenApiOptions, controller);
+      assert.equal(controllerMetadata?.summary?.toString(), 'training-student::StudentController');
+      const expectedSummaries = {
+        create: ['post', '/api/training/student', 'Create Student'],
+        select: ['get', '/api/training/student', 'List Students'],
+        view: ['get', '/api/training/student/{id}', 'View Student'],
+        update: ['patch', '/api/training/student/{id}', 'Update Student'],
+        summary: ['get', '/api/training/student/summary/{id}', 'View Student Summary'],
+        delete: ['delete', '/api/training/student/{id}', 'Delete Student'],
+        deleteForce: [
+          'delete',
+          '/api/training/student/deleteForce/{id}',
+          'Permanently Delete Student',
+        ],
+        deleteBulk: ['post', '/api/training/student/bulk/delete', 'Bulk Delete Students'],
+      } as const;
+      for (const [action, [method, path, summary]] of Object.entries(expectedSummaries)) {
+        const apiJson = await app.bean.openapi.generateJsonOfControllerAction(
+          controller,
+          action,
+          'V31',
+        );
+        const operation = (apiJson.paths as any)?.[path]?.[method];
+        assert.ok(operation, `${action} operation is missing`);
+        assert.equal(operation.summary?.toJSON(), summary);
+      }
       const apiJson = await app.bean.openapi.generateJsonOfControllerAction(
         controller,
         'deleteBulk',
@@ -78,7 +106,6 @@ describe('student.test.ts', { concurrency: false }, () => {
       );
       const operation = apiJson.paths?.['/api/training/student/bulk/delete']?.post;
       assert.equal(operation?.operationId, 'TrainingStudent_deleteBulk');
-      assert.equal(operation?.summary?.toJSON(), 'Bulk Delete');
       const requestSchema = operation?.requestBody?.content?.['application/json']?.schema as any;
       const requestSchemaRef = requestSchema?.$ref;
       assert.ok(requestSchemaRef);
@@ -639,32 +666,25 @@ describe('student.test.ts', { concurrency: false }, () => {
     });
   });
 
-  it('action:student:systemAdmin', async () => {
+  it('action:student:rbacCatalog', async () => {
     await app.bean.executor.mockCtx(async () => {
-      await app.bean.passport.signinMock();
-      try {
-        app.bean.passport.current!.roles = [];
-        const actions = [
-          'create',
-          'select',
-          'view',
-          'update',
-          'summary',
-          'delete',
-          'deleteBulk',
-          'deleteForce',
-        ];
-        const permissions = await Promise.all(
-          actions.map(action =>
-            app.bean.permission.retrievePermissionAction('training-student:student', action),
-          ),
-        );
-        assert.deepEqual(
-          permissions,
-          actions.map(() => false),
-        );
-      } finally {
-        await app.bean.passport.signout();
+      const catalog = app.bean.rbacCatalog.getCatalog();
+      const controllerBeanFullName = 'training-student.controller.student';
+      const expectedInherits = {
+        create: undefined,
+        select: undefined,
+        view: undefined,
+        update: undefined,
+        summary: `${controllerBeanFullName}#view`,
+        delete: undefined,
+        deleteBulk: `${controllerBeanFullName}#delete`,
+        deleteForce: `${controllerBeanFullName}#delete`,
+      } as const;
+      for (const [action, actionInheritKey] of Object.entries(expectedInherits)) {
+        const descriptor = catalog.get(`${controllerBeanFullName}#${action}`);
+        assert.ok(descriptor, `${action} RBAC action is missing`);
+        assert.equal(descriptor.actionInheritKey, actionInheritKey);
+        assert.equal(descriptor.options.dataScope, undefined);
       }
     });
   });

package/vona/src/suite-vendor/a-cabloy/modules/a-rbac/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-rbac",
-  "version": "5.0.6",
+  "version": "5.0.7",
   "description": "",
   "keywords": [
     "Vona Module"