Revert "temp release"

This reverts commit 56546a7777da4b166054d5b1a741422e6132119a.

src/services/api.js

@@ -8,7 +8,7 @@ const getApiUrls = () => {
     GATEWAY_URL: config.GATEWAY_URL || 'http://20.1.2.3',
     AUTH_URL: 'http://localhost:8081/api/auth',
     MEMBER_URL: 'http://localhost:8081/api/member',
-    STORE_URL: config.STORE_URL || 'http://localhost:8082/api/store',
+    STORE_URL: config.STORE_URL || 'http://20.1.2.3/api/store',
     CONTENT_URL: config.CONTENT_URL || 'http://20.1.2.3/api/content',
     MENU_URL: config.MENU_URL || 'http://20.1.2.3/api/menu',
     SALES_URL: config.SALES_URL || 'http://20.1.2.3/api/sales',

src/store/index.js

@@ -1,153 +1,285 @@
-//* src/store/index.js - Store 스토어 수정 (매장 조회 부분)
+//* src/store/index.js
+/**
+ * Pinia 스토어 설정
+ * 전역 상태 관리
+ */
 import { defineStore } from 'pinia'
-// 매장 스토어에 추가할 fetchStoreInfo 메서드
+import authService from '@/services/auth'
-export const useStoreStore = defineStore('store', {
+import storeService from '@/services/store'
+
+// 인증 스토어
+export const useAuthStore = defineStore('auth', {
   state: () => ({
-    storeInfo: null,
+    user: null,
-    loading: false,
+    token: localStorage.getItem('token'),
-    error: null
+    refreshToken: localStorage.getItem('refreshToken'),
+    isAuthenticated: false
   }),
   
   getters: {
-    hasStoreInfo: (state) => !!state.storeInfo,
+    getUserInfo: (state) => state.user,
-    isLoading: (state) => state.loading
+    isLoggedIn: (state) => state.isAuthenticated && !!state.token
   },
   
   actions: {
-    /**
+    async login(credentials) {
-     * 매장 정보 조회
+      try {
-     */
+        const response = await authService.login(credentials)
+        this.setAuth(response.data)
+        return response
+      } catch (error) {
+        this.clearAuth()
+        throw error
+      }
+    },
+    
+    async register(userData) {
+      try {
+        const response = await authService.register(userData)
+        return response
+      } catch (error) {
+        throw error
+      }
+    },
+    
+    async logout() {
+      try {
+        if (this.token) {
+          await authService.logout()
+        }
+      } catch (error) {
+        console.error('로그아웃 오류:', error)
+      } finally {
+        this.clearAuth()
+      }
+    },
+    
+    async refreshUserInfo() {
+      try {
+        const response = await authService.getUserInfo()
+        this.user = response.data
+        this.isAuthenticated = true
+        return response
+      } catch (error) {
+        this.clearAuth()
+        throw error
+      }
+    },
+    
+    setAuth(authData) {
+      this.user = authData.user
+      this.token = authData.accessToken
+      this.refreshToken = authData.refreshToken
+      this.isAuthenticated = true
+      
+      localStorage.setItem('token', authData.accessToken)
+      localStorage.setItem('refreshToken', authData.refreshToken)
+    },
+    
+    clearAuth() {
+      this.user = null
+      this.token = null
+      this.refreshToken = null
+      this.isAuthenticated = false
+      
+      localStorage.removeItem('token')
+      localStorage.removeItem('refreshToken')
+    }
+  }
+})
+
+// 앱 전역 스토어
+export const useAppStore = defineStore('app', {
+  state: () => ({
+    loading: false,
+    snackbar: {
+      show: false,
+      message: '',
+      color: 'success',
+      timeout: 3000
+    },
+    notifications: [],
+    notificationCount: 0
+  }),
+  
+  actions: {
+    setLoading(status) {
+      this.loading = status
+    },
+    
+    showSnackbar(message, color = 'success', timeout = 3000) {
+      this.snackbar = {
+        show: true,
+        message,
+        color,
+        timeout
+      }
+    },
+    
+    hideSnackbar() {
+      this.snackbar.show = false
+    },
+    
+    addNotification(notification) {
+      this.notifications.unshift({
+        id: Date.now(),
+        timestamp: new Date(),
+        ...notification
+      })
+      this.notificationCount = this.notifications.length
+    },
+    
+    clearNotifications() {
+      this.notifications = []
+      this.notificationCount = 0
+    }
+  }
+})
+
+// 매장 스토어
+export const useStoreStore = defineStore('store', {
+  state: () => ({
+    storeInfo: null,
+    loading: false
+  }),
+  
+  getters: {
+    hasStoreInfo: (state) => !!state.storeInfo
+  },
+  
+  actions: {
+    setStoreInfo(storeInfo) {
+      this.storeInfo = storeInfo
+    },
+
     async fetchStoreInfo() {
-      console.log('=== Store 스토어: 매장 정보 조회 시작 ===')
-      this.loading = true
-      this.error = null
-      
       try {
-        // 스토어 서비스 임포트
+        this.loading = true
-        const { storeService } = await import('@/services/store')
+        const response = await storeService.getStore() // getStoreInfo가 아닌 getStore
-        
+        this.storeInfo = response.data
-        console.log('매장 정보 API 호출')
+        return response
-        const result = await storeService.getStore()
-        
-        console.log('=== Store 스토어: API 응답 분석 ===')
-        console.log('Result:', result)
-        console.log('Result.success:', result.success)
-        console.log('Result.data:', result.data)
-        console.log('Result.message:', result.message)
-        
-        if (result.success && result.data) {
-          // 매장 정보가 있는 경우
-          console.log('✅ 매장 정보 설정:', result.data)
-          this.storeInfo = result.data
-          return { success: true, data: result.data }
-        } else {
-          // 매장이 없거나 조회 실패한 경우
-          console.log('⚠️ 매장 정보 없음 또는 조회 실패')
-          this.storeInfo = null
-          
-          if (result.message === '등록된 매장이 없습니다') {
-            return { success: false, message: '등록된 매장이 없습니다' }
-          } else {
-            return { success: false, message: result.message || '매장 정보 조회에 실패했습니다' }
-          }
-        }
       } catch (error) {
-        console.error('=== Store 스토어: 매장 정보 조회 실패 ===')
+        throw error
-        console.error('Error:', error)
-        
-        this.error = error.message
-        this.storeInfo = null
-        
-        // HTTP 상태 코드별 처리
-        if (error.response?.status === 404) {
-          return { success: false, message: '등록된 매장이 없습니다' }
-        }
-        
-        if (error.response?.status >= 500) {
-          return { success: false, message: '서버 오류가 발생했습니다. 잠시 후 다시 시도해주세요.' }
-        }
-        
-        if (error.response?.status === 401) {
-          return { success: false, message: '로그인이 필요합니다' }
-        }
-        
-        return { success: false, message: error.message || '매장 정보 조회에 실패했습니다' }
       } finally {
         this.loading = false
       }
     },
-
+    
-    /**
-     * 매장 등록
-     */
     async registerStore(storeData) {
-      console.log('매장 등록 시작:', storeData)
-      this.loading = true
-      this.error = null
-      
       try {
-        const { storeService } = await import('@/services/store')
+        this.loading = true
-        
+        const response = await storeService.registerStore(storeData)
-        const result = await storeService.registerStore(storeData)
+        this.storeInfo = response.data
-        
+        return response
-        console.log('매장 등록 결과:', result)
-        
-        if (result.success) {
-          // 등록 성공 후 매장 정보 다시 조회
-          await this.fetchStoreInfo()
-          return result
-        } else {
-          this.error = result.message
-          return result
-        }
       } catch (error) {
-        console.error('매장 등록 실패:', error)
+        throw error
-        this.error = error.message
-        return { success: false, message: error.message || '매장 등록에 실패했습니다' }
       } finally {
         this.loading = false
       }
     },
-
+    
-    /**
-     * 매장 정보 수정
-     */
     async updateStore(storeId, storeData) {
-      console.log('매장 정보 수정 시작:', { storeId, storeData })
-      this.loading = true
-      this.error = null
-      
       try {
-        const { storeService } = await import('@/services/store')
+        this.loading = true
-        
+        const response = await storeService.updateStore(storeId, storeData)
-        const result = await storeService.updateStore(storeId, storeData)
+        this.storeInfo = response.data
-        
+        return response
-        console.log('매장 수정 결과:', result)
-        
-        if (result.success) {
-          // 수정 성공 후 매장 정보 다시 조회
-          await this.fetchStoreInfo()
-          return result
-        } else {
-          this.error = result.message
-          return result
-        }
       } catch (error) {
-        console.error('매장 수정 실패:', error)
+        throw error
-        this.error = error.message
-        return { success: false, message: error.message || '매장 수정에 실패했습니다' }
       } finally {
         this.loading = false
       }
     },
+    
+    async createStoreInfo(storeData) {
+      try {
+        this.loading = true
+        const response = await storeService.createStoreInfo(storeData)
+        this.storeInfo = response.data
+        return response
+      } catch (error) {
+        throw error
+      } finally {
+        this.loading = false
+      }
+    }
+  }
+})
 
-    /**
+// 메뉴 스토어
-     * 매장 정보 초기화
+export const useMenuStore = defineStore('menu', {
-     */
+  state: () => ({
-    clearStoreInfo() {
+    menus: [],
-      this.storeInfo = null
+    loading: false,
-      this.error = null
+    totalCount: 0
-      this.loading = false
+  }),
+  
+  getters: {
+    getMenuById: (state) => (id) => {
+      return state.menus.find(menu => menu.id === id)
+    },
+    
+    getMenusByCategory: (state) => (category) => {
+      return state.menus.filter(menu => menu.category === category)
+    }
+  },
+  
+  actions: {
+    async fetchMenus() {
+      try {
+        this.loading = true
+        const response = await storeService.getMenus()
+        this.menus = response.data
+        this.totalCount = response.data.length
+        return response
+      } catch (error) {
+        throw error
+      } finally {
+        this.loading = false
+      }
+    },
+    
+    async createMenu(menuData) {
+      try {
+        this.loading = true
+        const response = await storeService.createMenu(menuData)
+        this.menus.push(response.data)
+        this.totalCount++
+        return response
+      } catch (error) {
+        throw error
+      } finally {
+        this.loading = false
+      }
+    },
+    
+    async updateMenu(menuId, menuData) {
+      try {
+        this.loading = true
+        const response = await storeService.updateMenu(menuId, menuData)
+        const index = this.menus.findIndex(menu => menu.id === menuId)
+        if (index !== -1) {
+          this.menus[index] = response.data
+        }
+        return response
+      } catch (error) {
+        throw error
+      } finally {
+        this.loading = false
+      }
+    },
+    
+    async deleteMenu(menuId) {
+      try {
+        this.loading = true
+        await storeService.deleteMenu(menuId)
+        this.menus = this.menus.filter(menu => menu.id !== menuId)
+        this.totalCount--
+      } catch (error) {
+        throw error
+      } finally {
+        this.loading = false
+      }
     }
   }
 })

