create-lumal-admin 0.0.4-beta → 0.0.6-beta

package/templates/features/system/src/modules/system/user/routes.ts

@@ -0,0 +1,27 @@
+import type { AppModule } from '../../../app/module';
+
+export const menus: AppModule['menus'] = [
+  {
+    path: '/system/users',
+    name: 'SystemUsers',
+    component: 'system/users',
+    meta: { title: '用户管理', icon: 'lumal:user', authority: ['system:user:list'], keepAlive: true, order: 1 },
+  },
+];
+export const views: AppModule['views'] = { 'system/users': () => import('./UserView.vue') };
+// 只声明真实存在的操作，不根据菜单前缀生成伪权限。
+export const permissions: AppModule['permissions'] = [
+  {
+    id: 'system-user',
+    label: '用户管理',
+    children: [
+      { id: 'system:user:list', label: '查询用户', permission: 'system:user:list' },
+      { id: 'system:user:create', label: '新增用户', permission: 'system:user:create' },
+      { id: 'system:user:update', label: '修改用户', permission: 'system:user:update' },
+      { id: 'system:user:delete', label: '删除用户', permission: 'system:user:delete' },
+      { id: 'system:user:status', label: '启用与停用', permission: 'system:user:status' },
+      { id: 'system:user:assign-roles', label: '分配角色', permission: 'system:user:assign-roles' },
+      { id: 'system:user:reset-password', label: '重置密码', permission: 'system:user:reset-password' },
+    ],
+  },
+];

package/templates/features/system/src/modules/system/user/types.ts

@@ -0,0 +1,28 @@
+import type { Query, Status } from '../../../shared/api';
+
+export interface User {
+  id: string;
+  username: string;
+  nickname: string;
+  organizationId: string;
+  roles: string[];
+  phone: string;
+  status: Status;
+  createdAt: string;
+}
+export interface UserInput {
+  username: string;
+  nickname: string;
+  organizationId: string;
+  roles: string[];
+  phone: string;
+  status: Status;
+}
+export interface UserQuery extends Query {
+  organizationId?: string;
+  roles?: string;
+}
+export interface UserBatchResult {
+  items: User[];
+  updated: number;
+}

package/templates/features/system/tests/system.test.ts.template

