cabloy 5.1.153 → 5.1.154

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

@@ -1,24 +1,29 @@
 import type { LocalizedTextMap } from 'vona-module-a-user';
 
+import { roleSiteIdAll } from 'vona-module-a-openapiutils';
+
 export interface IRoleConfig {
   title: string;
   titleLocales?: LocalizedTextMap;
   siteIds: string[];
+  builtin: boolean;
 }
 
 export const builtinRoles: Record<string, IRoleConfig> = {
   registeredUser: {
     title: 'Registered User',
+    builtin: true,
     titleLocales: {
       'zh-cn': '注册用户',
     },
-    siteIds: ['web'],
+    siteIds: [roleSiteIdAll],
   },
   systemAdmin: {
     title: 'System Administrator',
+    builtin: true,
     titleLocales: {
       'zh-cn': '系统管理员',
     },
-    siteIds: ['web', 'admin'],
+    siteIds: [roleSiteIdAll],
   },
 };

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

@@ -23,4 +23,7 @@ export class EntityRole extends EntityBase implements IRole {
 
   @Api.field(v.array(z.string()))
   siteIds: string[];
+
+  @Api.field(v.default(false))
+  builtin: boolean;
 }

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

@@ -0,0 +1,11 @@
+declare module 'vona' {
+  export interface VonaConfigEnv {
+    HOME_USER_PASSWORD_DEFAULT_ADMIN: string | undefined;
+    HOME_USER_DISABLE_BOOTSTRAP_SYSTEM_ADMIN: string | undefined;
+    HOME_USER_DISABLE_USER_ADMIN: string | undefined;
+    HOME_USER_BUILTIN_ROLE_REGISTERED_USER_SITE_IDS: string | undefined;
+    HOME_USER_BUILTIN_ROLE_SYSTEM_ADMIN_SITE_IDS: string | undefined;
+  }
+}
+
+export {};

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

@@ -1,4 +1,5 @@
 export * from './auth.ts';
+export * from './env.ts';
 export * from './jwt.ts';
 export * from './passport.ts';
 export * from './role.ts';

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

@@ -0,0 +1,65 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { config } from '../src/config/config.ts';
+import { builtinRoles } from '../src/config/roles.ts';
+
+function createConfig(env: Record<string, string | undefined>) {
+  return config({ meta: { env } } as never);
+}
+
+describe('config.test.ts', () => {
+  it('uses environment overrides and defaults without mutating static role definitions', () => {
+    const configured = createConfig({
+      HOME_USER_PASSWORD_DEFAULT_ADMIN: 'strong-admin-password',
+      HOME_USER_DISABLE_BOOTSTRAP_SYSTEM_ADMIN: 'true',
+      HOME_USER_DISABLE_USER_ADMIN: 'true',
+      HOME_USER_BUILTIN_ROLE_REGISTERED_USER_SITE_IDS: 'web',
+      HOME_USER_BUILTIN_ROLE_SYSTEM_ADMIN_SITE_IDS: 'web,admin',
+    });
+    assert.equal(configured.passwordDefault.admin, 'strong-admin-password');
+    assert.equal(configured.disableBootstrapSystemAdmin, true);
+    assert.equal(configured.disableUserAdmin, true);
+    assert.deepEqual(configured.builtinRoles.registeredUser.siteIds, ['web']);
+    assert.deepEqual(configured.builtinRoles.systemAdmin.siteIds, ['web', 'admin']);
+    assert.deepEqual(builtinRoles.registeredUser.siteIds, ['*']);
+    assert.deepEqual(builtinRoles.systemAdmin.siteIds, ['*']);
+
+    const defaults = createConfig({
+      HOME_USER_PASSWORD_DEFAULT_ADMIN: '',
+      HOME_USER_DISABLE_BOOTSTRAP_SYSTEM_ADMIN: 'false',
+      HOME_USER_DISABLE_USER_ADMIN: 'invalid',
+    });
+    assert.equal(defaults.passwordDefault.admin, '123456');
+    assert.equal(defaults.disableBootstrapSystemAdmin, false);
+    assert.equal(defaults.disableUserAdmin, false);
+    assert.deepEqual(defaults.builtinRoles.registeredUser.siteIds, ['*']);
+    assert.deepEqual(defaults.builtinRoles.systemAdmin.siteIds, ['*']);
+  });
+
+  it('parses comma-delimited role site IDs and falls back for blank values', () => {
+    const configured = createConfig({
+      HOME_USER_BUILTIN_ROLE_REGISTERED_USER_SITE_IDS: ' web, admin, , store ',
+      HOME_USER_BUILTIN_ROLE_SYSTEM_ADMIN_SITE_IDS: ' , ',
+    });
+    assert.deepEqual(configured.builtinRoles.registeredUser.siteIds, ['web', 'admin', 'store']);
+    assert.deepEqual(configured.builtinRoles.systemAdmin.siteIds, ['*']);
+  });
+
+  it('rejects non-exclusive wildcard role site IDs', () => {
+    assert.throws(
+      () =>
+        createConfig({
+          HOME_USER_BUILTIN_ROLE_REGISTERED_USER_SITE_IDS: '*,web',
+        }),
+      /HOME_USER_BUILTIN_ROLE_REGISTERED_USER_SITE_IDS/,
+    );
+    assert.throws(
+      () =>
+        createConfig({
+          HOME_USER_BUILTIN_ROLE_SYSTEM_ADMIN_SITE_IDS: 'web,*',
+        }),
+      /HOME_USER_BUILTIN_ROLE_SYSTEM_ADMIN_SITE_IDS/,
+    );
+  });
+});

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