src/store/store.js

@@ -1,266 +1,202 @@
-//* src/services/store.js - 백엔드 API 연동 수정
+//* src/store/store.js 수정 - 기존 구조 유지하고 API 연동만 추가
-import { storeApi, handleApiError, formatSuccessResponse } from './api.js'
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import storeService from '@/services/store'
 
-/**
+export const useStoreStore = defineStore('store', () => {
- * 매장 관련 API 서비스
+  // 기존 상태들 유지
- * 백엔드 Store Controller와 연동 (포트 8082)
+  const storeInfo = ref(null)
- */
+  const menus = ref([])
-class StoreService {
+  const salesData = ref(null)
-  /**
+  const isLoading = ref(false)
-   * 매장 등록 (STR-015: 매장 등록)
+
-   * @param {Object} storeData - 매장 정보
+  // 기존 computed 속성들 유지
-   * @returns {Promise<Object>} 매장 등록 결과
+  const hasStoreInfo = computed(() => !!storeInfo.value)
-   */
+  const menuCount = computed(() => menus.value?.length || 0)
-  async registerStore(storeData) {
+
+  // fetchStoreInfo를 실제 API 호출로 수정
+  const fetchStoreInfo = async () => {
+    if (import.meta.env.DEV) {
+      console.log('개발 모드: 매장 정보 API 호출 건너뛰기')
+      return { success: true }
+    }
+    
+    isLoading.value = true
+    
     try {
-      console.log('매장 등록 API 호출 - 요청 데이터:', storeData)
+      const result = await storeService.getStore()
       
-      // 백엔드 StoreCreateRequest에 맞는 형태로 변환
+      if (result.success) {
-      const requestData = {
+        storeInfo.value = result.data
-        storeName: storeData.storeName,
+        return { success: true }
-        businessType: storeData.businessType,
-        address: storeData.address,
-        phoneNumber: storeData.phoneNumber,
-        businessHours: storeData.businessHours || `${storeData.openTime}-${storeData.closeTime}`,
-        closedDays: Array.isArray(storeData.holidays) ? storeData.holidays.join(',') : storeData.closedDays,
-        seatCount: parseInt(storeData.seatCount) || 0,
-        snsAccounts: {
-          instagram: storeData.instagramUrl || '',
-          blog: storeData.blogUrl || ''
-        },
-        description: storeData.description || ''
-      }
-      
-      console.log('백엔드 전송 데이터:', requestData)
-      
-      const response = await storeApi.post('/register', requestData)
-      
-      console.log('매장 등록 API 응답:', response.data)
-      
-      // 백엔드 응답 구조에 맞게 처리
-      if (response.data.status === 200 || response.data.message?.includes('성공')) {
-        return formatSuccessResponse(response.data.data, response.data.message || '매장이 등록되었습니다.')
       } else {
-        throw new Error(response.data.message || '매장 등록에 실패했습니다.')
+        console.warn('매장 정보 조회 실패:', result.message)
+        return { success: false, error: result.message }
       }
     } catch (error) {
-      console.error('매장 등록 실패:', error)
+      console.warn('매장 정보 조회 실패:', error)
-      return handleApiError(error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
 
-  /**
+  // saveStoreInfo를 실제 API 호출로 수정
-   * 매장 정보 조회 (STR-005: 매장 정보 관리)
+  const saveStoreInfo = async (storeData) => {
-   * @returns {Promise<Object>} 매장 정보
+    isLoading.value = true
-   */
+    
-  async getStore() {
     try {
-      console.log('매장 정보 조회 API 호출')
+      let result
-      
+      if (storeInfo.value) {
-      const response = await storeApi.get('/')
+        // 기존 매장 정보 수정
-      
+        result = await storeService.updateStore(storeData)
-      console.log('매장 정보 조회 API 응답:', response.data)
-      
-      // 백엔드 응답 구조에 맞게 처리
-      if (response.data.status === 200 && response.data.data) {
-        return formatSuccessResponse(response.data.data, '매장 정보를 조회했습니다.')
-      } else if (response.data.data === null) {
-        // 매장이 없는 경우
-        return {
-          success: false,
-          message: '등록된 매장이 없습니다',
-          data: null
-        }
       } else {
-        throw new Error(response.data.message || '매장 정보를 찾을 수 없습니다.')
+        // 새 매장 등록
-      }
+        result = await storeService.registerStore(storeData)
-    } catch (error) {
-      console.error('매장 정보 조회 실패:', error)
-      
-      // 404 오류 처리 (매장이 없음)
-      if (error.response?.status === 404) {
-        return {
-          success: false,
-          message: '등록된 매장이 없습니다',
-          data: null
-        }
       }
       
-      // 500 오류 처리 (서버 내부 오류)
+      if (result.success) {
-      if (error.response?.status === 500) {
+        storeInfo.value = result.data
-        console.error('서버 내부 오류 - 백엔드 로그 확인 필요:', error.response?.data)
+        return { success: true, message: '매장 정보가 저장되었습니다.' }
-        return {
-          success: false,
-          message: '서버 오류가 발생했습니다. 관리자에게 문의하세요.',
-          data: null
-        }
-      }
-      
-      return handleApiError(error)
-    }
-  }
-
-  /**
-   * 매장 정보 수정 (STR-010: 매장 수정)
-   * @param {number} storeId - 매장 ID (현재는 사용하지 않음 - JWT에서 사용자 확인)
-   * @param {Object} storeData - 수정할 매장 정보
-   * @returns {Promise<Object>} 매장 수정 결과
-   */
-  async updateStore(storeId, storeData) {
-    try {
-      console.log('매장 정보 수정 API 호출 - 요청 데이터:', storeData)
-      
-      // 백엔드 StoreUpdateRequest에 맞는 형태로 변환
-      const requestData = {
-        storeName: storeData.storeName,
-        businessType: storeData.businessType,
-        address: storeData.address,
-        phoneNumber: storeData.phoneNumber,
-        businessHours: storeData.businessHours || `${storeData.openTime}-${storeData.closeTime}`,
-        closedDays: Array.isArray(storeData.holidays) ? storeData.holidays.join(',') : storeData.closedDays,
-        seatCount: parseInt(storeData.seatCount) || 0,
-        snsAccounts: {
-          instagram: storeData.instagramUrl || '',
-          blog: storeData.blogUrl || ''
-        },
-        description: storeData.description || ''
-      }
-      
-      console.log('백엔드 전송 데이터:', requestData)
-      
-      // PUT 요청 (storeId는 JWT에서 추출하므로 URL에 포함하지 않음)
-      const response = await storeApi.put('/', requestData)
-      
-      console.log('매장 정보 수정 API 응답:', response.data)
-      
-      if (response.data.status === 200 || response.data.message?.includes('성공')) {
-        return formatSuccessResponse(response.data.data, response.data.message || '매장 정보가 수정되었습니다.')
       } else {
-        throw new Error(response.data.message || '매장 정보 수정에 실패했습니다.')
+        return { success: false, error: result.message }
       }
     } catch (error) {
-      console.error('매장 정보 수정 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
-      return handleApiError(error)
+    } finally {
+      isLoading.value = false
     }
   }
 
-  /**
+  // fetchMenus를 실제 API 호출로 수정
-   * 매출 정보 조회 (STR-020: 대시보드)
+  const fetchMenus = async () => {
-   * @param {string} period - 조회 기간 (today, week, month, year)
+    if (!storeInfo.value?.storeId) {
-   * @returns {Promise<Object>} 매출 정보
+      console.warn('매장 ID가 없어 메뉴를 조회할 수 없습니다.')
-   */
+      return { success: false, error: '매장 정보가 필요합니다.' }
-  async getSales(period = 'today') {
+    }
+
+    isLoading.value = true
+    
     try {
-      // 현재는 목업 데이터 반환 (추후 실제 API 연동 시 수정)
+      const result = await storeService.getMenus(storeInfo.value.storeId)
-      const mockSalesData = {
+      
-        todaySales: 150000,
+      if (result.success) {
-        yesterdaySales: 120000,
+        menus.value = result.data
-        changeRate: 25.0,
+        return { success: true }
-        monthlyTarget: 3000000,
+      } else {
-        achievementRate: 45.2
+        return { success: false, error: result.message }
       }
-      
-      return formatSuccessResponse(mockSalesData, '매출 정보를 조회했습니다.')
     } catch (error) {
-      return handleApiError(error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
 
-  /**
+  // 메뉴 관련 메서드들 API 연동 추가
-   * 메뉴 등록 (STR-030: 메뉴 등록)
+  const saveMenu = async (menuData) => {
-   * @param {Object} menuData - 메뉴 정보
+    isLoading.value = true
-   * @returns {Promise<Object>} 메뉴 등록 결과
+    
-   */
-  async registerMenu(menuData) {
     try {
-      // 현재는 목업 처리 (추후 실제 API 연동 시 수정)
+      const result = await storeService.registerMenu(menuData)
-      console.log('메뉴 등록 - 목업 처리:', menuData)
       
-      const mockMenuResponse = {
+      if (result.success) {
-        id: Date.now(),
+        // 메뉴 목록 새로고침
-        ...menuData,
+        await fetchMenus()
-        createdAt: new Date().toISOString()
+        return { success: true, message: '메뉴가 등록되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
       }
-      
-      return formatSuccessResponse(mockMenuResponse, '메뉴가 등록되었습니다.')
     } catch (error) {
-      return handleApiError(error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
 
-  /**
+  const updateMenu = async (menuId, menuData) => {
-   * 메뉴 목록 조회 (STR-025: 메뉴 조회)
+    isLoading.value = true
-   * @returns {Promise<Object>} 메뉴 목록
+    
-   */
-  async getMenus() {
     try {
-      // 현재는 목업 데이터 반환 (추후 실제 API 연동 시 수정)
+      const result = await storeService.updateMenu(menuId, menuData)
-      const mockMenus = [
-        {
-          id: 1,
-          name: '김치찌개',
-          category: '찌개',
-          price: 8000,
-          description: '푸짐한 김치찌개',
-          imageUrl: '/images/menu-placeholder.png',
-          isPopular: true
-        },
-        {
-          id: 2,
-          name: '제육볶음',
-          category: '볶음',
-          price: 12000,
-          description: '매콤한 제육볶음',
-          imageUrl: '/images/menu-placeholder.png',
-          isRecommended: true
-        }
-      ]
       
-      return formatSuccessResponse(mockMenus, '메뉴 목록을 조회했습니다.')
+      if (result.success) {
-    } catch (error) {
+        // 메뉴 목록 새로고침
-      return handleApiError(error)
+        await fetchMenus()
-    }
+        return { success: true, message: '메뉴가 수정되었습니다.' }
-  }
+      } else {
-
+        return { success: false, error: result.message }
-  /**
-   * 메뉴 수정 (STR-035: 메뉴 수정)
-   * @param {number} menuId - 메뉴 ID
-   * @param {Object} menuData - 수정할 메뉴 정보
-   * @returns {Promise<Object>} 메뉴 수정 결과
-   */
-  async updateMenu(menuId, menuData) {
-    try {
-      // 현재는 목업 처리 (추후 실제 API 연동 시 수정)
-      console.log('메뉴 수정 - 목업 처리:', { menuId, menuData })
-      
-      const mockMenuResponse = {
-        id: menuId,
-        ...menuData,
-        updatedAt: new Date().toISOString()
       }
-      
-      return formatSuccessResponse(mockMenuResponse, '메뉴가 수정되었습니다.')
     } catch (error) {
-      return handleApiError(error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
 
-  /**
+  const deleteMenu = async (menuId) => {
-   * 메뉴 삭제 (STR-040: 메뉴 삭제)
+    isLoading.value = true
-   * @param {number} menuId - 삭제할 메뉴 ID
+    
-   * @returns {Promise<Object>} 메뉴 삭제 결과
-   */
-  async deleteMenu(menuId) {
     try {
-      // 현재는 목업 처리 (추후 실제 API 연동 시 수정)
+      const result = await storeService.deleteMenu(menuId)
-      console.log('메뉴 삭제 - 목업 처리:', menuId)
       
-      return formatSuccessResponse(null, '메뉴가 삭제되었습니다.')
+      if (result.success) {
+        // 메뉴 목록 새로고침
+        await fetchMenus()
+        return { success: true, message: '메뉴가 삭제되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
     } catch (error) {
-      return handleApiError(error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
-}
 
-export const storeService = new StoreService()
+  // 매출 정보 조회 추가
-export default storeService
+  const fetchSalesData = async () => {
+    if (!storeInfo.value?.storeId) {
+      return { success: false, error: '매장 정보가 필요합니다.' }
+    }
+
+    isLoading.value = true
+    
+    try {
+      const result = await storeService.getSales(storeInfo.value.storeId)
+      
+      if (result.success) {
+        salesData.value = result.data
+        return { success: true }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  return {
+    // 상태
+    storeInfo,
+    menus,
+    salesData,
+    isLoading,
+    
+    // 컴퓨티드
+    hasStoreInfo,
+    menuCount,
+    
+    // 메서드
+    fetchStoreInfo,
+    saveStoreInfo,
+    fetchMenus,
+    saveMenu,
+    updateMenu,
+    deleteMenu,
+    fetchSalesData
+  }
+})
+