@@ -0,0 +1,266 @@
+import type { BusinessTransport, DataRow, ListInput, PageResult } from '../src/app/services/contracts';
+import type { LocalDatabase } from '../src/app/services/local-contracts';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { permissionCodes, viewComponents } from '../src/app/router/views';
+import { buildStoredMenus } from '../src/app/stored-menus';
+import { createConfigService } from '../src/modules/system/config/api';
+import { createDictionaryService } from '../src/modules/system/dictionary/api';
+import { createLocalHandler } from '../src/modules/system/local';
+import { createMenuService } from '../src/modules/system/menu/api';
+import { createOrganizationService } from '../src/modules/system/organization/api';
+import { createRoleService } from '../src/modules/system/role/api';
+import { parsePermissionTree } from '../src/modules/system/role/permission-tree';
+import { createUserService, userInput } from '../src/modules/system/user/api';
+
+let transport: BusinessTransport & { list: (resource: string, input: ListInput) => Promise<PageResult> };
+let allowed = new Set<string>();
+let records: Map<string, DataRow[]>;
+beforeEach(() => {
+  records = new Map([
+    [
+      'users',
+      [
+        {
+          id: 'admin',
+          username: 'admin',
+          nickname: '管理员',
+          organizationId: 'root',
+          roles: ['admin'],
+          status: 'enabled',
+          password: 'lumal123',
+        },
+      ],
+    ],
+    [
+      'roles',
+      [{ id: 'admin', code: 'admin', name: '管理员', builtIn: true, status: 'enabled', permissions: permissionCodes }],
+    ],
+  ]);
+  allowed = new Set(permissionCodes);
+  const db: LocalDatabase = {
+    read: <T extends DataRow>(key: string, fallback?: () => T[]): T[] =>
+      structuredClone(records.get(key) ?? fallback?.() ?? []) as T[],
+    write: (key, rows) => {
+      records.set(key, structuredClone(rows));
+    },
+  };
+  const handler = createLocalHandler({
+    db,
+    user: () => ({ id: 'admin', username: 'admin', name: '管理员' }),
+    assertPermission: (code) => {
+      if (!allowed.has(code)) throw new Error(`无操作权限：${code}`);
+    },
+  });
+  const request: BusinessTransport['request'] = async <T>(
+    method: Parameters<BusinessTransport['request']>[0],
+    path: string,
+    input = {},
+  ) => (await handler.request(method, path, input)) as T;
+  transport = {
+    request,
+    list: (resource, input) =>
+      request('GET', `/system/${resource}`, {
+        query: { page: input.page, pageSize: input.pageSize, ...input.query } as Record<string, string | number>,
+      }),
+  };
+});
+const newUser = (username = 'new-user') =>
+  userInput({ username, nickname: '新增用户', organizationId: 'root', roles: ['admin'], status: 'enabled' });
+
+describe('用户业务约束', () => {
+  it('独立 CRUD、机构筛选、角色与状态筛选', async () => {
+    const users = createUserService(transport);
+    const row = await users.create(newUser());
+    expect(row).not.toHaveProperty('password');
+    await users.update(row.id, { ...newUser(), nickname: '已修改' });
+    expect(
+      (
+        await users.list({
+          page: 1,
+          pageSize: 10,
+          query: { organizationId: 'root', roles: 'admin', status: 'enabled' },
+        })
+      ).items,
+    ).toHaveLength(2);
+    await users.setStatus(row.id, 'disabled');
+    expect((await users.list({ page: 1, pageSize: 10, query: { status: 'disabled' } })).items[0]?.nickname).toBe(
+      '已修改',
+    );
+    await users.remove(row.id);
+    expect((await users.list({ page: 1, pageSize: 10, query: { keyword: 'new-user' } })).total).toBe(0);
+  });
+  it('批量先校验再写入，管理员与关联保护', async () => {
+    const users = createUserService(transport);
+    const row = await users.create(newUser());
+    await expect(users.batchStatus([row.id, 'admin'], 'disabled')).rejects.toThrow('内置管理员');
+    expect(records.get('users')?.find((item) => item.id === row.id)?.status).toBe('enabled');
+    await expect(users.remove('admin')).rejects.toThrow('内置管理员');
+    await expect(users.assignRoles('admin', [])).rejects.toThrow();
+    await expect(users.create({ ...newUser('missing-org'), organizationId: 'missing' })).rejects.toThrow('机构');
+    const result = await users.resetPassword(row.id);
+    expect(result.temporaryPassword.length).toBeGreaterThanOrEqual(8);
+    expect(records.get('users')?.find((item) => item.id === row.id)?.password).toBe(result.temporaryPassword);
+  });
+  it('资料更新不能绕过专用状态和角色权限', async () => {
+    const users = createUserService(transport);
+    const row = await users.create(newUser());
+    allowed.delete('system:user:status');
+    await expect(users.update(row.id, { ...newUser(), status: 'disabled' })).rejects.toThrow('无操作权限');
+    allowed.delete('system:user:create');
+    await expect(users.create(newUser('blocked'))).rejects.toThrow('无操作权限');
+  });
+});
+describe('角色资料与授权是两个独立业务流程', () => {
+  it('非叶访问权限独立回显，并拒绝循环、重复和异常权限树', () => {
+    const tree = parsePermissionTree([
+      {
+        id: 'page',
+        label: '用户',
+        permission: 'system:user:list',
+        children: [{ id: 'create', label: '新增', permission: 'system:user:create' }],
+      },
+    ]);
+    expect(tree[0]?.permission).toBeUndefined();
+    expect(tree[0]?.children?.map((node) => node.permission)).toEqual(['system:user:list', 'system:user:create']);
+    expect(() =>
+      parsePermissionTree([
+        { id: 'same', label: '1' },
+        { id: 'same', label: '2' },
+      ]),
+    ).toThrow('重复');
+    expect(() => parsePermissionTree([{ id: 'bad', label: '1', children: {} }])).toThrow('数组');
+    const cycle = { id: 'cycle', label: '循环', children: [] as unknown[] };
+    cycle.children.push(cycle);
+    expect(() => parsePermissionTree([cycle])).toThrow('循环');
+  });
+  it('真实权限树、授权回显、未知授权拒绝、引用和内置保护', async () => {
+    const roles = createRoleService(transport);
+    const role = await roles.create({ code: 'reader', name: '只读角色', description: '', status: 'enabled' });
+    expect((await roles.tree()).length).toBeGreaterThan(0);
+    expect(await roles.authorize('reader', ['system:user:list'])).toEqual(['system:user:list']);
+    expect(await roles.permissions('reader')).toEqual(['system:user:list']);
+    await expect(roles.authorize('reader', ['not-registered'])).rejects.toThrow('未注册');
+    await expect(roles.authorize('admin', [])).rejects.toThrow('内置管理员');
+    await expect(roles.remove('admin')).rejects.toThrow('内置');
+    const user = await createUserService(transport).create({ ...newUser(), roles: ['reader'] });
+    await expect(roles.remove(role.id)).rejects.toThrow('引用');
+    await createUserService(transport).remove(user.id);
+    await roles.remove(role.id);
+  });
+  it('资料已写入而授权失败时不会回滚或声称原子更新', async () => {
+    const roles = createRoleService(transport);
+    const role = await roles.create({ code: 'reader', name: '只读角色', description: '', status: 'enabled' });
+    await roles.update(role.id, { ...role, name: '已保存资料' });
+    allowed.delete('system:role:authorize');
+    await expect(roles.authorize(role.code, ['system:user:list'])).rejects.toThrow('无操作权限');
+    expect((await roles.list({ page: 1, pageSize: 10, query: { keyword: 'reader' } })).items[0]?.name).toBe(
+      '已保存资料',
+    );
+    allowed.add('system:role:authorize');
+    expect(await roles.authorize(role.code, ['system:user:list'])).toEqual(['system:user:list']);
+    await expect(
+      transport.request('PUT', `/system/roles/${role.id}`, { body: { ...role, permissions: [] } }),
+    ).rejects.toThrow('分别保存');
+  });
+});
+describe('菜单、机构、字典和配置', () => {
+  it('目录、菜单、按钮树，路径、白名单、循环与层级约束', async () => {
+    const api = createMenuService(transport);
+    const directory = await api.create({
+      parentId: '',
+      type: 'directory',
+      path: '/custom',
+      name: 'Custom',
+      title: '扩展目录',
+      component: '',
+      icon: '',
+      permissions: [],
+      order: 0,
+      hidden: false,
+      externalLink: '',
+    });
+    const page = await api.create({
+      ...directory,
+      parentId: directory.id,
+      type: 'menu',
+      path: '/custom/page',
+      name: 'CustomPage',
+      title: '扩展页',
+      component: 'system/users',
+    });
+    await api.create({
+      ...page,
+      parentId: page.id,
+      type: 'button',
+      path: '',
+      name: '',
+      title: '操作',
+      component: '',
+      permissions: ['system:user:create'],
+    });
+    expect((await api.list())[0]?.children?.[0]?.children?.[0]?.type).toBe('button');
+    await expect(api.update(directory.id, { ...directory, parentId: page.id })).rejects.toThrow('循环');
+    await expect(api.create({ ...page, component: 'constructor', name: 'Bad', path: '/custom/bad' })).rejects.toThrow(
+      '白名单',
+    );
+    await expect(api.create({ ...page, name: 'BadPath', path: '/other' })).rejects.toThrow('父级');
+    const nav = buildStoredMenus(records.get('menus')!, viewComponents);
+    expect(nav[0]?.children).toHaveLength(1);
+    expect(nav[0]?.children?.[0]?.children).toEqual([]);
+    await expect(api.remove(directory.id)).rejects.toThrow('子节点');
+  });
+  it('机构新增、更新、循环和关联用户删除保护', async () => {
+    const api = createOrganizationService(transport);
+    const org = await api.create({
+      name: '研发部',
+      code: 'dev',
+      parentId: 'root',
+      leader: '',
+      phone: '',
+      email: '',
+      order: 1,
+      status: 'enabled',
+    });
+    await api.update(org.id, { ...org, name: '研发中心' });
+    const root = (await api.list())[0]!;
+    await expect(api.update('root', { ...root, parentId: org.id })).rejects.toThrow('循环');
+    const users = createUserService(transport);
+    const user = await users.create({ ...newUser(), organizationId: org.id });
+    await expect(api.remove(org.id)).rejects.toThrow('关联用户');
+    expect((await users.list({ page: 1, pageSize: 10, query: { organizationId: 'root' } })).items).toHaveLength(2);
+    await users.remove(user.id);
+    await api.remove(org.id);
+  });
+  it('字典关联、值唯一、级联删除及缓存失效', async () => {
+    const invalidate = vi.fn();
+    const api = createDictionaryService(transport, invalidate);
+    const type = await api.createType({ code: 'approval', name: '审批', description: '', status: 'enabled' });
+    const input = {
+      typeCode: 'approval',
+      label: '通过',
+      value: 'approved',
+      order: 1,
+      color: '#15803d',
+      status: 'enabled' as const,
+    };
+    const item = await api.createItem(input);
+    await api.updateItem(item.id, { ...input, label: '已通过' });
+    expect((await api.items('approval'))[0]?.label).toBe('已通过');
+    expect(await api.items('other')).toEqual([]);
+    await expect(api.createItem(input)).rejects.toThrow('重复');
+    await api.removeType(type.id);
+    expect(await api.items('approval')).toEqual([]);
+    expect(invalidate).toHaveBeenCalledTimes(4);
+  });
+  it('配置验证、独立保存与权限拒绝', async () => {
+    const api = createConfigService(transport);
+    const initial = await api.get();
+    expect((await api.save({ ...initial, appName: '测试应用' })).appName).toBe('测试应用');
+    await expect(api.save({ ...initial, colorPrimary: 'javascript:bad' })).rejects.toThrow('无效');
+    expect((await api.get()).appName).toBe('测试应用');
+    await api.restore();
+    expect((await api.get()).appName).toBe(initial.appName);
+    allowed.delete('system:config:update');
+    await expect(api.save(initial)).rejects.toThrow('无操作权限');
+  });
+});

