feat: support relations

Author: cuebit

src/mixins/Query.ts

@@ -12,13 +12,13 @@ export default function Query(
    *   false = include soft deletes
    *   null  = exclude soft deletes
    */
-  query.prototype.softDeletesFilter = null
+  query.prototype.softDeleteSelectFilter = null
 
   /**
    * Constraint includes soft deleted models.
    */
   query.prototype.withTrashed = function() {
-    this.softDeletesFilter = false
+    this.softDeleteSelectFilter = false
 
     return this
   }
@@ -27,7 +27,7 @@ export default function Query(
    * Constraint restricts to only soft deleted models.
    */
   query.prototype.onlyTrashed = function() {
-    this.softDeletesFilter = true
+    this.softDeleteSelectFilter = true
 
     return this
   }
@@ -98,6 +98,40 @@ export default function Query(
       .get()
   }
 
+  /**
+   * Patch any new queries so that sub queries, such as relation queries,
+   * can respect top level modifiers. For many-to-many relations, due to core
+   * API limitations, we're forced to pass-through intermediate models.
+   */
+  const newQuery = query.prototype.newQuery
+
+  query.prototype.newQuery = function(entity?) {
+    const patchedQuery = newQuery.call(this, entity)
+
+    // Only patch queries that are loading relations.
+    const loadables = Object.keys(this.load)
+
+    if (loadables.length > 0) {
+      patchedQuery.softDeleteSelectFilter = this.softDeleteSelectFilter
+
+      if (entity && entity !== this.entity && this.model.hasPivotFields()) {
+        const fields = this.model.pivotFields().reduce((fields, field) => {
+          Object.keys(field).filter((entity) => loadables.includes(entity)).forEach((entity) => {
+            fields.push(field[entity].pivot.entity)
+          })
+          return fields
+        }, [] as string[])
+
+        // Release an entity that is an intermediate to a loadable relation.
+        if (fields.includes(entity)) {
+          patchedQuery.softDeleteSelectFilter = false
+        }
+      }
+    }
+
+    return patchedQuery
+  }
+
   /**
    * Fetch all soft deletes from the store and group by entity.
    */
@@ -121,12 +155,12 @@ export default function Query(
   ) {
     return models.filter((model) => {
       // Only soft deletes
-      if (this.softDeletesFilter === true) {
+      if (this.softDeleteSelectFilter === true) {
         return model.$trashed()
       }
 
       // Include soft deletes
-      if (this.softDeletesFilter === false) {
+      if (this.softDeleteSelectFilter === false) {
         return models
       }
 

src/types/vuex-orm.ts

@@ -53,7 +53,7 @@ declare module '@vuex-orm/core' {
     /**
      * Filtering mode for the query builder.
      */
-    softDeletesFilter: boolean | null
+    softDeleteSelectFilter: boolean | null
 
     /**
      * Process the model(s) to be soft deleted.

test/feature/relations/BelongsTo.spec.ts

@@ -0,0 +1,73 @@
+import { createStore } from 'test/support/Helpers'
+import { Model } from '@vuex-orm/core'
+
+describe('Feature - Relations - Belongs To', () => {
+  class User extends Model {
+    static entity = 'users'
+
+    static fields() {
+      return {
+        id: this.attr(null)
+      }
+    }
+  }
+
+  class Post extends Model {
+    static entity = 'posts'
+
+    static fields() {
+      return {
+        id: this.attr(null),
+        user_id: this.attr(null),
+        user: this.belongsTo(User, 'user_id')
+      }
+    }
+
+    user!: User
+  }
+
+  beforeEach(async () => {
+    createStore([User, Post])
+
+    await Post.create({
+      data: {
+        id: 1,
+        user: { id: 1 }
+      }
+    })
+  })
+
+  it('can resolve queries without deleted relations (default)', async () => {
+    await User.softDelete(1)
+
+    const post = Post.query()
+      .with('user')
+      .find(1) as Post
+
+    expect(post.user).toBeNull()
+  })
+
+  it('can include deleted relations using `withTrashed` clause', async () => {
+    await User.softDelete(1)
+
+    const post = Post.query()
+      .withTrashed()
+      .with('user')
+      .find(1) as Post
+
+    expect(post.user).toBeInstanceOf(User)
+    expect(post.user.$trashed()).toBe(true)
+  })
+
+  it('can resolve only deleted relations using `onlyTrashed` clause', async () => {
+    await User.softDelete(1)
+
+    const post = Post.query()
+      .onlyTrashed()
+      .with('user')
+      .find(1) as Post
+
+    expect(post.user).toBeInstanceOf(User)
+    expect(post.user.$trashed()).toBe(true)
+  })
+})

test/feature/relations/BelongsToMany.spec.ts

@@ -0,0 +1,95 @@
+import { createStore } from 'test/support/Helpers'
+import { Model } from '@vuex-orm/core'
+
+describe('Feature - Relations - Belongs To Many', () => {
+  class User extends Model {
+    static entity = 'users'
+
+    static fields() {
+      return {
+        id: this.attr(null),
+        roles: this.belongsToMany(Role, RoleUser, 'user_id', 'role_id')
+      }
+    }
+
+    roles!: Role[]
+  }
+
+  class Role extends Model {
+    static entity = 'roles'
+
+    static fields() {
+      return {
+        id: this.attr(null)
+      }
+    }
+  }
+
+  class RoleUser extends Model {
+    static entity = 'roleUser'
+
+    static primaryKey = ['role_id', 'user_id']
+
+    static fields() {
+      return {
+        role_id: this.attr(null),
+        user_id: this.attr(null)
+      }
+    }
+  }
+
+  beforeEach(async () => {
+    createStore([User, Role, RoleUser])
+
+    await User.create({
+      data: [
+        { id: 1, roles: [{ id: 3 }, { id: 4 }] },
+        { id: 2, roles: [{ id: 3 }] }
+      ]
+    })
+  })
+
+  it('can resolve queries without deleted relation (default)', async () => {
+    await Role.softDelete(3)
+
+    const users = User.query()
+      .with('roles')
+      .findIn([1, 2]) as User[]
+
+    expect(users[0].roles.length).toBe(1)
+    expect(users[0].roles[0].$trashed()).toBe(false)
+
+    expect(users[1].roles.length).toBe(0)
+  })
+
+  it('can include deleted relations using `withTrashed` clause', async () => {
+    await Role.softDelete(3)
+
+    const users = User.query()
+      .withTrashed()
+      .with('roles')
+      .findIn([1, 2]) as User[]
+
+    expect(users[0].roles.length).toBe(2)
+    expect(users[0].roles[0].$trashed()).toBe(true)
+    expect(users[0].roles[1].$trashed()).toBe(false)
+
+    expect(users[1].roles.length).toBe(1)
+    expect(users[1].roles[0].$trashed()).toBe(true)
+  })
+
+  it('can resolve only deleted relations using `onlyTrashed` clause', async () => {
+    await Role.softDelete(3)
+
+    const users = User.query()
+      .onlyTrashed()
+      .with('roles')
+      .findIn([1, 2]) as User[]
+
+    expect(users[0].roles.length).toBe(1)
+    expect(users[0].roles[0].$trashed()).toBe(true)
+
+    expect(users[1].roles.length).toBe(1)
+    expect(users[1].roles[0].$trashed()).toBe(true)
+  })
+})

test/feature/relations/HasMany.spec.ts

@@ -0,0 +1,75 @@
+import { createStore } from 'test/support/Helpers'
+import { Model } from '@vuex-orm/core'
+
+describe('Feature - Relations - Has Many', () => {
+  class User extends Model {
+    static entity = 'users'
+
+    static fields() {
+      return {
+        id: this.attr(null),
+        posts: this.hasMany(Post, 'user_id')
+      }
+    }
+
+    posts!: Post[]
+  }
+
+  class Post extends Model {
+    static entity = 'posts'
+
+    static fields() {
+      return {
+        id: this.attr(null),
+        user_id: this.attr(null)
+      }
+    }
+  }
+
+  beforeEach(async () => {
+    createStore([User, Post])
+
+    await User.create({
+      data: {
+        id: 1,
+        posts: [{ id: 1 }, { id: 2 }]
+      }
+    })
+  })
+
+  it('can resolve queries without deleted relations (default)', async () => {
+    await Post.softDelete(1)
+
+    const user = User.query()
+      .with('posts')
+      .find(1) as User
+
+    expect(user.posts.length).toBe(1)
+    expect(user.posts[0].$trashed()).toBe(false)
+  })
+
+  it('can include deleted relations using `withTrashed` clause', async () => {
+    await Post.softDelete(1)
+
+    const user = User.query()
+      .withTrashed()
+      .with('posts')
+      .find(1) as User
+
+    expect(user.posts.length).toBe(2)
+    expect(user.posts[0].$trashed()).toBe(true)
+    expect(user.posts[1].$trashed()).toBe(false)
+  })
+
+  it('can resolve only deleted relations using `onlyTrashed` clause', async () => {
+    await Post.softDelete(1)
+
+    const user = User.query()
+      .onlyTrashed()
+      .with('posts')
+      .find(1) as User
+
+    expect(user.posts.length).toBe(1)
+    expect(user.posts[0].$trashed()).toBe(true)
+  })
+})