refactor: structure module mixins

Author: cuebit

src/VuexORMSoftDelete.ts

@@ -2,10 +2,13 @@ import { Model, Query } from '@vuex-orm/core'
 import Components from './contracts/Components'
 import Config from './contracts/Config'
 import Options from './contracts/Options'
-import Modules from './contracts/Modules'
+import * as Store from './contracts/Store'
 import ModelMixin from './mixins/Model'
 import QueryMixin from './mixins/Query'
-import ModulesMixin from './mixins/Modules'
+import ActionsMixin from './mixins/Actions'
+import GettersMixin from './mixins/Getters'
+import RootActionsMixin from './mixins/RootActions'
+import RootGettersMixin from './mixins/RootGetters'
 import GlobalConfig from './config/GlobalConfig'
 
 export default class VuexORMSoftDelete {
@@ -20,9 +23,24 @@ export default class VuexORMSoftDelete {
   query: typeof Query
 
   /**
-   * The module components.
+   * The store action tree.
    */
-  modules: Modules
+  actions: Store.Actions
+
+  /**
+   * The store action tree.
+   */
+  getters: Store.Getters
+
+  /**
+   * The store action tree.
+   */
+  rootGetters: Store.RootGetters
+
+  /**
+   * The store action tree.
+   */
+  rootActions: Store.RootActions
 
   /**
    * The global configuration object.
@@ -36,12 +54,10 @@ export default class VuexORMSoftDelete {
     this.model = components.Model
     this.query = components.Query
 
-    this.modules = {
-      actions: components.Actions,
-      getters: components.Getters,
-      rootGetters: components.RootGetters,
-      rootActions: components.RootActions
-    }
+    this.actions = components.Actions
+    this.getters = components.Getters
+    this.rootActions = components.RootActions
+    this.rootGetters = components.RootGetters
 
     this.config = this.createConfig(config)
   }
@@ -64,6 +80,9 @@ export default class VuexORMSoftDelete {
   plugin(): void {
     ModelMixin(this, this.model)
     QueryMixin(this, this.query)
-    ModulesMixin(this, this.modules)
+    ActionsMixin(this, this.actions)
+    GettersMixin(this, this.getters)
+    RootActionsMixin(this, this.rootActions)
+    RootGettersMixin(this, this.rootGetters)
   }
 }

src/contracts/Components.ts

@@ -1,5 +1,5 @@
 import { Model, Query } from '@vuex-orm/core'
-import { Actions, Getters, RootGetters, RootActions } from './Modules'
+import { Actions, Getters, RootGetters, RootActions } from './Store'
 
 export interface Components {
   Model: typeof Model

src/contracts/Modules.ts renamed to src/contracts/Store.ts

@@ -17,12 +17,3 @@ export {
   State,
   RootState
 }
-
-export interface Modules {
-  actions: Actions
-  getters: Getters
-  rootGetters: RootGetters
-  rootActions: RootActions
-}
-
-export default Modules

src/mixins/Actions.ts

@@ -0,0 +1,25 @@
+import VuexORMSoftDelete from '../VuexORMSoftDelete'
+import { Actions as ActionsContract, ActionContext } from '../contracts/Store'
+
+export default function Actions(
+  _context: VuexORMSoftDelete,
+  actions: ActionsContract
+): void {
+  /**
+   * Trash records and persist to the store.
+   */
+  actions.softDelete = async (
+    context: ActionContext,
+    payload: any
+  ): Promise<any> => {
+    const state = context.state
+    const entity = state.$name
+    const where = payload.where ?? payload
+
+    return context.dispatch(
+      `${state.$connection}/softDelete`,
+      { entity, where },
+      { root: true }
+    )
+  }
+}

src/mixins/Getters.ts

@@ -0,0 +1,24 @@
+import VuexORMSoftDelete from '../VuexORMSoftDelete'
+import { Collection } from '../contracts/Data'
+import {
+  Getters as GettersContract,
+  State,
+  RootState
+} from '../contracts/Store'
+
+export default function Getters(
+  _context: VuexORMSoftDelete,
+  getters: GettersContract
+): void {
+  /**
+   * Get all trashed records from the store and group by entity.
+   */
+  getters.allTrashed = (
+    state: State,
+    _getters: any,
+    _rootState: RootState,
+    rootGetters: any
+  ) => (): Collection => {
+    return rootGetters[`${state.$connection}/allTrashed`](state.$name)
+  }
+}

src/mixins/Modules.ts

@@ -0,0 +1,24 @@
+import { Store } from 'vuex'
+import VuexORMSoftDelete from '../VuexORMSoftDelete'
+import {
+  RootActions as RootActionsContract,
+  RootActionContext
+} from '../contracts/Store'
+
+export default function RootActions(
+  context: VuexORMSoftDelete,
+  actions: RootActionsContract
+): void {
+  /**
+   * Trash records and persist the store.
+   */
+  actions.softDelete = async function(
+    this: Store<any>,
+    _context: RootActionContext,
+    payload: any
+  ): Promise<any> {
+    const { entity, where } = payload
+
+    return new context.query(this, entity).softDelete(where)
+  }
+}

src/mixins/RootActions.ts

@@ -0,0 +1,25 @@
+import { Store } from 'vuex'
+import VuexORMSoftDelete from '../VuexORMSoftDelete'
+import { Collection, Collections } from '../contracts/Data'
+import {
+  RootGetters as RootGettersContract,
+  RootState
+} from '../contracts/Store'
+
+export default function RootGetters(
+  context: VuexORMSoftDelete,
+  rootGetters: RootGettersContract
+): void {
+  /**
+   * Get all trashed records belonging to an entity.
+   */
+  rootGetters.allTrashed = function(this: Store<any>, _state: RootState) {
+    return (entity?: string): Collection | Collections => {
+      if (entity) {
+        return new context.query(this, entity).allTrashed()
+      }
+
+      return context.query.allTrashed(this)
+    }
+  }
+}

src/mixins/RootGetters.ts

@@ -14,18 +14,11 @@ declare module '@vuex-orm/core' {
     /**
      * Process the record being trashed.
      */
-    export function softDelete<T extends typeof Model>(
-      this: T,
-      condition: PrimaryKey
-    ): Promise<Data.Item>
-    export function softDelete<T extends typeof Model>(
-      this: T,
-      condition: Predicate<Model>
-    ): Promise<Data.Collection>
-    export function softDelete<T extends typeof Model>(
-      this: T,
-      condition: any
-    ): Promise<any>
+    export function softDelete(condition: PrimaryKey): Promise<Data.Item>
+    export function softDelete(condition: Predicate): Promise<Data.Collection>
+    export function softDelete(condition: any): Promise<any>
+
+    export function restore(payload: any): Promise<any>
   }
 
   interface Model {
@@ -63,7 +56,7 @@ declare module '@vuex-orm/core' {
      * Process the record(s) to be trashed.
      */
     softDelete(condition: PrimaryKey): Promise<Data.Collections>
-    softDelete(condition: Predicate<Model>): Promise<Data.Collections>
+    softDelete(condition: Predicate): Promise<Data.Collections>
     softDelete(condition: any): any
 
     /**