Merge pull request #202 from AthennaIO/develop

feat: add whereHas method

Author: jlenon7

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/database",
-  "version": "5.23.0",
+  "version": "5.24.0",
   "description": "The Athenna database handler for SQL/NoSQL.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -77,7 +77,7 @@
   },
   "devDependencies": {
     "@athenna/artisan": "^5.6.0",
-    "@athenna/common": "^5.9.0",
+    "@athenna/common": "^5.10.0",
     "@athenna/config": "^5.3.0",
     "@athenna/ioc": "^5.1.0",
     "@athenna/logger": "^5.3.0",

package.json

@@ -512,6 +512,23 @@ export class ModelQueryBuilder<
     return this
   }
 
+  /**
+   * Only returns the data if the closure returns a result.
+   */
+  public whereHas<K extends ModelRelations<M>>(
+    relation: K | string,
+    closure: (
+      query: ModelQueryBuilder<
+        Extract<M[K] extends BaseModel[] ? M[K][0] : M[K], BaseModel>,
+        Driver
+      >
+    ) => any
+  ) {
+    this.schema.includeWhereHasRelation(relation, closure)
+
+    return this
+  }
+
   /**
    * Executes the given closure when the first argument is true.
    */

src/models/builders/ModelQueryBuilder.ts

@@ -128,6 +128,10 @@ export class ModelGenerator<M extends BaseModel = any> extends Macroable {
       model = await this.includeRelation(model, relation)
     }
 
+    if (!model) {
+      return undefined
+    }
+
     return model.setOriginal()
   }
 

src/models/factories/ModelGenerator.ts

@@ -42,6 +42,10 @@ export class BelongsToRelation {
       .when(relation.closure, relation.closure)
       .find()
 
+    if (relation.isWhereHasIncluded && !model[relation.property]) {
+      return undefined
+    }
+
     return model
   }
 
@@ -66,10 +70,16 @@ export class BelongsToRelation {
 
     results.forEach(result => map.set(result[relation.primaryKey], result))
 
-    return models.map(model => {
-      model[relation.property] = map.get(model[relation.foreignKey])
+    return models
+      .map(model => {
+        model[relation.property] = map.get(model[relation.foreignKey])
+
+        if (relation.isWhereHasIncluded && !model[relation.property]) {
+          return undefined
+        }
 
-      return model
-    })
+        return model
+      })
+      .filter(Boolean)
   }
 }

src/models/relations/BelongsTo/BelongsToRelation.ts

@@ -51,6 +51,10 @@ export class BelongsToManyRelation {
       .when(relation.closure, relation.closure)
       .findMany()
 
+    if (relation.isWhereHasIncluded && !model[relation.property]?.length) {
+      return undefined
+    }
+
     return model
   }
 
@@ -96,14 +100,20 @@ export class BelongsToManyRelation {
       map.set(result[relation.relationPrimaryKey], result)
     )
 
-    return models.map(model => {
-      const ids = pivotDataMap.get(model[relation.primaryKey]) || []
+    return models
+      .map(model => {
+        const ids = pivotDataMap.get(model[relation.primaryKey]) || []
 
-      model[relation.property] = ids
-        .map(id => map.get(id))
-        .filter(data => data !== undefined)
+        model[relation.property] = ids
+          .map(id => map.get(id))
+          .filter(data => data !== undefined)
 
-      return model
-    })
+        if (relation.isWhereHasIncluded && !model[relation.property]?.length) {
+          return undefined
+        }
+
+        return model
+      })
+      .filter(Boolean)
   }
 }

src/models/relations/BelongsToMany/BelongsToManyRelation.ts

@@ -25,6 +25,10 @@ export class HasManyRelation {
       .when(relation.closure, relation.closure)
       .findMany()
 
+    if (relation.isWhereHasIncluded && !model[relation.property]?.length) {
+      return undefined
+    }
+
     return model
   }
 
@@ -53,10 +57,16 @@ export class HasManyRelation {
       map.set(result[relation.foreignKey], array)
     })
 
-    return models.map(model => {
-      model[relation.property] = map.get(model[relation.primaryKey]) || []
+    return models
+      .map(model => {
+        model[relation.property] = map.get(model[relation.primaryKey]) || []
 
-      return model
-    })
+        if (relation.isWhereHasIncluded && !model[relation.property]?.length) {
+          return undefined
+        }
+
+        return model
+      })
+      .filter(Boolean)
   }
 }

src/models/relations/HasMany/HasManyRelation.ts

@@ -25,6 +25,10 @@ export class HasOneRelation {
       .when(relation.closure, relation.closure)
       .find()
 
+    if (relation.isWhereHasIncluded && !model[relation.property]) {
+      return undefined
+    }
+
     return model
   }
 
@@ -47,10 +51,16 @@ export class HasOneRelation {
 
     results.forEach(result => map.set(result[relation.foreignKey], result))
 
-    return models.map(model => {
-      model[relation.property] = map.get(model[relation.primaryKey])
+    return models
+      .map(model => {
+        model[relation.property] = map.get(model[relation.primaryKey])
+
+        if (relation.isWhereHasIncluded && !model[relation.property]) {
+          return undefined
+        }
 
-      return model
-    })
+        return model
+      })
+      .filter(Boolean)
   }
 }

src/models/relations/HasOne/HasOneRelation.ts

@@ -322,7 +322,7 @@ export class ModelSchema<M extends BaseModel = any> extends Macroable {
    * that are included.
    */
   public getIncludedRelations(): RelationOptions[] {
-    return this.relations.filter(r => r.isIncluded)
+    return this.relations.filter(r => r.isIncluded || r.isWhereHasIncluded)
   }
 
   /**
@@ -369,6 +369,43 @@ export class ModelSchema<M extends BaseModel = any> extends Macroable {
     return options
   }
 
+  /**
+   * Include a relation by setting the isWhereHasIncluded
+   * option to true.
+   */
+  public includeWhereHasRelation(
+    property: string | ModelRelations<M>,
+    closure?: (query: ModelQueryBuilder) => any
+  ) {
+    const model = this.Model.name
+
+    if (property.includes('.')) {
+      const [first, ...rest] = property.split('.')
+
+      property = first
+      closure = this.createdNestedRelationClosure(rest)
+    }
+
+    const options = this.getRelationByProperty(property)
+
+    if (!options) {
+      throw new NotImplementedRelationException(
+        property as string,
+        model,
+        this.relations.map(r => r.property).join(', ')
+      )
+    }
+
+    const i = this.relations.indexOf(options)
+
+    options.isWhereHasIncluded = true
+    options.closure = closure
+
+    this.relations[i] = options
+
+    return options
+  }
+
   /**
    * Created nested relationships closure to
    * load relationship's relationships

src/models/schemas/ModelSchema.ts

@@ -67,6 +67,16 @@ export type BelongsToManyOptions<
    */
   isIncluded?: boolean
 
+  /**
+   * Set if the model will be included when fetching
+   * data.
+   * If this option is true, you don't need to call
+   * methods like `whereHas()` to eager load your relation.
+   *
+   * @default false
+   */
+  isWhereHasIncluded?: boolean
+
   /**
    * The primary key is always the primary key
    * of the main model.