Support querying against hasMany relations using WHERE EXISTS.

Author: techniq

src/index.js

@@ -18,50 +18,6 @@ function getTable (resourceConfig) {
   return resourceConfig.table || underscore(resourceConfig.name)
 }
 
-/**
- * Lookup and apply table joins to query if field contains a `.`
- * @param {string} field - Field defined in where filter
- * @param {object} query - knex query to modify
- * @param {object} resourceConfig - Resource of primary query/table
- * @param {string[]} existingJoins - Array of fully qualitifed field names for
- *   any existing table joins for query
- * @returns {string} - field updated to perspective of applied joins
- */
-function applyTableJoins (field, query, resourceConfig, existingJoins) {
-  if (DSUtils.contains(field, '.')) {
-    let parts = field.split('.')
-    let localResourceConfig = resourceConfig
-
-    let relationPath = []
-    while (parts.length >= 2) {
-      let relationName = parts.shift()
-      let relationResourceConfig = resourceConfig.getResource(relationName)
-      relationPath.push(relationName)
-
-      if (!existingJoins.some(t => t === relationPath.join('.'))) {
-        let [relation] = localResourceConfig.relationList.filter(r => r.relation === relationName)
-        if (relation) {
-          let table = getTable(localResourceConfig)
-          let localId = `${table}.${relation.localKey}`
-
-          let relationTable = getTable(relationResourceConfig)
-          let foreignId = `${relationTable}.${relationResourceConfig.idAttribute}`
-
-          query.join(relationTable, localId, foreignId)
-          existingJoins.push(relationPath.join('.'))
-        } else {
-          // hopefully a qualified local column
-        }
-      }
-      localResourceConfig = relationResourceConfig
-    }
-
-    field = `${getTable(localResourceConfig)}.${parts[0]}`
-  }
-
-  return field
-}
-
 function loadWithRelations (items, resourceConfig, options) {
   let tasks = []
   let instance = Array.isArray(items) ? null : items
@@ -291,6 +247,7 @@ class DSSqlAdapter {
 
   filterQuery (resourceConfig, params, options) {
     let table = getTable(resourceConfig)
+    let joinedTables = []
     let query
 
     if (params instanceof Object.getPrototypeOf(this.query.client).QueryBuilder) {
@@ -308,8 +265,6 @@ class DSSqlAdapter {
     params.orderBy = params.orderBy || params.sort
     params.skip = params.skip || params.offset
 
-    let joinedTables = []
-
     DSUtils.forEach(DSUtils.keys(params), k => {
       let v = params[k]
       if (!DSUtils.contains(reserved, k)) {
@@ -331,16 +286,68 @@ class DSSqlAdapter {
             '==': criteria
           }
         }
-
-        DSUtils.forOwn(criteria, (v, op) => {
-          // Apply table joins (if needed)
+        
+        let processRelationField = (field) => {
+          let parts = field.split('.')
+          let localResourceConfig = resourceConfig
+          let relationPath = []
+          
+          while (parts.length >= 2) {
+            let relationName = parts.shift()
+            let relationResourceConfig = resourceConfig.getResource(relationName)
+            relationPath.push(relationName)
+
+            if (localResourceConfig.relationList) {
+              let [relation] = localResourceConfig.relationList.filter(r => r.relation === relationName)
+              if (relation) {
+                if (relation.type === 'belongsTo' || relation.type === 'hasOne') {
+                  // Apply table join for belongsTo/hasOne property (if not done already)
+                  if (!joinedTables.some(t => t === relationPath.join('.'))) {
+                    let table = getTable(localResourceConfig)
+                    let localId = `${table}.${relation.localKey}`
+
+                    let relationTable = getTable(relationResourceConfig)
+                    let foreignId = `${relationTable}.${relationResourceConfig.idAttribute}`
+
+                    query.join(relationTable, localId, foreignId)
+                    joinedTables.push(relationPath.join('.'))
+                  }
+                } else if (relation.type === 'hasMany') {
+                  // Perform `WHERE EXISTS` subquery for hasMany property
+                  let table = getTable(localResourceConfig)
+                  let localId = `${table}.${localResourceConfig.idAttribute}`
+
+                  let relationTable = getTable(relationResourceConfig)
+                  let foreignId = `${relationTable}.${relation.foreignKey}`
+
+                  let existsParams = {
+                    [foreignId]: {'===': knex.raw(localId)},
+                    [parts[0]]: criteria
+                  };
+                  query.whereExists(this.filterQuery(relationResourceConfig, existsParams, options));
+                  criteria = null; // criteria handled by EXISTS subquery
+                }
+              } else {
+                // hopefully a qualified local column
+              }
+              
+              localResourceConfig = relationResourceConfig
+            } 
+          }
+          
+          return `${getTable(localResourceConfig)}.${parts[0]}`
+        }
+        
+        if (DSUtils.contains(field, '.')) {
           if (DSUtils.contains(field, ',')) {
             let splitFields = field.split(',').map(c => c.trim())
-            field = splitFields.map(splitField => applyTableJoins(splitField, query, resourceConfig, joinedTables)).join(',')
+            field = splitFields.map(splitField => processRelationField(splitField)).join(',')
           } else {
-            field = applyTableJoins(field, query, resourceConfig, joinedTables)
+            field = processRelationField(field, query, resourceConfig, joinedTables)
           }
-
+        }
+        
+        DSUtils.forOwn(criteria, (v, op) => {
           if (op === '==' || op === '===') {
             if (v === null) {
               query = query.whereNull(field)

test/findAll.spec.js

@@ -45,6 +45,26 @@ describe('DSSqlAdapter#findAll', function () {
     assert.equal(posts[1].content, 'bar');
     assert.equal(posts[2].content, 'baz');
   });
+  
+  it('should filter using a hasMany relation', function* () {
+    let user1 = yield adapter.create(User, {name: 'Sean'});
+    let post1 = yield adapter.create(Post, {userId: user1.id, content: 'foo'});
+    let post2 = yield adapter.create(Post, {userId: user1.id, content: 'bar'});
+    let post3 = yield adapter.create(Post, {userId: user1.id, content: 'baz'});
+    
+    let user2 = yield adapter.create(User, {name: 'Jason'});
+    let post4 = yield adapter.create(Post, {userId: user2.id, content: 'foo'});
+    let post5 = yield adapter.create(Post, {userId: user2.id, content: 'bar'});
+    
+    let user3 = yield adapter.create(User, {name: 'Ed'});
+    let post6 = yield adapter.create(Post, {userId: user3.id, content: 'bar'});
+    let post7 = yield adapter.create(Post, {userId: user3.id, content: 'baz'});
+
+    let users = yield adapter.findAll(User, {where: {'post.content': {'==': 'foo'} }});
+    assert.equal(users.length, 2);
+    assert.equal(users[0].name, 'Sean');
+    assert.equal(users[1].name, 'Jason');
+  });
 
   describe('near', function () {
     beforeEach(function * () {