:recycle: using destructured dispatch to pass api limits

vue-theme/src/components/sidebars/events.vue

         async getPosts() {
             const upcoming = this.$store.dispatch(
                 `getAllEvents`,
-                sortTypes.currentAndUpcoming,
+                {
+                    sortType: sortTypes.currentAndUpcoming
+                }
             )
             if (upcoming.length < 1) {
                 // this.listType = 'past'

vue-theme/src/pages/index.vue

 
             // Limit the amount of posts because we
             // only need the most recent
-            const paramLimit = { limit: 1 }
-
+            const params = { limit: 1 }
+            console.log(action)
             // We try and fetch EVERYTHING except
             // for EVENTS and EXHIBITIONS
             if (!omit.includes(type)) {
-                this.$store.dispatch(action, null, paramLimit)
+                this.$store.dispatch(action, { sortType: null, params })
             } else {
                 // Only grab the current or upcoming on load
                 const eventsOrExhibitions = await this.$store.dispatch(
                     action,
-                    sortTypes.currentAndUpcoming,
+                    { 
+                        sortType: sortTypes.currentAndUpcoming,
+                        params
+                    }
                 )
                 // If no current or upcoming, get past events
                 // to fill in the blanks
                 if (eventsOrExhibitions.length < 1) {
-                    this.$store.dispatch(action, sortTypes.past, paramLimit)
+                    this.$store.dispatch(action, { sortType: sortTypes.past, params })
                 }
             }
         }

vue-theme/src/pages/list.vue

 
             // Don't dispatch if there's no type
             if (this.type && this.dispatchName) {
-                this.$store.dispatch(this.dispatchName, sort, params)
+                this.$store.dispatch(this.dispatchName, { sortType: sort, params })
 
                 if (this.type == 'event') {
                     this.$store.dispatch(
                         'getAllExhibitions',
-                        sortTypes.currentAndUpcoming,
-                        params
+                        {
+                            sortType: sortTypes.currentAndUpcoming,
+                            params 
+                        }
                     )
                 }
                 if (this.type == 'exhibition') {
                     this.$store.dispatch(
                         'getAllEvents',
-                        sortTypes.currentAndUpcoming,
-                        params
+                        {
+                            sortType: sortTypes.currentAndUpcoming,
+                            params 
+                        }
                     )
                 }
             }
             const page = this.allPages.filter(
                 page => page.slug == type + 's',
             )[0]
+            const blankHero = { url: null, heroType: null }
+            // Clear the hero and bail
+            if(!page) return this.$store.commit('SET_HERO', blankHero)
 
-            let json = { url: page.featured, heroType: 'image' }
+            blankHero.url = page.featured
+            blankHero.heroType = 'image'
+            let json = hero = blankHero
             if (
                 page.hero &&
                 JSON.parse(page.hero) &&

vue-theme/src/store/modules/artist.js

 }
 
 const actions = {
-    getAllArtists({ commit }, sortType, params) {
+    getAllArtists({ commit }, { sortType, params }) {
         commit('CLEAR_ARTISTS')
         commit('ARTISTS_LOADED', false)
-        return api.getByType('artist', sortType, artists => {
+        const storeFetch = (artists => {
             commit('STORE_FETCHED_ARTISTS', { artists })
             commit('ARTISTS_LOADED', true)
-        }, params)
+        })
+        return api.getByType({ type: 'artist', sort: sortType, params, cb: storeFetch })
     },
     getSingleArtist({ commit }, id) {
         commit('CLEAR_SINGLE_ARTISTS')

vue-theme/src/store/modules/episode.js

     getAllEpisodes({ commit }, sortType) {
         commit('CLEAR_EPISODES')
         commit('EPISODES_LOADED', false)
-        return api.getByType('episode', sortType, episodes => {
-            commit('STORE_FETCHED_EPISODES', { episodes })
-            commit('EPISODES_LOADED', true)
+        return api.getByType({ type: 'episode', sort: sortType, cb: episodes => {
+                commit('STORE_FETCHED_EPISODES', { episodes })
+                commit('EPISODES_LOADED', true)
+            }
         })
     },
     getSingleEpisode({ commit }, id) {

vue-theme/src/store/modules/event.js

 }
 
 const actions = {
-    getAllEvents({ commit }, sortType, params) {
+    getAllEvents({ commit }, { sortType, params }) {
         commit('CLEAR_EVENTS')
         commit('EVENTS_LOADED', false)
-        return api.getByType('event', sortType, events => {
+        return api.getByType({ type: 'event', sort: sortType, cb: events => {
             commit('STORE_FETCHED_EVENTS', { events })
             commit('EVENTS_LOADED', true)
-        }, params)
+        }, params })
     },
     getSingleEvent({ commit }, id) {
         commit('CLEAR_SINGLE_EVENTS')

vue-theme/src/store/modules/exhibition.js

 }
 
 const actions = {
-    getAllExhibitions({ commit }, sortType, params) {
+    getAllExhibitions({ commit },{ sortType, params }) {
         commit('CLEAR_EXHIBITIONS')
         commit('EXHIBITIONS_LOADED', false)
-        return api.getByType('exhibition', sortType, exhibitions => {
+        return api.getByType({ type: 'exhibition', sort: sortType, cb: exhibitions => {
             commit('STORE_FETCHED_EXHIBITIONS', { exhibitions })
             commit('EXHIBITIONS_LOADED', true)
-        }, params)
+        }, params })
     },
     getSingleExhibition({ commit }, id) {
         commit('CLEAR_SINGLE_EXHIBITIONS')

vue-theme/src/store/modules/page.js

 const actions = {
     async getAllPages({ commit }, sortType) {
         commit('PAGES_LOADED', false)
-        return await api.getByType('page', sortType, pages => {
-            commit('STORE_FETCHED_PAGES', { pages })
-            commit('PAGES_LOADED', true)
+        return await api.getByType({ type: 'page', sort: sortType, cb: pages => {
+                commit('STORE_FETCHED_PAGES', { pages })
+                commit('PAGES_LOADED', true)
+            }
         })
     },
     getSinglePage({ commit }, id) {

vue-theme/src/store/modules/post.js

 }
 
 const actions = {
-    getAllPosts({ commit }, sortType, params) {
+    getAllPosts({ commit },{ sortType, params }) {
         commit('CLEAR_POSTS')
         commit('POSTS_LOADED', false)
-        return api.getByType('post', sortType, posts => {
+        return api.getByType({ type: 'post', sort: sortType, cb: posts => {
             commit('STORE_FETCHED_POSTS', { posts })
             commit('POSTS_LOADED', true)
-        }, params)
+        }, params })
     },
     getSinglePost({ commit }, id) {
         commit('CLEAR_SINGLE_POSTS')

vue-theme/src/utils/api.js

 }
 
 export default {
-    getByType(type, sortType, cb, params) {
-        if (sortType && Object.values(sortTypes).includes(sortType)) {
+    getByType({ type, sort, params, cb }) {
+        let query = params && params.limit ? `?limit=${params.limit}`: ''
+        console.log('params')
+        console.log(params)
+        if (sort && Object.values(sortTypes).includes(sort)) {
             return axios
-                .get(SETTINGS.API_BASE_PATH + `sort/${type}/${sortType}`)
+                .get(SETTINGS.API_BASE_PATH + `sort/${type}/${sort}${query}`)
                 .then(response => {
                     cb(response.data)
                     return response.data
                     cb(e)
                 })
         } else {
-            let query = `${type}`
-            if(params && params.limit) {
-                query = `${type}?limit=${params.limit}`
-            }
             return axios
-                .get(SETTINGS.API_BASE_PATH + query)
+                .get(SETTINGS.API_BASE_PATH + `${type}${query}`)
                 .then(response => {
                     cb(response.data)
                     return response.data