chore: tidy up code

Author: cuebit

src/mixins/Actions.ts

@@ -6,7 +6,7 @@ export default function Actions(
   actions: ActionsContract
 ): void {
   /**
-   * Trash records and persist to the store.
+   * Soft delete records and persist to the store.
    */
   actions.softDelete = async (
     context: ActionContext,

src/mixins/Query.ts

@@ -7,15 +7,15 @@ export default function Query(
   query: typeof BaseQuery
 ): void {
   /**
-   * Determine if trashed records should be filtered exclusively.
-   *   true  = only trashed records
-   *   false = include trashed records
-   *   null  = exclude trashed records
+   * Determine if soft deleted models should be filtered exclusively.
+   *   true  = only soft deletes
+   *   false = include soft deletes
+   *   null  = exclude soft deletes
    */
   query.prototype.softDeletesFilter = null
 
   /**
-   * Constraint includes trashed records.
+   * Constraint includes soft deleted models.
    */
   query.prototype.withTrashed = function() {
     this.softDeletesFilter = false
@@ -24,7 +24,7 @@ export default function Query(
   }
 
   /**
-   * Constraint restricts to only trashed records.
+   * Constraint restricts to only soft deleted models.
    */
   query.prototype.onlyTrashed = function() {
     this.softDeletesFilter = true
@@ -48,28 +48,28 @@ export default function Query(
   }
 
   /**
-   * Process the record(s) to be trashed.
-   * The method expects the condition to be a single or collection of a primary
-   * key, a single or collection of a composite key, or a expression closure.
+   * Process the model(s) to be soft deleted.
    */
   query.prototype.softDelete = function(condition: any) {
-    const config = context.createConfig(this.model.softDeleteConfig)
+    const { key, flagName, mutator } = context.createConfig(
+      this.model.softDeleteConfig
+    )
 
     let value = Date.now()
 
-    value = typeof config.mutator === 'function' ? config.mutator(value) : value
+    value = typeof mutator === 'function' ? mutator(value) : value
 
     const data = {
-      [config.key]: value,
-      [config.flagName]: true
+      [key]: value,
+      [flagName]: true
     }
 
     if (Array.isArray(condition)) {
       // Array of primary keys
       if (!this.model.isCompositePrimaryKey()) {
         return this.model.update({
           data,
-          where: (r) => condition.includes(r[r.$primaryKey()])
+          where: (record) => condition.includes(record[record.$primaryKey()])
         })
       }
 
@@ -86,21 +86,20 @@ export default function Query(
       }
     }
 
-    return this.model.update({
-      data,
-      where: condition as any
-    })
+    return this.model.update({ data, where: condition })
   }
 
   /**
-   * Fetch all trashed records from the store.
+   * Fetch all soft deletes from the store.
    */
   query.prototype.allTrashed = function() {
-    return this.onlyTrashed().get()
+    return this.newQuery()
+      .onlyTrashed()
+      .get()
   }
 
   /**
-   * Fetch all trashed records from the store and group by entity.
+   * Fetch all soft deletes from the store and group by entity.
    */
   query.allTrashed = function(store) {
     const database = store.$db()
@@ -113,25 +112,25 @@ export default function Query(
   }
 
   /**
-   * Global select hook prevents trashed records from being selected unless
+   * Global select hook prevents soft deleted models from being selected unless
    * queries are explicity chained with `withTrashed` or `onlyTrashed`.
    */
   query.on('beforeSelect', function<T extends BaseQuery>(
     this: T,
     models: Data.Collection
   ) {
     return models.filter((model) => {
-      // Only trashed records
+      // Only soft deletes
       if (this.softDeletesFilter === true) {
         return model.$trashed()
       }
 
-      // Include trashed records
+      // Include soft deletes
       if (this.softDeletesFilter === false) {
         return models
       }
 
-      // Exclude trashed records
+      // Exclude soft deletes
       return !model.$trashed()
     })
   })

src/mixins/RootActions.ts

@@ -7,12 +7,12 @@ import {
 
 export default function RootActions(
   context: VuexORMSoftDelete,
-  actions: RootActionsContract
+  rootActions: RootActionsContract
 ): void {
   /**
-   * Trash records and persist the store.
+   * Soft delete records and persist the store.
    */
-  actions.softDelete = async function(
+  rootActions.softDelete = async function(
     this: Store<any>,
     _context: RootActionContext,
     payload: any

test/feature/VuexORMSoftDelete.spec.ts

@@ -5,9 +5,6 @@ describe('Feature - Vuex ORM Soft Delete', () => {
   it('should have `key` and `flagName` attributes on new', async () => {
     class User extends Model {
       static entity = 'users'
-
-      deleted_at!: number
-      $isDeleted!: boolean
     }
 
     createStore([User])

test/feature/model/Delete.spec.ts

@@ -173,7 +173,7 @@ describe('Feature - Model - Delete', () => {
       ]
     })
 
-    await User.softDelete((record: any) => record.age >= 20)
+    await User.softDelete((record: User) => record.age >= 20)
 
     const expected = createState({
       users: {
@@ -263,6 +263,7 @@ describe('Feature - Model - Delete', () => {
         }
       }
 
+      posts!: Post[]
       deleted_at!: number
       $isDeleted!: boolean
     }
@@ -288,14 +289,16 @@ describe('Feature - Model - Delete', () => {
 
     expect(user.$isDeleted).toBe(false)
     expect(user.deleted_at).toBe(null)
+    expect(user.posts).not.toEqual([])
 
     await user.$softDelete()
 
     expect(user.$isDeleted).toBe(true)
     expect(user.deleted_at).toBe(mockDate)
+    expect(user.posts).not.toEqual([])
   })
 
-  it('should hydrate instance after deleting', async () => {
+  it('can hydrate instance after deleting', async () => {
     class User extends Model {
       static entity = 'users'
 

test/feature/module/Delete.spec.ts

@@ -177,7 +177,7 @@ describe('Feature - Module - Delete', () => {
 
     await store.dispatch(
       'entities/users/softDelete',
-      (record: any) => record.age >= 20
+      (record: User) => record.age >= 20
     )
 
     const expected = createState({