package/templates/modes/http/src/app/services/data-source.ts

@@ -0,0 +1,124 @@
+import type { ApplicationService, ServiceContext } from './contracts';
+import { createRequestClient, RequestError } from '@lumal/core/request';
+import { object } from '../menu-policy';
+import { createHttpAdapter } from './http-adapter';
+
+export const demoAccount: { username: string; password: string } | null = null;
+
+export function createHttpBackend(
+  context: ServiceContext,
+  baseURL: string,
+  adapterName = 'standard',
+): ApplicationService {
+  const adapter = createHttpAdapter(adapterName);
+  function exposeHttpMessage({ error }: { error: unknown }): void {
+    if (error instanceof RequestError) {
+      const message = adapter.errorMessage(error.data);
+      if (message) error.message = message; // 保留 status/kind/data，仅适配后端明确定义的错误文案。
+    }
+  }
+  const publicRequest = createRequestClient({
+    baseURL,
+    onResponseError: exposeHttpMessage,
+    onRequest() {
+      if (!baseURL.trim()) throw new Error('未配置 VITE_API_BASE_URL，请先接入真实后端');
+    },
+    onResponse: <T>({ data, init }: { data: unknown; init: RequestInit }) => {
+      init.signal?.throwIfAborted();
+      return adapter.parseResponse(data) as T;
+    },
+  });
+  const request = createRequestClient({
+    baseURL,
+    onResponseError: exposeHttpMessage,
+    duplicateSubmit: true,
+    getToken: () => context.getSession()?.accessToken,
+    onRequest({ init }) {
+      if (!baseURL.trim()) throw new Error('未配置 VITE_API_BASE_URL，请先接入真实后端');
+      init.signal = init.signal ? AbortSignal.any([init.signal, context.getSignal()]) : context.getSignal();
+      const token = context.getSession()?.accessToken;
+      if (!token || new Headers(init.headers).get('Authorization') !== `Bearer ${token}`)
+        throw new RequestError('会话已切换', { kind: 'cancelled' });
+    },
+    onResponse: <T>({ data, init }: { data: unknown; init: RequestInit }) => {
+      init.signal?.throwIfAborted();
+      return adapter.parseResponse(data) as T;
+    },
+    authRefresh: {
+      async refresh({ init }) {
+        const refreshToken = context.getSession()?.refreshToken;
+        if (!refreshToken) throw new Error('缺少刷新凭据');
+        const result = await publicRequest.post('/auth/refresh', {
+          body: { refreshToken },
+          signal: init.signal ?? undefined,
+        });
+        init.signal?.throwIfAborted();
+        if (context.getSession()?.refreshToken !== refreshToken) throw new DOMException('会话已切换', 'AbortError');
+        context.setSession(adapter.parseSession(result));
+      },
+    },
+    onSessionExpired: context.expire,
+  });
+  return {
+    request: (method, path, input = {}) =>
+      request.request(path, {
+        method,
+        ...input,
+        // 业务端点仅接受 JSON 对象；在请求边界校验，不能直接透传任意 object。
+        body: input.body === undefined ? undefined : object(input.body),
+      }),
+    login: async (input, signal) =>
+      adapter.parseSession(await publicRequest.post('/auth/login', { body: { ...input }, signal })),
+    getUser: async (signal) => adapter.parseUser(await request.get('/session/me', { signal })),
+    getAccess: async (signal) => adapter.parseAccess(await request.get('/session/access', { signal })),
+    getMenus: async (signal) => adapter.parseMenus(await request.get(adapter.menusPath, { signal })),
+    logout: async (accessToken) => {
+      await publicRequest.post('/auth/logout', { headers: { Authorization: `Bearer ${accessToken}` } });
+    },
+    clearCache() {
+      publicRequest.clearCache();
+      request.clearCache();
+    },
+    async list(resource, input) {
+      const result = await request.get(`/system/${resource}`, {
+        query: { page: input.page, pageSize: input.pageSize, ...input.query } as Record<string, string | number>,
+      });
+      // Mock 的树形 / 字典接口不分页，显式在应用 adapter 边界转换。
+      if (adapterName === 'lumal-mock' && Array.isArray(result)) {
+        const flatten = (rows: Record<string, unknown>[]): Record<string, unknown>[] =>
+          rows.flatMap((row) => [
+            { ...row, children: undefined },
+            ...(Array.isArray(row.children) ? flatten(row.children) : []),
+          ]);
+        const items = flatten(result);
+        const keyword = String(input.query.keyword ?? '').trim();
+        const filtered = items.filter(
+          (row) => !keyword || Object.values(row).some((value) => String(value).includes(keyword)),
+        );
+        return {
+          items: filtered.slice((input.page - 1) * input.pageSize, input.page * input.pageSize),
+          total: filtered.length,
+        };
+      }
+      return adapter.parsePage(result);
+    },
+    async save(resource, model, id) {
+      if (resource === 'roles' && Object.hasOwn(model, 'permissions'))
+        throw new Error('角色资料与授权必须分别调用，请使用角色授权服务');
+      return id
+        ? await request.put(`/system/${resource}/${encodeURIComponent(id)}`, { body: model })
+        : await request.post(`/system/${resource}`, { body: model });
+    },
+    remove: async (resource, id) => {
+      await request.delete(`/system/${resource}/${encodeURIComponent(id)}`);
+    },
+  };
+}
+
+export function createBackend(context: ServiceContext): ApplicationService {
+  return createHttpBackend(
+    context,
+    import.meta.env.VITE_API_BASE_URL ?? '',
+    import.meta.env.VITE_API_ADAPTER || 'standard',
+  );
+}