@@ -9,13 +9,17 @@ describe('role.test.ts', () => {
       const roleRegisteredUser = await scope.model.role.getByName('registeredUser');
       assert.equal(roleRegisteredUser?.title, 'Registered User');
       assert.deepEqual(roleRegisteredUser?.titleLocales, { 'zh-cn': '注册用户' });
-      assert.ok(roleRegisteredUser?.siteIds.includes('web'));
+      assert.deepEqual(
+        roleRegisteredUser?.siteIds,
+        scope.config.builtinRoles.registeredUser.siteIds,
+      );
+      assert.equal(roleRegisteredUser?.builtin, true);
 
       const roleSystemAdmin = await scope.model.role.getByName('systemAdmin');
       assert.equal(roleSystemAdmin?.title, 'System Administrator');
       assert.deepEqual(roleSystemAdmin?.titleLocales, { 'zh-cn': '系统管理员' });
-      assert.ok(roleSystemAdmin?.siteIds.includes('web'));
-      assert.ok(roleSystemAdmin?.siteIds.includes('admin'));
+      assert.deepEqual(roleSystemAdmin?.siteIds, scope.config.builtinRoles.systemAdmin.siteIds);
+      assert.equal(roleSystemAdmin?.builtin, true);
 
       await app.bean.passport.signinMock();
       const passport = await app.bean.executor.performAction('get', '/home/user/passport/current');
@@ -24,13 +28,17 @@ describe('role.test.ts', () => {
       );
       assert.equal(passportRegisteredUser?.title, 'Registered User');
       assert.deepEqual(passportRegisteredUser?.titleLocales, { 'zh-cn': '注册用户' });
-      assert.ok(passportRegisteredUser?.siteIds.includes('web'));
+      assert.deepEqual(
+        passportRegisteredUser?.siteIds,
+        scope.config.builtinRoles.registeredUser.siteIds,
+      );
+      assert.equal(passportRegisteredUser?.builtin, true);
 
       const passportSystemAdmin = passport.roles.find((role: any) => role.name === 'systemAdmin');
       assert.equal(passportSystemAdmin?.title, 'System Administrator');
       assert.deepEqual(passportSystemAdmin?.titleLocales, { 'zh-cn': '系统管理员' });
-      assert.ok(passportSystemAdmin?.siteIds.includes('web'));
-      assert.ok(passportSystemAdmin?.siteIds.includes('admin'));
+      assert.deepEqual(passportSystemAdmin?.siteIds, scope.config.builtinRoles.systemAdmin.siteIds);
+      assert.equal(passportSystemAdmin?.builtin, true);
     });
   });
 });

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-ssr",
-  "version": "5.1.30",
+  "version": "5.1.31",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

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

