cabloy 5.1.152 → 5.1.154

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/lib/beanSsrSiteBase.ts

@@ -15,6 +15,7 @@ import path from 'node:path';
 import { BeanBase, cast, deepExtend, SymbolModuleName } from 'vona';
 import { checkErrorJwtExpiredAndThrow } from 'vona-module-a-jwt';
 
+import type { TypeEventResolveMenuVisibilityResult } from '../bean/event.resolveMenuVisibility.ts';
 import type { TypeEventRetrieveMenusResult } from '../bean/event.retrieveMenus.ts';
 import type { TypeEventRetrieveMenusSiteResult } from '../bean/event.retrieveMenusSite.ts';
 import type {
@@ -34,6 +35,13 @@ import type {
 import { ServiceDevProxy } from '../service/devProxy.ts';
 import { ServiceSsrHandler } from '../service/ssrHandler.ts';
 import { SymbolCacheMenus } from './const.ts';
+import { checkSsrBinding } from './ssrMenuEligibility.ts';
+import {
+  projectPublicSsrMenuGroups,
+  projectPublicSsrMenus,
+  resolveSsrMenuVisibilityDefault,
+  resolveVisibleSsrMenuGroups,
+} from './ssrMenuVisibility.ts';
 
 export class BeanSsrSiteBase<
   SsrSiteOptions extends IDecoratorSsrSiteOptions = IDecoratorSsrSiteOptions,
@@ -154,13 +162,22 @@ export class BeanSsrSiteBase<
   async retrieveMenus(): Promise<TypeEventRetrieveMenusResult | undefined> {
     const menusPrepared = await this._getMenusCache(this.ctx.locale);
     if (!menusPrepared) return;
-    const menus = menusPrepared.menus
-      ?.filter(menu => !menu.roles?.length || this.bean.passport.checkRoleName(menu.roles))
-      .map(menu => {
-        const { roles: _roles, ...menuPublic } = menu;
-        return menuPublic;
-      });
-    return { menus, groups: menusPrepared.groups };
+    const menusPreparedVisible = await this.$scope.ssr.event.resolveMenuVisibility.emit(
+      {
+        ssrSiteName: this.$onionName,
+        menus: menusPrepared.menus ?? [],
+        currentRoleIds: (this.bean.passport.currentRoles ?? []).map(role => role.id),
+      },
+      async data => this._resolveMenuVisibilityDefault(data.menus),
+    );
+    const groupsPreparedVisible = resolveVisibleSsrMenuGroups(
+      menusPreparedVisible,
+      menusPrepared.groups ?? [],
+    );
+    return {
+      menus: projectPublicSsrMenus(menusPreparedVisible),
+      groups: projectPublicSsrMenuGroups(groupsPreparedVisible),
+    };
   }
 
   public get siteOptions() {
@@ -282,6 +299,12 @@ export class BeanSsrSiteBase<
     };
   }
 
+  private _resolveMenuVisibilityDefault(
+    menus: ISsrMenuItemPrepared[],
+  ): TypeEventResolveMenuVisibilityResult {
+    return resolveSsrMenuVisibilityDefault(menus, roles => this.bean.passport.checkRoleName(roles));
+  }
+
   private async _getMenusCache(
     locale: keyof ILocaleRecord,
   ): Promise<TypeEventRetrieveMenusSiteResult | undefined> {
@@ -335,8 +358,8 @@ export class BeanSsrSiteBase<
     for (const ssrMenu of ssrMenus) {
       const siteMenuOptions = ssrMenu.beanOptions
         .options as IDecoratorSsrMenuOptions<IDecoratorSsrSiteOptions>;
-      if (!_checkValidSiteOrLocale(siteOnionName, siteMenuOptions.site)) continue;
-      if (!_checkValidSiteOrLocale(locale, siteMenuOptions.locale)) continue;
+      if (!checkSsrBinding(siteOnionName, siteMenuOptions.site)) continue;
+      if (!checkSsrBinding(locale, siteMenuOptions.locale)) continue;
       const menusFrom =
         siteMenuOptions.items || (siteMenuOptions.item && { '': siteMenuOptions.item });
       if (!menusFrom) continue;
@@ -356,10 +379,3 @@ export class BeanSsrSiteBase<
     return menus;
   }
 }
-
-function _checkValidSiteOrLocale(expect: any, target: any) {
-  if (!target) return true;
-  if (Array.isArray(target) && target.includes(expect)) return true;
-  if (expect === target) return true;
-  return false;
-}

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/lib/index.ts

@@ -2,5 +2,7 @@ export * from './beanSsrSiteBase.ts';
 export * from './const.ts';
 export * from './ssr.ts';
 export * from './ssrMenu.ts';
+export * from './ssrMenuEligibility.ts';
+export * from './ssrMenuVisibility.ts';
 export * from './ssrMenuGroup.ts';
 export * from './ssrSite.ts';

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/lib/ssrMenuEligibility.ts

@@ -0,0 +1,107 @@
+import type { IOnionSlice } from 'vona-module-a-onion';
+
+import type {
+  IDecoratorSsrMenuOptions,
+  ISsrMenuCatalog,
+  ISsrMenuEligibility,
+  ISsrMenuRecord,
+} from '../types/ssrMenu.ts';
+import type { IDecoratorSsrMenuGroupOptions, ISsrMenuGroupRecord } from '../types/ssrMenuGroup.ts';
+import type { IDecoratorSsrSiteOptions } from '../types/ssrSite.ts';
+
+export function checkSsrBinding<T>(expect: T, target: T | T[] | null | ''): boolean {
+  if (target === undefined || target === null || target === '') return true;
+  if (Array.isArray(target)) return target.some(item => item === expect);
+  return target === expect;
+}
+
+export function resolveSsrMenuCatalog(
+  sites: ISsrMenuCatalog['sites'],
+  ssrMenus: IOnionSlice<ISsrMenuRecord, keyof ISsrMenuRecord, unknown>[],
+  ssrMenuGroups: IOnionSlice<ISsrMenuGroupRecord, keyof ISsrMenuGroupRecord, unknown>[] = [],
+): ISsrMenuCatalog {
+  const menus: ISsrMenuCatalog['menus'] = [];
+  const groups: ISsrMenuCatalog['groups'] = [];
+  for (const { ssrSiteName } of sites) {
+    for (const ssrMenu of ssrMenus) {
+      const options = ssrMenu.beanOptions.options as
+        | IDecoratorSsrMenuOptions<IDecoratorSsrSiteOptions>
+        | undefined;
+      if (!options || !checkSsrBinding(ssrSiteName, options.site)) continue;
+      const items = options.items || (options.item && { '': options.item });
+      if (!items) continue;
+      for (const key of Object.keys(items)) {
+        const item = items[key];
+        menus.push({
+          ssrSiteName,
+          ssrMenuName: key ? `${ssrMenu.name}#${key}` : ssrMenu.name,
+          onionName: ssrMenu.name,
+          roles: item.roles,
+          ...withoutUndefined({
+            title: item.title,
+            description: item.description,
+            icon: item.icon,
+            order: item.order,
+            group: item.group,
+            separator: item.separator,
+            link: item.link,
+            external: item.external,
+            target: item.target,
+            meta: item.meta,
+          }),
+        });
+      }
+    }
+  }
+  for (const { ssrSiteName } of sites) {
+    for (const ssrMenuGroup of ssrMenuGroups) {
+      const options = ssrMenuGroup.beanOptions.options as
+        | IDecoratorSsrMenuGroupOptions<IDecoratorSsrSiteOptions>
+        | undefined;
+      if (!options || !checkSsrBinding(ssrSiteName, options.site) || !options.item) {
+        continue;
+      }
+      const item = options.item;
+      groups.push({
+        ssrSiteName,
+        ssrMenuGroupName: ssrMenuGroup.name,
+        onionName: ssrMenuGroup.name,
+        title: item.title,
+        description: item.description,
+        icon: item.icon,
+        order: item.order,
+        group: item.group,
+        collapsed: item.collapsed,
+      });
+    }
+  }
+  return { sites: [...sites], menus, groups };
+}
+
+function withoutUndefined<T extends object>(value: T): T {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)) as T;
+}
+
+export function resolveSsrMenuEligibility(
+  ssrSiteName: string,
+  ssrMenuName: string,
+  ssrMenus: IOnionSlice<ISsrMenuRecord, keyof ISsrMenuRecord, unknown>[],
+): ISsrMenuEligibility | undefined {
+  for (const ssrMenu of ssrMenus) {
+    const options = ssrMenu.beanOptions.options as
+      | IDecoratorSsrMenuOptions<IDecoratorSsrSiteOptions>
+      | undefined;
+    if (!options || !checkSsrBinding(ssrSiteName, options.site)) continue;
+    const menus = options.items || (options.item && { '': options.item });
+    if (!menus) continue;
+    for (const key of Object.keys(menus)) {
+      const name = key ? `${ssrMenu.name}#${key}` : ssrMenu.name;
+      if (name !== ssrMenuName) continue;
+      return {
+        ssrSiteName,
+        ssrMenuName,
+        rolesDefined: menus[key].roles !== undefined,
+      };
+    }
+  }
+}

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/lib/ssrMenuVisibility.ts

