@liujitcn/kratos-admin-core 0.0.1

package/dist/package/src/modules/index.ts

@@ -0,0 +1,233 @@
+import type { Component } from "vue";
+import type { RouteLocationNormalizedLoaded } from "vue-router";
+
+/**
+ * 管理端视图加载器。
+ */
+export type AdminViewLoader = () => Promise<{
+  default: Component;
+}>;
+
+/**
+ * 管理端视图模块表。
+ */
+export type AdminViewModules = Record<string, AdminViewLoader>;
+
+/** ADMIN_STATIC_VIEWS 管理端可替换静态页面的固定视图键。 */
+export const ADMIN_STATIC_VIEWS = {
+  LOGIN: "login/index",
+  FORBIDDEN: "error/403",
+  NOT_FOUND: "error/404",
+  SERVER_ERROR: "error/500",
+  PENDING: "error/pending"
+} as const;
+
+/** 管理端静态页面固定视图键。 */
+export type AdminStaticViewKey = (typeof ADMIN_STATIC_VIEWS)[keyof typeof ADMIN_STATIC_VIEWS];
+
+/** 管理端静态页面实现表。 */
+export type AdminStaticViewModules = Partial<Record<AdminStaticViewKey, AdminViewLoader>>;
+
+/**
+ * 管理端顶部工具。
+ */
+export interface AdminHeaderTool {
+  /** 工具唯一名称，同时作为渲染节点 ID。 */
+  name: string;
+  /** 工具对应的 Vue 组件。 */
+  component: Component;
+}
+
+/** 管理端用户菜单操作。 */
+export interface AdminUserMenuAction {
+  /** 操作唯一名称。 */
+  name: string;
+  /** 操作显示名称。 */
+  label: string;
+  /** 对应后端动态菜单名称，菜单不存在时不显示操作。 */
+  menuName: string;
+  /** 操作图标。 */
+  icon?: Component;
+}
+
+/** 管理端动态路由行为配置。 */
+export interface AdminRouteOptions {
+  /** 查询参数变化时是否复用同一个页签。 */
+  reuseTabAcrossQuery?: boolean;
+}
+
+/**
+ * 管理端模块定义。
+ */
+export interface AdminModule {
+  /** 模块名称。 */
+  name: string;
+  /** 模块提供的业务页面加载器，页面统一通过模块前缀解析。 */
+  views?: AdminViewModules;
+  /** 模块提供的静态页面实现，后注册模块可替换已有实现。 */
+  staticViews?: AdminStaticViewModules;
+  /** 模块提供的顶部工具。 */
+  headerTools?: AdminHeaderTool[];
+  /** 模块提供的用户菜单操作。 */
+  userMenuActions?: AdminUserMenuAction[];
+  /** 模块提供的动态路由行为配置，以后端菜单名称为键。 */
+  routeOptions?: Record<string, AdminRouteOptions>;
+  /** 模块提供的命名扩展，由扩展所属业务包定义具体类型。 */
+  extensions?: Record<string, unknown>;
+}
+
+const registeredModules = new Map<string, AdminModule>();
+
+/**
+ * 声明一个可被管理端宿主注册的模块。
+ */
+export function defineAdminModule(module: AdminModule): AdminModule {
+  return module;
+}
+
+/**
+ * 注册一个管理端模块，名称或模块级扩展点重复时抛出错误。
+ */
+export function registerAdminModule(module: AdminModule): void {
+  registerAdminModules([module]);
+}
+
+/**
+ * 批量注册管理端模块，全部通过唯一性校验后再写入注册表。
+ */
+export function registerAdminModules(modules: AdminModule[]): void {
+  const nextModules = [...registeredModules.values(), ...modules];
+  assertUniqueAdminModuleKeys(nextModules, "模块", module => [module.name]);
+  assertUniqueAdminModuleKeys(nextModules, "顶部工具", module => module.headerTools?.map(tool => tool.name) ?? []);
+  assertUniqueAdminModuleKeys(nextModules, "用户菜单", module => module.userMenuActions?.map(action => action.name) ?? []);
+  assertUniqueAdminModuleKeys(nextModules, "路由配置", module => Object.keys(module.routeOptions ?? {}));
+  modules.forEach(module => registeredModules.set(module.name, module));
+}
+
+/**
+ * 获取当前已注册的管理端模块。
+ */
+export function getRegisteredAdminModules(): AdminModule[] {
+  return [...registeredModules.values()];
+}
+
+/**
+ * 管理端视图注册表。
+ */
+export interface AdminViewRegistry {
+  /** 根据固定视图键或后端菜单组件路径查找页面加载器。 */
+  resolve(component?: string): AdminViewLoader | undefined;
+}
+
+/**
+ * 创建管理端视图注册表，业务页面按模块隔离，静态页面允许后注册模块替换。
+ */
+export function createAdminViewRegistry(modules: AdminModule[]): AdminViewRegistry {
+  const viewMap = new Map<string, AdminViewLoader>();
+
+  modules.forEach(module => {
+    Object.entries(module.views ?? {}).forEach(([path, loader]) => {
+      const normalizedPath = normalizeAdminViewPath(path);
+      if (!normalizedPath) return;
+      viewMap.set(`${module.name}/${normalizedPath}`, loader);
+    });
+    Object.entries(module.staticViews ?? {}).forEach(([path, loader]) => {
+      const normalizedPath = normalizeAdminViewPath(path);
+      if (!normalizedPath || !loader) return;
+      viewMap.set(normalizedPath, loader);
+    });
+  });
+
+  return {
+    resolve(component) {
+      const normalizedPath = normalizeAdminViewPath(component);
+      if (!normalizedPath || normalizedPath === "Layout") return undefined;
+
+      const candidates = [
+        normalizedPath,
+        `${normalizedPath}/index`,
+        normalizedPath.replace(/\/index$/, ""),
+        `${normalizedPath.replace(/\/index$/, "")}/index`
+      ];
+
+      return candidates.map(path => viewMap.get(path)).find(Boolean);
+    }
+  };
+}
+
+/**
+ * 根据当前已注册模块创建视图注册表。
+ */
+export function getAdminViewRegistry(): AdminViewRegistry {
+  return createAdminViewRegistry(getRegisteredAdminModules());
+}
+
+/**
+ * 获取当前已注册模块提供的顶部工具。
+ */
+export function getAdminHeaderTools(): AdminHeaderTool[] {
+  return getRegisteredAdminModules().flatMap(module => module.headerTools ?? []);
+}
+
+/**
+ * 获取当前已注册模块提供的用户菜单操作。
+ */
+export function getAdminUserMenuActions(): AdminUserMenuAction[] {
+  return getRegisteredAdminModules().flatMap(module => module.userMenuActions ?? []);
+}
+
+/**
+ * 获取指定动态路由的行为配置。
+ */
+export function getAdminRouteOptions(name?: string): AdminRouteOptions | undefined {
+  if (!name) return undefined;
+  return getRegisteredAdminModules().reduce<AdminRouteOptions | undefined>((options, module) => {
+    return module.routeOptions?.[name] ?? options;
+  }, undefined);
+}
+
+/** getAdminTabPath 根据路由扩展配置返回当前页签唯一标识。 */
+export function getAdminTabPath(route: Pick<RouteLocationNormalizedLoaded, "name" | "path" | "fullPath">): string {
+  const routeName = typeof route.name === "string" ? route.name : undefined;
+  return getAdminRouteOptions(routeName)?.reuseTabAcrossQuery ? route.path : route.fullPath;
+}
+
+/**
+ * 获取最后注册模块提供的指定命名扩展。
+ */
+export function getAdminModuleExtension<T>(name: string): T | undefined {
+  return getRegisteredAdminModules().reduce<T | undefined>((extension, module) => {
+    return (module.extensions?.[name] as T | undefined) ?? extension;
+  }, undefined);
+}
+
+/**
+ * 统一模块路径和后端菜单组件路径的表示形式。
+ */
+function normalizeAdminViewPath(path?: string): string {
+  if (!path) return "";
+
+  let normalizedPath = path.trim().replace(/\\/g, "/");
+  normalizedPath = normalizedPath.replace(/^.*\/src\/views\//, "");
+  normalizedPath = normalizedPath.replace(/^.*\/views\//, "");
+  normalizedPath = normalizedPath.replace(/^\.\/views\//, "");
+  normalizedPath = normalizedPath.replace(/^\/+/, "");
+  normalizedPath = normalizedPath.replace(/\.vue$/, "");
+
+  return normalizedPath;
+}
+
+/** 校验模块提供的命名入口在整个宿主内唯一。 */
+function assertUniqueAdminModuleKeys(modules: AdminModule[], label: string, getKeys: (module: AdminModule) => string[]): void {
+  const owners = new Map<string, string>();
+
+  modules.forEach(module => {
+    getKeys(module).forEach(key => {
+      const owner = owners.get(key);
+      if (owner) {
+        throw new Error(`管理端${label}名称重复: ${key}（模块 ${owner} 与 ${module.name}）`);
+      }
+      owners.set(key, module.name);
+    });
+  });
+}

package/dist/package/src/modules/kratosAdmin.ts

@@ -0,0 +1,17 @@
+import { ADMIN_STATIC_VIEWS, defineAdminModule, type AdminStaticViewModules } from "./index";
+
+const staticViewModules: AdminStaticViewModules = {
+  [ADMIN_STATIC_VIEWS.LOGIN]: () => import("../views/login/index.vue"),
+  [ADMIN_STATIC_VIEWS.FORBIDDEN]: () => import("../views/error/403.vue"),
+  [ADMIN_STATIC_VIEWS.NOT_FOUND]: () => import("../views/error/404.vue"),
+  [ADMIN_STATIC_VIEWS.SERVER_ERROR]: () => import("../views/error/500.vue"),
+  [ADMIN_STATIC_VIEWS.PENDING]: () => import("../views/error/pending.vue")
+};
+
+/**
+ * kratos-admin 内置基础模块。
+ */
+export const kratosAdminModule = defineAdminModule({
+  name: "kratos-admin",
+  staticViews: staticViewModules
+});

package/dist/package/src/navigation.ts

@@ -0,0 +1,2 @@
+export { default, default as router } from "./routers";
+export { isUnmatchedRoute, navigateTo, resolveFrontendRouteURL } from "./utils/router";

package/dist/package/src/request.ts

@@ -0,0 +1,2 @@
+export { default } from "./utils/request";
+export { ensureAccessToken, getRequestAccessToken, handleAuthExpired, hasValidAccessToken, requestBaseURL } from "./utils/request";

package/dist/package/src/routers/index.ts

@@ -0,0 +1,143 @@
+import { createRouter, createWebHashHistory, createWebHistory } from "vue-router";
+import { useAuthStore } from "../stores/modules/auth";
+import { HOME_URL, LOGIN_URL, ROUTER_WHITE_LIST } from "../config";
+import { initDynamicRouter } from "../routers/modules/dynamicRouter";
+import { staticRouter, errorRouter } from "../routers/modules/staticRouter";
+import NProgress from "../config/nprogress";
+import { isUnmatchedRoute } from "../utils/router";
+import { ensureAccessToken } from "../utils/request";
+
+const mode = import.meta.env.VITE_ROUTER_MODE;
+
+const routerMode = {
+  hash: () => createWebHashHistory(),
+  history: () => createWebHistory()
+};
+
+/**
+ * @description 📚 路由参数配置简介
+ * @param path ==> 路由菜单访问路径
+ * @param name ==> 路由 name (对应页面组件 name, 可用作 KeepAlive 缓存标识 && 按钮权限筛选)
+ * @param redirect ==> 路由重定向地址
+ * @param component ==> 视图文件路径
+ * @param meta ==> 路由菜单元信息
+ * @param meta.icon ==> 菜单和面包屑对应的图标
+ * @param meta.title ==> 路由标题 (用作 document.title || 菜单的名称)
+ * @param meta.hide ==> 是否在菜单中隐藏 (通常列表详情页需要隐藏)
+ * @param meta.alwaysShow ==> 目录只有一个子路由时是否始终显示
+ * @param meta.full ==> 菜单是否全屏 (示例：数据大屏页面)
+ * @param meta.affix ==> 菜单是否固定在标签页中 (首页通常是固定项)
+ * @param meta.keepAlive ==> 当前路由是否缓存
+ * */
+const router = createRouter({
+  history: routerMode[mode](),
+  routes: [...staticRouter, ...errorRouter],
+  strict: false,
+  scrollBehavior: () => ({ left: 0, top: 0 })
+});
+
+/**
+ * @description 路由拦截 beforeEach
+ * */
+router.beforeEach(async to => {
+  const authStore = useAuthStore();
+  const redirectQuery = typeof to.query.redirect === "string" ? to.query.redirect : "";
+
+  // 1.NProgress 开始
+  NProgress.start();
+
+  // 2.动态设置标题
+  const title = import.meta.env.VITE_GLOB_APP_TITLE;
+  document.title = to.meta.title ? `${to.meta.title} - ${title}` : title;
+
+  const hasAccessToken = await ensureAccessToken();
+
+  // 3.判断是访问登陆页，有 Token 就在当前页面，没有 Token 重置路由到登陆页
+  if (to.path.toLocaleLowerCase() === LOGIN_URL) {
+    const hasOauthCallback = typeof to.query.oauth_ticket === "string" || typeof to.query.oauth_error === "string";
+    if (hasOauthCallback) {
+      resetRouter();
+      return true;
+    }
+    if (hasAccessToken) {
+      // 登录态访问登录页时优先回到显式 redirect，避免 from 为根路径时触发重复重定向。
+      const targetPath = redirectQuery && redirectQuery !== LOGIN_URL ? redirectQuery : HOME_URL;
+      return targetPath;
+    }
+    resetRouter();
+    return true;
+  }
+
+  // 4.判断访问页面是否在路由白名单地址(静态路由)中，如果存在直接放行
+  if (ROUTER_WHITE_LIST.includes(to.path)) return true;
+
+  // 5.判断是否有可用 Token，没有重定向到 login 页面
+  if (!hasAccessToken) {
+    const redirect = to.path === LOGIN_URL ? undefined : to.fullPath;
+    return {
+      path: LOGIN_URL,
+      query: redirect ? { redirect } : undefined,
+      replace: true
+    };
+  }
+
+  // 6.如果没有菜单列表，就重新请求菜单列表并添加动态路由
+  if (!authStore.authMenuListGet.length) {
+    await initDynamicRouter();
+    if (isUnmatchedRoute(router, to.path)) return getFirstAccessibleRoutePath();
+    return { ...to, replace: true };
+  }
+
+  // 6.1 菜单已恢复但路由实例尚未重新挂载时，补跑一次动态路由注册，避免刷新或登录首跳直接命中 404。
+  if (isUnmatchedRoute(router, to.path)) {
+    await initDynamicRouter();
+    if (isUnmatchedRoute(router, to.path)) return getFirstAccessibleRoutePath();
+    return { ...to, replace: true };
+  }
+
+  // 7.存储 routerName 做按钮权限筛选
+  authStore.setRouteName(to.name as string);
+
+  // 8.正常访问页面
+  return true;
+});
+
+/**
+ * @description 重置路由
+ * */
+export const resetRouter = () => {
+  const authStore = useAuthStore();
+  authStore.flatMenuListGet.forEach(route => {
+    const { name } = route;
+    if (name && router.hasRoute(name)) router.removeRoute(name);
+  });
+};
+
+/** 获取当前已注册动态菜单中的第一个可访问页面，作为首页不可用时的兜底落点。 */
+function getFirstAccessibleRoutePath() {
+  const authStore = useAuthStore();
+  const systemRouteSet = new Set(["/", "/layout", LOGIN_URL, "/403", "/404", "/500"]);
+  const firstRoute = authStore.flatMenuListGet.find(item => {
+    if (!item.path || systemRouteSet.has(item.path) || item.meta?.hidden) return false;
+    if (item.children?.length || !item.component || item.component === "Layout") return false;
+    return !isUnmatchedRoute(router, item.path);
+  });
+  return firstRoute?.path ?? "/404";
+}
+
+/**
+ * @description 路由跳转错误
+ * */
+router.onError(error => {
+  NProgress.done();
+  console.warn("路由错误", error.message);
+});
+
+/**
+ * @description 路由跳转结束
+ * */
+router.afterEach(() => {
+  NProgress.done();
+});
+
+export default router;

package/dist/package/src/routers/modules/dynamicRouter.ts

@@ -0,0 +1,160 @@
+import router from "../../routers/index";
+import { LOGIN_URL } from "../../config";
+import { RouteRecordRaw } from "vue-router";
+import { ElNotification } from "element-plus";
+import { useUserStore } from "../../stores/modules/user";
+import { useAuthStore } from "../../stores/modules/auth";
+import type { RouteItem } from "../../rpc/system/admin/v1/auth";
+import { BaseMenuType } from "../../rpc/system/common/v1/enum";
+import { getRouteMetaFull } from "../../utils";
+import { ADMIN_STATIC_VIEWS, getAdminViewRegistry } from "../../modules";
+
+/** 解析后的后端路由项，补齐完整路径和重定向。 */
+type ResolvedRouteItem = {
+  item: RouteItem;
+  path: string;
+  redirect?: string;
+};
+
+/**
+ * 判断是否为外链路径。
+ */
+function isExternalPath(path: string) {
+  return /^(https?:|mailto:|tel:)/.test(path);
+}
+
+/**
+ * 规范化绝对路由路径，统一前导斜杠并移除重复/尾部斜杠。
+ */
+function normalizeAbsolutePath(path: string) {
+  if (!path) return "";
+  const pathWithSlash = path.startsWith("/") ? path : `/${path}`;
+  const normalizedPath = pathWithSlash.replace(/\/{2,}/g, "/");
+  if (normalizedPath === "/") return normalizedPath;
+  return normalizedPath.replace(/\/+$/, "");
+}
+
+/**
+ * 结合父级路径解析当前路由路径。
+ */
+function resolveRoutePath(rawPath: string | undefined, parentPath = "") {
+  if (!rawPath) return "";
+  const trimmedPath = rawPath.trim();
+  if (!trimmedPath) return "";
+  if (isExternalPath(trimmedPath)) return trimmedPath;
+  if (trimmedPath.startsWith("/")) return normalizeAbsolutePath(trimmedPath);
+
+  const normalizedParentPath = normalizeAbsolutePath(parentPath);
+  if (!normalizedParentPath || normalizedParentPath === "/") {
+    return normalizeAbsolutePath(trimmedPath);
+  }
+  return normalizeAbsolutePath(`${normalizedParentPath}/${trimmedPath}`);
+}
+
+/**
+ * 递归解析菜单的完整路径，兼容子菜单相对路径。
+ */
+function buildResolvedRouteItems(menuList: RouteItem[], parentPath = ""): ResolvedRouteItem[] {
+  const resolvedRouteItems: ResolvedRouteItem[] = [];
+
+  menuList.forEach(item => {
+    const currentPath = resolveRoutePath(item.path, parentPath);
+    const redirectBasePath = currentPath || parentPath;
+    const currentRedirect = resolveRoutePath(item.redirect, redirectBasePath);
+
+    resolvedRouteItems.push({
+      item,
+      path: currentPath,
+      redirect: currentRedirect || undefined
+    });
+
+    if (!item.children?.length) return;
+
+    // 子路由优先基于当前节点路径进行拼接，保证目录 + 菜单路径可还原为完整地址。
+    const childParentPath = currentPath || parentPath;
+    resolvedRouteItems.push(...buildResolvedRouteItems(item.children, childParentPath));
+  });
+
+  return resolvedRouteItems;
+}
+
+/**
+ * 解析菜单对应的页面组件。
+ */
+function resolveRouteComponent(component?: string) {
+  const viewRegistry = getAdminViewRegistry();
+  const viewLoader = viewRegistry.resolve(component);
+  if (viewLoader) return viewLoader;
+
+  const pendingViewLoader = viewRegistry.resolve(ADMIN_STATIC_VIEWS.PENDING);
+  if (!pendingViewLoader) throw new Error(`未注册管理端静态页面：${ADMIN_STATIC_VIEWS.PENDING}`);
+  return pendingViewLoader;
+}
+
+/**
+ * 将后端路由项转换为前端路由记录。
+ */
+function createRouteRecord(item: RouteItem, path: string, redirect?: string) {
+  return {
+    path,
+    redirect,
+    name: item.name ?? undefined,
+    component: item.component ?? undefined,
+    meta: item.meta ?? undefined
+  } as RouteRecordRaw & {
+    component?: string | (() => Promise<unknown>);
+  };
+}
+
+/**
+ * @description 初始化动态路由
+ */
+export const initDynamicRouter = async () => {
+  const userStore = useUserStore();
+  const authStore = useAuthStore();
+
+  try {
+    // 1.获取菜单列表 && 按钮权限列表
+    await authStore.getAuthMenuList();
+    await authStore.getAuthButtonList();
+
+    // 2.判断当前用户有没有菜单权限
+    if (!authStore.authMenuListGet.length) {
+      ElNotification({
+        title: "无权限访问",
+        message: "当前账号无任何菜单权限，请联系系统管理员！",
+        type: "warning",
+        duration: 3000
+      });
+      userStore.clearAuthData();
+      router.replace(LOGIN_URL);
+      return Promise.reject("No permission");
+    }
+
+    // 3.添加动态路由
+    const resolvedRouteItems = buildResolvedRouteItems(authStore.authMenuListGet);
+    resolvedRouteItems.forEach(({ item, path, redirect }) => {
+      if (item.type === BaseMenuType.EXT_LINK) return;
+      const routeRecord = createRouteRecord(item, path, redirect);
+
+      if (typeof routeRecord.component === "string") {
+        const resolvedComponent = resolveRouteComponent(routeRecord.component);
+        if (!resolvedComponent) return;
+        routeRecord.component = resolvedComponent;
+      }
+      if (!routeRecord.component) return;
+      if (!routeRecord.path) return;
+      if (routeRecord.name && router.hasRoute(routeRecord.name)) return;
+      if (getRouteMetaFull(item.meta)) {
+        router.addRoute(routeRecord);
+      } else {
+        router.addRoute("Layout", routeRecord);
+      }
+    });
+  } catch (error) {
+    // 当按钮 || 菜单请求出错时，重定向到登陆页
+    userStore.clearAuthData();
+    router.replace(LOGIN_URL);
+    return Promise.reject(error);
+  }
+};

package/dist/package/src/routers/modules/staticRouter.ts

@@ -0,0 +1,73 @@
+import { RouteRecordRaw } from "vue-router";
+import { HOME_URL, LOGIN_URL } from "../../config";
+import { ADMIN_STATIC_VIEWS, getAdminViewRegistry } from "../../modules";
+
+/** 创建通过视图注册表解析的静态页面加载器。 */
+function createAdminStaticViewLoader(viewPath: string) {
+  return () => {
+    const viewLoader = getAdminViewRegistry().resolve(viewPath);
+    if (!viewLoader) throw new Error(`未注册管理端静态页面：${viewPath}`);
+    return viewLoader();
+  };
+}
+
+/**
+ * staticRouter (静态路由)
+ */
+export const staticRouter: RouteRecordRaw[] = [
+  {
+    path: "/",
+    redirect: HOME_URL
+  },
+  {
+    path: LOGIN_URL,
+    name: "Login",
+    component: createAdminStaticViewLoader(ADMIN_STATIC_VIEWS.LOGIN),
+    meta: {
+      title: "登录"
+    }
+  },
+  {
+    path: "/layout",
+    name: "Layout",
+    component: () => import("../../layouts/index.vue"),
+    // component: () => import("../../layouts/indexAsync.vue"),
+    redirect: HOME_URL,
+    children: []
+  }
+];
+
+/**
+ * errorRouter (错误页面路由)
+ */
+export const errorRouter = [
+  {
+    path: "/403",
+    name: "403",
+    component: createAdminStaticViewLoader(ADMIN_STATIC_VIEWS.FORBIDDEN),
+    meta: {
+      title: "403页面"
+    }
+  },
+  {
+    path: "/404",
+    name: "404",
+    component: createAdminStaticViewLoader(ADMIN_STATIC_VIEWS.NOT_FOUND),
+    meta: {
+      title: "404页面"
+    }
+  },
+  {
+    path: "/500",
+    name: "500",
+    component: createAdminStaticViewLoader(ADMIN_STATIC_VIEWS.SERVER_ERROR),
+    meta: {
+      title: "500页面"
+    }
+  },
+  // Resolve refresh page, route warnings
+  {
+    path: "/:pathMatch(.*)*",
+    component: createAdminStaticViewLoader(ADMIN_STATIC_VIEWS.NOT_FOUND)
+  }
+];

package/dist/package/src/rpc/base/v1/config.ts

@@ -0,0 +1,34 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               unknown
+// source: base/v1/config.proto
+
+/* eslint-disable */
+import type { BaseConfigSite } from "../../common/v1/enum";
+
+/** 获取系统配置条件 */
+export interface GetConfigRequest {
+  /** 位置：枚举【BaseConfigSite】 */
+  site: BaseConfigSite;
+}
+
+/** 系统配置项 */
+export interface ConfigItem {
+  /** 配置key */
+  key: string;
+  /** 配置value */
+  value: string;
+}
+
+/** 系统配置查询结果 */
+export interface GetConfigResponse {
+  /** 系统配置列表 */
+  configs: ConfigItem[];
+}
+
+/** Base系统配置公共服务 */
+export interface ConfigService {
+  /** 获取系统配置 */
+  GetConfig(request: GetConfigRequest): Promise<GetConfigResponse>;
+}