@@ -162,6 +162,7 @@ declare module 'vona' {
 }
 /** service: end */
 /** event: begin */
+export * from '../bean/event.resolveMenuVisibility.ts';
 export * from '../bean/event.retrieveMenus.ts';
 export * from '../bean/event.retrieveMenusSite.ts';
 
@@ -172,6 +173,16 @@ declare module 'vona' {
 }
 declare module 'vona-module-a-ssr' {
 
+        export interface EventResolveMenuVisibility {
+          /** @internal */
+          get scope(): ScopeModuleASsr;
+        }
+
+          export interface EventResolveMenuVisibility {
+            get $beanFullName(): 'a-ssr.event.resolveMenuVisibility';
+            get $onionName(): 'a-ssr:resolveMenuVisibility';
+          }
+
         export interface EventRetrieveMenus {
           /** @internal */
           get scope(): ScopeModuleASsr;
@@ -194,20 +205,24 @@ declare module 'vona-module-a-ssr' {
 }
 /** event: end */
 /** event: begin */
+import type { EventResolveMenuVisibility } from '../bean/event.resolveMenuVisibility.ts';
 import type { EventRetrieveMenus } from '../bean/event.retrieveMenus.ts';
 import type { EventRetrieveMenusSite } from '../bean/event.retrieveMenusSite.ts';
 export interface IModuleEvent {
-  'retrieveMenus': EventRetrieveMenus;
+  'resolveMenuVisibility': EventResolveMenuVisibility;
+'retrieveMenus': EventRetrieveMenus;
 'retrieveMenusSite': EventRetrieveMenusSite;
 }
 /** event: end */
 /** event: begin */
+import type { TypeEventResolveMenuVisibilityData, TypeEventResolveMenuVisibilityResult } from '../bean/event.resolveMenuVisibility.ts';
 import type { TypeEventRetrieveMenusData, TypeEventRetrieveMenusResult } from '../bean/event.retrieveMenus.ts';
 import type { TypeEventRetrieveMenusSiteData, TypeEventRetrieveMenusSiteResult } from '../bean/event.retrieveMenusSite.ts';
 import type { EventOn } from 'vona-module-a-event';
 declare module 'vona-module-a-event' {
   export interface IEventRecord {
-    'a-ssr:retrieveMenus': EventOn<TypeEventRetrieveMenusData, TypeEventRetrieveMenusResult>;
+    'a-ssr:resolveMenuVisibility': EventOn<TypeEventResolveMenuVisibilityData, TypeEventResolveMenuVisibilityResult>;
+'a-ssr:retrieveMenus': EventOn<TypeEventRetrieveMenusData, TypeEventRetrieveMenusResult>;
 'a-ssr:retrieveMenusSite': EventOn<TypeEventRetrieveMenusSiteData, TypeEventRetrieveMenusSiteResult>;
   }
 }

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/src/bean/event.resolveMenuVisibility.ts

@@ -0,0 +1,19 @@
+import type { TableIdentity } from 'table-identity';
+
+import { BeanEventBase, Event } from 'vona-module-a-event';
+
+import type { ISsrMenuItemPrepared } from '../types/ssrMenu.ts';
+
+export interface TypeEventResolveMenuVisibilityData {
+  ssrSiteName: string;
+  menus: ISsrMenuItemPrepared[];
+  currentRoleIds: TableIdentity[];
+}
+
+export type TypeEventResolveMenuVisibilityResult = ISsrMenuItemPrepared[];
+
+@Event()
+export class EventResolveMenuVisibility extends BeanEventBase<
+  TypeEventResolveMenuVisibilityData,
+  TypeEventResolveMenuVisibilityResult
+> {}

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,