@@ -0,0 +1,91 @@
+import type { IMenuGroup, IMenuItem } from 'vona-module-a-menu';
+
+import type { ISsrMenuItemPrepared } from '../types/ssrMenu.ts';
+
+export function resolveSsrMenuVisibilityDefault(
+  menus: ISsrMenuItemPrepared[],
+  checkRoleName: (roles: NonNullable<ISsrMenuItemPrepared['roles']>) => boolean,
+): ISsrMenuItemPrepared[] {
+  return menus.filter(menu => {
+    if (menu.roles === undefined) return true;
+    if (!menu.roles.length) return false;
+    return checkRoleName(menu.roles);
+  });
+}
+
+export function resolveVisibleSsrMenuGroups(
+  menus: ISsrMenuItemPrepared[],
+  groups: IMenuGroup[],
+): IMenuGroup[] {
+  const groupsByName = new Map(groups.map(group => [group.name, group]));
+  const visibleGroupNames = new Set<string>();
+  const retainGroup = (name: string) => {
+    const group = groupsByName.get(name);
+    if (!group || visibleGroupNames.has(name)) return;
+    visibleGroupNames.add(name);
+    for (const parentName of getGroupNames(group.group)) {
+      retainGroup(parentName);
+    }
+  };
+  for (const menu of menus) {
+    for (const groupName of getGroupNames(menu.group)) {
+      retainGroup(groupName);
+    }
+  }
+  return groups.filter(group => visibleGroupNames.has(group.name));
+}
+
+export function projectPublicSsrMenus(menus: ISsrMenuItemPrepared[]): IMenuItem[] {
+  return menus.map(menu => {
+    const {
+      name,
+      title,
+      description,
+      icon,
+      order,
+      group,
+      separator,
+      link,
+      external,
+      target,
+      meta,
+    } = menu;
+    return _withoutUndefined<IMenuItem>({
+      name,
+      title,
+      description,
+      icon,
+      order,
+      group,
+      separator,
+      link,
+      external,
+      target,
+      meta,
+    });
+  });
+}
+
+export function projectPublicSsrMenuGroups(groups: IMenuGroup[]): IMenuGroup[] {
+  return groups.map(group => {
+    const { name, title, description, icon, order, group: parentGroup, collapsed } = group;
+    return _withoutUndefined<IMenuGroup>({
+      name,
+      title,
+      description,
+      icon,
+      order,
+      group: parentGroup,
+      collapsed,
+    });
+  });
+}
+
+function _withoutUndefined<T extends { name: string }>(value: T): T {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)) as T;
+}
+
+function getGroupNames(group: string | string[] | undefined): string[] {
+  if (!group) return [];
+  return Array.isArray(group) ? group : [group];
+}

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/service/ssr.ts