package/templates/modes/http/src/app/services/http-adapter.ts

@@ -0,0 +1,128 @@
+import type { AuthSessionData } from '@lumal/core/auth';
+import type { LumalMenuRecord } from '@lumal/core/router';
+import type { AccessSnapshot, CurrentUser, PageResult } from './contracts';
+import { parseAuthSession } from '@lumal/core/auth';
+import { createStandardResponseParser, parsePageResult } from '@lumal/core/request';
+import { object, resolveView, safeExternalUrl, stringArray, validateMenus } from '../menu-policy';
+import { localMenus, viewComponents } from '../router/views';
+
+export interface HttpAdapter {
+  parseResponse: (data: unknown) => unknown;
+  parseSession: (data: unknown) => AuthSessionData;
+  parseUser: (data: unknown) => CurrentUser;
+  parseAccess: (data: unknown) => AccessSnapshot;
+  parseMenus: (data: unknown) => LumalMenuRecord[];
+  parsePage: (data: unknown) => PageResult;
+  errorMessage: (data: unknown) => string | undefined;
+  menusPath: string;
+}
+function errorMessage(value: unknown, key = 'message'): string | undefined {
+  if (!value || typeof value !== 'object' || !Object.hasOwn(value, key)) return;
+  const message = (value as Record<string, unknown>)[key];
+  return typeof message === 'string' && message.trim() ? message.trim().slice(0, 500) : undefined;
+}
+function parseUser(value: unknown): CurrentUser {
+  const raw = object(value);
+  if (!['id', 'name', 'username'].every((key) => typeof raw[key] === 'string' && raw[key]))
+    throw new Error('当前用户缺少 id/name/username');
+  return { id: String(raw.id), name: String(raw.name), username: String(raw.username) };
+}
+function parseAccess(value: unknown): AccessSnapshot {
+  const raw = object(value);
+  return { roles: stringArray(raw.roles), permissions: stringArray(raw.permissions) };
+}
+const parseMenus = (value: unknown) => validateMenus(value, viewComponents);
+function flatten(menus: LumalMenuRecord[]): LumalMenuRecord[] {
+  return menus.flatMap((menu) => [menu, ...flatten(menu.children ?? [])]);
+}
+
+export function createHttpAdapter(name = 'standard'): HttpAdapter {
+  const standard: HttpAdapter = {
+    parseResponse: (value) => value,
+    parseSession: parseAuthSession,
+    parseUser,
+    parseAccess,
+    parseMenus,
+    parsePage: (value) => (Array.isArray(value) ? { items: value, total: value.length } : parsePageResult(value)),
+    errorMessage,
+    menusPath: '/menus',
+  };
+  if (name === 'standard') return standard;
+  if (name !== 'lumal-mock') throw new Error(`未知 HTTP adapter：${name}`);
+  const unwrap = createStandardResponseParser({
+    fieldNames: { code: 'statusCode', data: 'result', message: 'resultMsg' },
+    successCodes: ['0000'],
+    sessionExpiredCodes: ['AUTH_EXPIRED'],
+  });
+  const aliases: Record<string, string> = {
+    'system/user': 'system/users',
+    'system/role': 'system/roles',
+    'system/menu': 'system/menus',
+    'system/organization': 'system/organizations',
+    'system/dict': 'system/dictionaries/types',
+    'system/dict-item': 'system/dictionaries/items',
+  };
+  const supported = new Map(
+    flatten(localMenus)
+      .filter((menu) => menu.component)
+      .map((menu) => [menu.component!, menu]),
+  );
+  return {
+    ...standard,
+    parseResponse: (data) => unwrap({ data } as Parameters<typeof unwrap>[0]),
+    errorMessage: (value) => errorMessage(value, 'resultMsg'),
+    parseSession: (value) =>
+      parseAuthSession(value, {
+        fieldNames: { accessToken: 'access_token', refreshToken: 'refresh_token', expiresAt: 'expire_time' },
+      }),
+    parsePage: (value) =>
+      Array.isArray(value)
+        ? { items: value, total: value.length }
+        : parsePageResult(value, { fieldNames: { items: 'records', total: 'totalNum' } }),
+    menusPath: '/menu',
+    parseAccess(value) {
+      const access = parseAccess(value);
+      // Mock API 实际以 config:view 保护写接口，显式映射到应用的 update 权限。
+      return {
+        ...access,
+        permissions: access.permissions.includes('system:config:view')
+          ? [...new Set([...access.permissions, 'system:config:update'])]
+          : access.permissions,
+      };
+    },
+    parseMenus(value) {
+      const visit = (items: unknown): LumalMenuRecord[] => {
+        if (!Array.isArray(items)) throw new Error('Mock 菜单响应必须是数组');
+        return items.flatMap((item) => {
+          const raw = object(item);
+          const key = String(raw.viewPath ?? '');
+          if (['constructor', '__proto__', 'prototype'].includes(key)) throw new Error('菜单组件不在白名单中');
+          const component = Object.hasOwn(aliases, key) ? aliases[key]! : key;
+          const selected = supported.get(component);
+          const children = raw.nodes === undefined ? [] : visit(raw.nodes);
+          if (key && !selected && !children.length) return []; // 明确的 Mock adapter 只接入当前预设已生成的页面。
+          if (selected && !resolveView(viewComponents, component)) throw new Error('菜单组件不在白名单中');
+          if (!selected && !children.length) return [];
+          const sourceMeta = raw.meta === undefined ? {} : object(raw.meta);
+          return [
+            {
+              path: selected?.path ?? String(raw.routePath),
+              name: selected?.name ?? String(raw.routeName),
+              component: selected?.component,
+              meta: {
+                ...selected?.meta,
+                ...sourceMeta,
+                title: String(raw.menuName ?? selected?.meta?.title ?? ''),
+                authority: stringArray(raw.authCode ?? []),
+                order: Number(raw.sortNo ?? selected?.meta?.order ?? 0),
+                ...(raw.url ? { externalLink: safeExternalUrl(raw.url) } : {}),
+              },
+              children,
+            },
+          ];
+        });
+      };
+      return parseMenus(visit(value));
+    },
+  };
+}