refactor: refactor global-config

apps/web/src/api-clients/api-client-manager.ts

@@ -1,8 +1,7 @@
 import { SpaceConnector } from '@cloudforet/core-lib/space-connector';
 
-import type { ApiClientsSchemaType } from '@/lib/config/global-config/api-client-schema';
-import { ApiClientEndpoint } from '@/lib/config/global-config/api-client-schema';
-import type { GlobalServiceConfig } from '@/lib/config/global-config/type';
+import { ApiClientEndpoint } from '@/lib/config/global-config/schema/api-client-schema';
+import type { ApiClientsSchemaType, GlobalServiceConfig } from '@/lib/config/global-config/types/type';
 
 
 class APIClientManager {

apps/web/src/common/composables/contents-accessibility/index.ts

@@ -1,7 +1,7 @@
 import type { Ref } from 'vue';
 import { computed, reactive, toRef } from 'vue';
 
-import { useMenuStore } from '@/store/menu/menu-store';
+import { useGlobalConfigStore } from '@/store/global-config/global-config-store';
 
 import type { MenuId } from '@/lib/menu/config';
 
@@ -10,11 +10,10 @@ interface UseContentsAccessibilityReturnType {
 }
 
 export const useContentsAccessibility = (menuId: MenuId): UseContentsAccessibilityReturnType => {
-    const menuStore = useMenuStore();
-    const menuState = menuStore.state;
+    const globalConfigStore = useGlobalConfigStore();
 
     const state = reactive({
-        visibleContents: computed<boolean>(() => menuState.menuList.findIndex((menu) => menu.id === menuId) !== -1),
+        visibleContents: computed<boolean>(() => globalConfigStore.getters.menuList.findIndex((menu) => menu.id === menuId) !== -1),
     });
 
     return {

apps/web/src/common/modules/navigations/stores/gnb-store.ts

@@ -22,7 +22,6 @@ import type { FavoriteOptions } from '@/common/modules/favorites/favorite-button
 import type { Breadcrumb } from '@/common/modules/page-layouts/type';
 
 interface GnbStoreState {
-    visibleAlertIcon?: boolean;
     breadcrumbs: Breadcrumb[];
     selectedItem: Breadcrumb;
     id?: string;
@@ -45,7 +44,6 @@ export const useGnbStore = defineStore('gnb', () => {
     });
 
     const state = reactive<GnbStoreState>({
-        visibleAlertIcon: false,
         breadcrumbs: [],
         selectedItem: {} as Breadcrumb,
         id: '',
@@ -68,9 +66,6 @@ export const useGnbStore = defineStore('gnb', () => {
     });
 
     const mutations = {
-        setVisibleAlertIcon: (val?: boolean) => {
-            state.visibleAlertIcon = val;
-        },
         setBreadcrumbs: (breadcrumbs: Breadcrumb[]) => {
             state.breadcrumbs = breadcrumbs;
         },

apps/web/src/common/modules/navigations/top-bar/modules/top-bar-toolset/TopBarToolset.vue

@@ -7,9 +7,9 @@ import { i18n } from '@/translations';
 
 import { useAppContextStore } from '@/store/app-context/app-context-store';
 import { useDomainStore } from '@/store/domain/domain-store';
+import { useGlobalConfigStore } from '@/store/global-config/global-config-store';
 import { useUserStore } from '@/store/user/user-store';
 
-import { useGnbStore } from '@/common/modules/navigations/stores/gnb-store';
 import TopBarAdminToggleButton from '@/common/modules/navigations/top-bar/modules/top-bar-toolset/modules/top-bar-admin-toggle-button/TopBarAdminToggleButton.vue';
 import TopBarFavorite
     from '@/common/modules/navigations/top-bar/modules/top-bar-toolset/modules/top-bar-favorite/TopBarFavorite.vue';
@@ -32,13 +32,13 @@ const emit = defineEmits<{(event: 'hide-menu'): void;
 const appContextStore = useAppContextStore();
 const domainStore = useDomainStore();
 const userStore = useUserStore();
-const gnbStore = useGnbStore();
+const globalConfigStore = useGlobalConfigStore();
 
 const state = reactive({
     isDomainAdmin: computed(() => userStore.getters.isDomainAdmin),
     isAdminMode: computed(() => appContextStore.getters.isAdminMode),
     isGrantLoading: computed(() => appContextStore.getters.globalGrantLoading),
-    visibleAlertIcon: computed(() => gnbStore.state.visibleAlertIcon),
+    visibleAlertIcon: computed(() => globalConfigStore.state.schema.ALERT_MANAGER.uiAffects?.visibleAlertIcon),
     tooltipTexts: computed<Record<string, string>>(() => ({
         adminToggle: (state.isAdminMode ? i18n.t('COMMON.GNB.TOOLTIP.EXIT_ADMIN_MODE') : i18n.t('COMMON.GNB.TOOLTIP.ENABLE_ADMIN_MODE')) as string,
     })),

apps/web/src/lib/access-control/page-access-helper.ts

@@ -1,6 +1,6 @@
 import type { RoleType } from '@/api-clients/identity/role/type';
 
-import { useMenuStore } from '@/store/menu/menu-store';
+import { useGlobalConfigStore } from '@/store/global-config/global-config-store';
 
 import type {
     PageAccessMap,
@@ -14,7 +14,7 @@ import {
     WORKSPACE_USER_MINIMAL_PERMISSIONS,
 } from '@/lib/access-control/config';
 import config from '@/lib/config';
-import type { GlobalServiceConfig } from '@/lib/config/global-config/type';
+import type { GlobalServiceConfig } from '@/lib/config/global-config/types/type';
 import type { Menu, MenuId } from '@/lib/menu/config';
 
 import type { LSBItem, LSBMenu } from '@/common/modules/navigations/lsb/type';
@@ -48,9 +48,9 @@ export const flattenMenu = (menuList: Menu[]): Menu[] => menuList.flatMap((menu)
 
 export const getPageAccessMapFromRawData = (pageAccessPermissions?: string[], isRolePage?: boolean): PageAccessMap => {
     const globalConfig = config.get('SERVICES') || {};
-    const menuStore = useMenuStore();
+    const globalConfigStore = useGlobalConfigStore();
     const result: PageAccessMap = {};
-    const menuListByVersion = !isRolePage ? menuStore.state.menuList : getEnabledMenus(globalConfig);
+    const menuListByVersion = !isRolePage ? globalConfigStore.getters.menuList : getEnabledMenus(globalConfig);
     const flattenedMenuList = flattenMenu(menuListByVersion);
     const setPermissions = (id: string, read = true, write = true, access = true) => {
         result[id] = { read, write, access };

apps/web/src/lib/access-control/redirect-route-helper.ts

@@ -3,8 +3,7 @@ import type { Location } from 'vue-router/types/router';
 
 import { ERROR_ROUTE } from '@/router/constant';
 
-import type { FlattenedMenuMap } from '@/store/menu/menu-store';
-import { useMenuStore } from '@/store/menu/menu-store';
+import { useGlobalConfigStore, type FlattenedMenuMap } from '@/store/global-config/global-config-store';
 
 import type { PageAccessMap } from '@/lib/access-control/config';
 import type { MenuId } from '@/lib/menu/config';
@@ -19,8 +18,8 @@ export const getRedirectRouteByPagePermission = (route: Route, pagePermissionsMa
     const menuId = route.meta?.menuId;
     if (!menuId) return { name: ERROR_ROUTE._NAME, params: { statusCode: '404' } };
 
-    const menuStore = useMenuStore();
-    const generateFlattenedMenuMap = menuStore.getters.generateFlattenedMenuMap;
+    const globalConfigStore = useGlobalConfigStore();
+    const generateFlattenedMenuMap = globalConfigStore.getters.generateFlattenedMenuMap;
     const subMenuIdList = getSubMenuListByMenuId(menuId, generateFlattenedMenuMap);
     let redirectMenuId: MenuId|undefined;
     subMenuIdList.some((subMenuId) => {

apps/web/src/lib/config/global-config/feature-schema-manager.ts

@@ -1,54 +1,70 @@
-import { FEATURES } from '@/lib/config/global-config/constants';
-import { initialFeatureSchema } from '@/lib/config/global-config/feature-schema';
-import type { FeatureSchemaType, GlobalServiceConfig } from '@/lib/config/global-config/type';
-import { MENU_ID } from '@/lib/menu/config';
+import { useGlobalConfigStore } from '@/store/global-config/global-config-store';
 
-export class FeatureSchemaManager {
-    private serviceConfig: GlobalServiceConfig;
+import { getFeatureConfigurator } from '@/lib/config/global-config/helpers/get-feature-configurator';
+import type { FeatureSchemaType, GlobalServiceConfig } from '@/lib/config/global-config/types/type';
 
-    private readonly schema: FeatureSchemaType;
+export class FeatureSchemaManager {
+    private config: GlobalServiceConfig = {
+        IAM: {
+            ENABLED: true,
+            VERSION: 'V1',
+        },
+    };
 
-    constructor(serviceConfig: GlobalServiceConfig) {
-        this.serviceConfig = serviceConfig;
-        this.schema = JSON.parse(JSON.stringify(initialFeatureSchema));
+    initialize(config: GlobalServiceConfig) {
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+        this.createSchema();
     }
 
-    applyGlobalConfig(): FeatureSchemaType {
-        Object.entries(this.serviceConfig).forEach(([serviceName, config]) => {
-            if (config.ENABLED) {
-                this.updateSchema(serviceName, config.VERSION);
-            } else {
-                delete this.schema[serviceName];
-            }
-        });
+    createSchema() {
+        const globalConfigStore = useGlobalConfigStore();
+        const schema = {} as FeatureSchemaType;
 
-        return this.schema;
-    }
+        const featureMethodMap: Record<string, Record<string, boolean>> = {};
 
-    private updateSchema(serviceName: string, version: string): void {
-        if (!this.schema || !this.schema[serviceName]) return;
+        Object.keys(this.config).forEach((feature) => {
+            if (this.config[feature]?.ENABLED) {
+                const configurator = getFeatureConfigurator(feature);
+                if (configurator) {
+                    const currentVersion = this.config[feature]?.VERSION || 'V1';
+                    configurator.initialize(currentVersion);
+                    const menuConfig = configurator.getMenu();
 
-        this.schema[serviceName].currentVersion = version;
+                    if (configurator.uiAffect) {
+                        configurator.uiAffect.forEach((uiAffect) => {
+                            const targetFeature = uiAffect.feature;
+                            const targetVersion = targetFeature === feature
+                                ? currentVersion
+                                : (this.config[targetFeature]?.VERSION || 'V1');
 
-        if (serviceName === FEATURES.ALERT_MANAGER) {
-            if (version === 'V2') {
-                const iamFeatureSettings = this.schema[FEATURES.IAM].V1;
-                iamFeatureSettings.menu[MENU_ID.USER_GROUP] = true;
-                if (iamFeatureSettings.adminMenu) {
-                    iamFeatureSettings.adminMenu[MENU_ID.USER_GROUP] = true;
+                            if (!featureMethodMap[targetFeature]) {
+                                featureMethodMap[targetFeature] = {};
+                            }
+
+                            uiAffect.affects.forEach((affect) => {
+                                if (affect.version === targetVersion) {
+                                    featureMethodMap[targetFeature][affect.method] = true;
+                                }
+                            });
+                        });
+                    }
+
+                    schema[feature] = {
+                        version: currentVersion,
+                        menu: menuConfig.menu,
+                        adminMenu: menuConfig?.adminMenu === null ? null : (menuConfig?.adminMenu || menuConfig?.menu),
+                        uiAffects: feature in featureMethodMap ? featureMethodMap[feature] : {},
+                    };
                 }
-                this.updateUiAffects(FEATURES.PROJECT, 'V1', 'visibleAlertTabAtDetail', false);
-                this.updateUiAffects(FEATURES.ASSET_INVENTORY, 'V1', 'visibleAlertTabAtDetail', false);
-                this.updateUiAffects(FEATURES.COST_EXPLORER, 'V1', 'visibleBudgetNotification', true);
             }
-        }
-    }
+        });
 
-    private updateUiAffects(featureKey: string, version: string, affectKey: string, value: boolean): void {
-        const feature = this.schema[featureKey]?.[version];
-        if (feature?.uiAffects?.[affectKey] !== undefined) {
-            feature.uiAffects[affectKey] = value;
-        }
+        globalConfigStore.setSchema(schema);
     }
 }
 
+
+export default new FeatureSchemaManager();

apps/web/src/lib/config/global-config/generate-routes.ts

@@ -0,0 +1,31 @@
+import type { RouteConfig } from 'vue-router';
+
+import { useGlobalConfigStore } from '@/store/global-config/global-config-store';
+
+import { getFeatureConfigurator } from '@/lib/config/global-config/helpers/get-feature-configurator';
+
+import adminAdvancedRoutes from '@/services/advanced/routes/admin/routes';
+import adminInfoRoutes from '@/services/info/routes/admin/routes';
+import infoRoutes from '@/services/info/routes/routes';
+import adminWorkspaceHomeRoutes from '@/services/workspace-home/routes/admin/routes';
+import workspaceHomeRoute from '@/services/workspace-home/routes/routes';
+
+export const generateRoutes = (mode: string): RouteConfig[] => {
+    const globalConfigStore = useGlobalConfigStore();
+    const schema = globalConfigStore.state.schema;
+    const baseRoutes = mode === 'admin'
+        ? [adminWorkspaceHomeRoutes, adminAdvancedRoutes, adminInfoRoutes]
+        : [workspaceHomeRoute, infoRoutes];
+
+    Object.keys(schema).forEach((serviceName) => {
+        const configurator = getFeatureConfigurator(serviceName);
+        if (configurator) {
+            const route = configurator.getRoutes(mode === 'admin');
+            if (route && !baseRoutes.some((existingRoute) => existingRoute.path === route.path)) {
+                baseRoutes.push(route);
+            }
+        }
+    });
+
+    return baseRoutes;
+};