@@ -3,9 +3,11 @@ import type { IOnionSlice } from 'vona-module-a-onion';
 import { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
 
+import type { ISsrMenuCatalog, ISsrMenuEligibility } from '../types/ssrMenu.ts';
 import type { IDecoratorSsrSiteOptions, ISsrSiteRecord } from '../types/ssrSite.ts';
 
 import { SymbolCacheSites } from '../lib/const.ts';
+import { resolveSsrMenuCatalog, resolveSsrMenuEligibility } from '../lib/ssrMenuEligibility.ts';
 
 @Service()
 export class ServiceSsr extends BeanBase {
@@ -66,6 +68,34 @@ export class ServiceSsr extends BeanBase {
     return this.app.meta[SymbolCacheSites][cacheKey];
   }
 
+  public getMenuCatalog(): ISsrMenuCatalog {
+    const sites = this.getSitesEnabled().map(site => {
+      const options = site.beanOptions.options as IDecoratorSsrSiteOptions;
+      return {
+        ssrSiteName: site.name,
+        title: this.app.meta.text.locale(this.ctx.locale, options.title),
+      };
+    });
+    return resolveSsrMenuCatalog(
+      sites,
+      this.bean.onion.ssrMenu.getOnionsEnabled(),
+      this.bean.onion.ssrMenuGroup.getOnionsEnabled(),
+    );
+  }
+
+  public resolveMenuEligibility(
+    ssrSiteName: string,
+    ssrMenuName: string,
+  ): ISsrMenuEligibility | undefined {
+    const site = this.getSitesEnabled().find(item => item.name === ssrSiteName);
+    if (!site) return;
+    return resolveSsrMenuEligibility(
+      ssrSiteName,
+      ssrMenuName,
+      this.bean.onion.ssrMenu.getOnionsEnabled(),
+    );
+  }
+
   public prepareMenuLink(
     link?: keyof IDecoratorSsrSiteOptions['pages'],
   ): keyof IDecoratorSsrSiteOptions['pages'] | undefined {

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/types/ssrMenu.ts

@@ -18,11 +18,78 @@ export interface ISsrMenuItem<Pages extends {} = {}, Icons extends {} = {}> exte
 
 export type ISsrMenuItemPrepared = IMenuItem<any, any> & Pick<ISsrMenuItem<any, any>, 'roles'>;
 
+export interface ISsrMenuEligibility {
+  ssrSiteName: string;
+  ssrMenuName: string;
+  rolesDefined: boolean;
+}
+
+export interface ISsrMenuCatalogSiteInfo {
+  ssrSiteName: string;
+  title: string;
+}
+
+export interface ISsrMenuCatalogMenu {
+  ssrSiteName: string;
+  ssrMenuName: string;
+  onionName: string;
+  roles?: (keyof IRoleNameRecord)[];
+  title?: IMenuItem['title'];
+  description?: IMenuItem['description'];
+  icon?: IMenuItem['icon'];
+  order?: IMenuItem['order'];
+  group?: IMenuItem['group'];
+  separator?: IMenuItem['separator'];
+  link?: IMenuItem['link'];
+  external?: IMenuItem['external'];
+  target?: IMenuItem['target'];
+  meta?: IMenuItem['meta'];
+}
+
+export interface ISsrMenuCatalogGroup {
+  ssrSiteName: string;
+  ssrMenuGroupName: string;
+  onionName: string;
+  title?: IMenuGroup['title'];
+  description?: IMenuGroup['description'];
+  icon?: IMenuGroup['icon'];
+  order?: IMenuGroup['order'];
+  group?: IMenuGroup['group'];
+  collapsed?: IMenuGroup['collapsed'];
+}
+
+export interface ISsrMenuCatalog {
+  sites: ISsrMenuCatalogSiteInfo[];
+  menus: ISsrMenuCatalogMenu[];
+  groups: ISsrMenuCatalogGroup[];
+}
+
+export interface ISsrMenuCatalogPresentationMenu extends IMenuItem<any, any> {
+  ssrSiteName: string;
+  ssrMenuName: string;
+  configurable: boolean;
+}
+
+export interface ISsrMenuCatalogPresentationGroup extends IMenuGroup<any> {
+  ssrSiteName: string;
+}
+
+export interface ISsrMenuCatalogPresentation {
+  menus: ISsrMenuCatalogPresentationMenu[];
+  groups: ISsrMenuCatalogPresentationGroup[];
+}
+
 export interface ISsrMenusPrepared {
   menus?: ISsrMenuItemPrepared[];
   groups?: IMenuGroup[];
 }
 
+export interface ISsrMenuCatalogSite {
+  ssrSiteName: string;
+  menus: ISsrMenuItemPrepared[];
+  groups: IMenuGroup[];
+}
+
 // should not set default generic = IDecoratorSsrSiteOptions
 export interface IDecoratorSsrMenuOptions<
   SsrSiteOptions extends IDecoratorSsrSiteOptions,

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/test/ssrMenuEligibility.test.ts

@@ -0,0 +1,135 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import {
+  checkSsrBinding,
+  resolveSsrMenuCatalog,
+  resolveSsrMenuEligibility,
+} from '../src/lib/ssrMenuEligibility.ts';
+
+function createMenus() {
+  return [
+    {
+      name: 'test:omitted',
+      beanOptions: {
+        options: {
+          item: { roles: [] },
+          locale: ['en-us'],
+        },
+      },
+    },
+    {
+      name: 'test:keyed',
+      beanOptions: {
+        options: {
+          site: ['test:admin', 'test:web'],
+          items: {
+            static: { roles: ['systemAdmin'] },
+            public: {},
+          },
+        },
+      },
+    },
+    {
+      name: 'test:malformed',
+      beanOptions: {},
+    },
+  ] as any;
+}
+
+describe('ssrMenuEligibility.test.ts', () => {
+  it('matches unset, scalar, or array bindings', () => {
+    assert.equal(checkSsrBinding('test:admin', undefined), true);
+    assert.equal(checkSsrBinding('test:admin', null), true);
+    assert.equal(checkSsrBinding('test:admin', ''), true);
+    assert.equal(checkSsrBinding('test:admin', 'test:admin'), true);
+    assert.equal(checkSsrBinding('test:web', 'test:admin'), false);
+    assert.equal(checkSsrBinding('test:web', ['test:admin', 'test:web']), true);
+    assert.equal(checkSsrBinding('en-us', ['zh-cn', 'en-us']), true);
+    assert.equal(checkSsrBinding('en-us', []), false);
+  });
+
+  it('derives every enabled-site partition with site and onion identities', () => {
+    const catalog = resolveSsrMenuCatalog(
+      [
+        { ssrSiteName: 'test:admin', title: 'Admin' },
+        { ssrSiteName: 'test:web', title: 'Web' },
+      ],
+      createMenus(),
+    );
+    assert.deepEqual(catalog.sites, [
+      { ssrSiteName: 'test:admin', title: 'Admin' },
+      { ssrSiteName: 'test:web', title: 'Web' },
+    ]);
+    assert.deepEqual(catalog.menus, [
+      {
+        ssrSiteName: 'test:admin',
+        ssrMenuName: 'test:omitted',
+        onionName: 'test:omitted',
+        roles: [],
+      },
+      {
+        ssrSiteName: 'test:admin',
+        ssrMenuName: 'test:keyed#static',
+        onionName: 'test:keyed',
+        roles: ['systemAdmin'],
+      },
+      {
+        ssrSiteName: 'test:admin',
+        ssrMenuName: 'test:keyed#public',
+        onionName: 'test:keyed',
+        roles: undefined,
+      },
+      {
+        ssrSiteName: 'test:web',
+        ssrMenuName: 'test:omitted',
+        onionName: 'test:omitted',
+        roles: [],
+      },
+      {
+        ssrSiteName: 'test:web',
+        ssrMenuName: 'test:keyed#static',
+        onionName: 'test:keyed',
+        roles: ['systemAdmin'],
+      },
+      {
+        ssrSiteName: 'test:web',
+        ssrMenuName: 'test:keyed#public',
+        onionName: 'test:keyed',
+        roles: undefined,
+      },
+    ]);
+  });
+
+  it('resolves final leaves independently of locale', () => {
+    const menus = createMenus();
+    assert.deepEqual(resolveSsrMenuEligibility('test:admin', 'test:omitted', menus), {
+      ssrSiteName: 'test:admin',
+      ssrMenuName: 'test:omitted',
+      rolesDefined: true,
+    });
+    assert.deepEqual(resolveSsrMenuEligibility('test:web', 'test:omitted', menus), {
+      ssrSiteName: 'test:web',
+      ssrMenuName: 'test:omitted',
+      rolesDefined: true,
+    });
+  });
+
+  it('distinguishes dynamic/static leaves from public leaves and exact keyed names', () => {
+    const menus = createMenus();
+    assert.deepEqual(resolveSsrMenuEligibility('test:admin', 'test:keyed#static', menus), {
+      ssrSiteName: 'test:admin',
+      ssrMenuName: 'test:keyed#static',
+      rolesDefined: true,
+    });
+    assert.deepEqual(resolveSsrMenuEligibility('test:web', 'test:keyed#public', menus), {
+      ssrSiteName: 'test:web',
+      ssrMenuName: 'test:keyed#public',
+      rolesDefined: false,
+    });
+    assert.equal(resolveSsrMenuEligibility('test:admin', 'test:keyed', menus), undefined);
+    assert.equal(resolveSsrMenuEligibility('test:other', 'test:keyed#static', menus), undefined);
+    assert.equal(resolveSsrMenuEligibility('test:admin', 'test:missing', menus), undefined);
+    assert.equal(resolveSsrMenuEligibility('test:admin', 'test:malformed', menus), undefined);
+  });
+});

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/test/ssrMenuVisibility.test.ts

@@ -0,0 +1,64 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import {
+  projectPublicSsrMenuGroups,
+  projectPublicSsrMenus,
+  resolveSsrMenuVisibilityDefault,
+  resolveVisibleSsrMenuGroups,
+} from '../src/lib/ssrMenuVisibility.ts';
+
+function createMenus() {
+  return [
+    { name: 'test:public', title: 'Public', group: 'root' },
+    { name: 'test:dynamic', title: 'Dynamic', roles: [], group: 'root' },
+    { name: 'test:static', title: 'Static', roles: ['member'] },
+  ] as any;
+}
+
+describe('ssrMenuVisibility.test.ts', () => {
+  it('distinguishes public, dynamic-only, and static leaves', () => {
+    const menus = createMenus();
+    assert.deepEqual(
+      resolveSsrMenuVisibilityDefault(menus, roles => roles.includes('member')),
+      [menus[0], menus[2]],
+    );
+    assert.deepEqual(
+      resolveSsrMenuVisibilityDefault(menus, () => false),
+      [menus[0]],
+    );
+  });
+
+  it('retains only groups that contain a visible descendant', () => {
+    const groups = [
+      { name: 'root', title: 'Root' },
+      { name: 'nested', title: 'Nested', group: 'root' },
+      { name: 'empty', title: 'Empty' },
+    ];
+    const menus = [{ name: 'test:visible', group: 'nested' }] as any;
+    assert.deepEqual(resolveVisibleSsrMenuGroups(menus, groups), [groups[0], groups[1]]);
+  });
+
+  it('projects only public menu and group fields', () => {
+    const menus = [
+      {
+        name: 'test:private',
+        title: 'Private',
+        roles: ['member'],
+        policyRevision: 'private',
+        associationState: 'private',
+      },
+    ] as any;
+    const groups = [{ name: 'root', title: 'Root', catalogState: 'private' }] as any;
+    const result = {
+      menus: projectPublicSsrMenus(menus),
+      groups: projectPublicSsrMenuGroups(groups),
+    };
+    assert.deepEqual(result.menus, [{ name: 'test:private', title: 'Private' }]);
+    assert.deepEqual(result.groups, [{ name: 'root', title: 'Root' }]);
+    const serialized = JSON.stringify(result);
+    for (const forbidden of ['roles', 'policyRevision', 'associationState', 'catalogState']) {
+      assert.equal(serialized.includes(forbidden), false, forbidden);
+    }
+  });
+});

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-cabloy",
-  "version": "5.1.47",
+  "version": "5.1.48",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",
@@ -9,7 +9,7 @@
   "dependencies": {
     "vona-module-a-cabloy": "workspace:^",
     "vona-module-a-markdown": "^5.0.3",
-    "vona-module-a-rbac": "^5.0.1",
+    "vona-module-a-rbac": "^5.0.2",
     "vona-module-a-socket": "workspace:^",
     "vona-module-a-ssr": "workspace:^",
     "vona-module-a-ssrhmr": "workspace:^"

package/vona/src/suite-vendor/a-vona/modules/a-openapiutils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-openapiutils",
-  "version": "5.1.21",
+  "version": "5.1.22",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-openapiutils/src/lib/const/index.ts

@@ -1,2 +1,3 @@
 export * from './database.ts';
 export * from './decorator.ts';
+export * from './site.ts';

package/vona/src/suite-vendor/a-vona/modules/a-openapiutils/src/lib/const/site.ts

@@ -0,0 +1 @@
+export const roleSiteIdAll = '*';

package/vona/src/suite-vendor/a-vona/modules/a-permission/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-permission",
-  "version": "5.1.17",
+  "version": "5.1.18",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-user/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-user",
-  "version": "5.1.23",
+  "version": "5.1.24",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-user/src/types/role.ts

@@ -15,6 +15,7 @@ export interface IRole {
   title: string;
   titleLocales?: LocalizedTextMap;
   siteIds: string[];
+  builtin?: boolean;
 }
 
 export interface IRoleAdapter {