WIP

CHANGELOG.md

@@ -12,6 +12,10 @@
 
 ---
 
+## [v0.6.0](https://github.com/foxifyjs/odin/releases/tag/v0.6.0) - *(2018-12-04)*
+
+- :zap: Added `has` to model queries (use with caution since it may have a negative impact on your performance)
+
 ## [v0.5.4](https://github.com/foxifyjs/odin/releases/tag/v0.5.4) - *(2018-12-03)*
 
 - :zap: Added `Collection` to create collection and indexes

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxify/odin",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Active Record Model",
   "author": "Ardalan Amini <ardalanamini22@gmail.com> [https://github.com/ardalanamini]",
   "contributors": [
@@ -44,8 +44,8 @@
   "dependencies": {
     "@types/graphql": "^0.13.4",
     "@types/graphql-iso-date": "^3.3.1",
-    "@types/mongodb": "^3.1.15",
-    "@types/node": "^10.12.11",
+    "@types/mongodb": "^3.1.17",
+    "@types/node": "^10.12.12",
     "async": "^2.6.1",
     "caller-id": "^0.1.0",
     "deasync": "^0.1.14",

src/DB/Join.ts

@@ -12,10 +12,10 @@ class Join<T = any> extends Filter {
 
     return {
       $lookup: {
-        as: this._as,
-        from: this._collection,
         let: this._let,
+        from: this._collection,
         pipeline: this._pipeline,
+        as: this._as,
       },
     };
   }
@@ -54,10 +54,9 @@ class Join<T = any> extends Filter {
 
       keys.push(prepareKey(keys.pop() as string));
 
-      const key = keys.join(".");
-      const pivotKey = `pivot_${key}`;
+      const pivotKey = `pivot_${keys.join("_ODIN_")}`;
 
-      this._let[pivotKey] = `$${key}`;
+      this._let[pivotKey] = `$${keys.join(".")}`;
 
       return this._push_filter("and", {
         $expr: {
@@ -75,10 +74,9 @@ class Join<T = any> extends Filter {
 
       keys.push(prepareKey(keys.pop() as string));
 
-      const key = keys.join(".");
-      const pivotKey = `pivot_${key}`;
+      const pivotKey = `pivot_${keys.join("_ODIN_")}`;
 
-      this._let[pivotKey] = `$${key}`;
+      this._let[pivotKey] = `$${keys.join(".")}`;
 
       return this._push_filter("or", {
         $expr: {

src/Relation/Base.ts

@@ -10,6 +10,11 @@ namespace Relation {
     name: string;
     relations: Relation[];
   }
+
+  export interface RelationCount {
+    name: string;
+    relation?: RelationCount;
+  }
 }
 
 abstract class Relation<T extends Odin = Odin, A = undefined> {
@@ -38,6 +43,8 @@ abstract class Relation<T extends Odin = Odin, A = undefined> {
 
   public abstract load(query: DB<T> | Join<T>, relations: Relation.Relation[]): DB<T> | Join<T>;
 
+  public abstract loadCount(query: DB<T> | Join<T>): DB<T> | Join<T>;
+
   /****************************** With Relations ******************************/
 
   public with(...relations: string[]): Query<T>;

src/Relation/EmbedMany.ts

@@ -1,7 +1,7 @@
 import * as Odin from "..";
 import * as DB from "../DB";
 import Join from "../DB/Join";
-import { makeCollectionId } from "../utils";
+import { array, makeCollectionId } from "../utils";
 import Relation from "./Base";
 import HasMany from "./HasMany";
 
@@ -34,10 +34,25 @@ class EmbedMany<T extends Odin = Odin> extends HasMany<T> {
         },
         q.whereIn(this.foreignKey, `${this.model.constructor.toString()}.${this.localKey}`)
       ),
-      // q => q.whereIn(this.foreignKey, `${this.model.constructor.toString()}.${this.localKey}`),
       this.as
     );
   }
+
+  public loadCount(query: DB<T> | Join<T>) {
+    return query
+      .join(
+        this.relation.toString(),
+        q => q
+          .whereIn(this.foreignKey, `${this.model.constructor.toString()}.data.${this.localKey}`),
+        "relation"
+      )
+      .pipeline({
+        $project: {
+          data: 1,
+          count: { $size: "$relation" },
+        },
+      });
+  }
 }
 
 export default EmbedMany;

src/Relation/HasMany.ts

@@ -33,10 +33,25 @@ class HasMany<T extends Odin = Odin> extends Relation<T> {
         },
         q.where(this.foreignKey, `${this.model.constructor.toString()}.${this.localKey}`)
       ),
-      // q => q.where(this.foreignKey, `${this.model.constructor.toString()}.${this.localKey}`),
       this.as
     );
   }
+
+  public loadCount(query: DB<T> | Join<T>) {
+    return query
+      .join(
+        this.relation.toString(),
+        q => q
+          .where(this.foreignKey, `${this.model.constructor.toString()}.data.${this.localKey}`),
+        "relation"
+      )
+      .pipeline({
+        $project: {
+          data: 1,
+          count: { $size: "$relation" },
+        },
+      });
+  }
 }
 
 export default HasMany;

src/Relation/HasOne.ts

@@ -35,15 +35,29 @@ class HasOne<T extends Odin = Odin> extends Relation<T, "HasOne"> {
         q.where(this.foreignKey, `${this.model.constructor.toString()}.${this.localKey}`)
           .limit(1)
       ),
-      // q => q
-      //   .where(this.foreignKey, `${this.model.constructor.toString()}.${this.localKey}`)
-      //   .limit(1),
       name
     ).pipeline({
       $unwind: { path: `$${name}`, preserveNullAndEmptyArrays: true },
     });
   }
 
+  public loadCount(query: DB<T> | Join<T>) {
+    return query
+      .join(
+        this.relation.toString(),
+        q => q
+          .where(this.foreignKey, `${this.model.constructor.toString()}.data.${this.localKey}`)
+          .limit(1),
+        "relation"
+      )
+      .pipeline({
+        $project: {
+          data: 1,
+          count: { $size: "$relation" },
+        },
+      });
+  }
+
   public insert(items: T[]): Promise<undefined>;
   public insert(items: T[], callback: DB.Callback<undefined>): void;
   public async insert(items: T[], callback?: DB.Callback<undefined>) {

src/Relation/MorphMany.ts

@@ -31,6 +31,25 @@ class MorphMany<T extends Odin = Odin> extends MorphBase<T> {
       name
     );
   }
+
+  public loadCount(query: DB<T> | Join<T>) {
+    const constructor = this.model.constructor;
+
+    return query
+      .join(
+        this.relation.toString(),
+        q => q
+          .where(this.foreignKey, `${constructor.toString()}.data.${this.localKey}`)
+          .where(`${this.type}_type`, constructor.name),
+        "relation"
+      )
+      .pipeline({
+        $project: {
+          data: 1,
+          count: { $size: "$relation" },
+        },
+      });
+  }
 }
 
 export default MorphMany;

src/Relation/MorphOne.ts

@@ -36,6 +36,26 @@ class MorphOne<T extends Odin = Odin> extends MorphBase<T, "MorphOne"> {
     });
   }
 
+  public loadCount(query: DB<T> | Join<T>) {
+    const constructor = this.model.constructor;
+
+    return query
+      .join(
+        this.relation.toString(),
+        q => q
+          .where(this.foreignKey, `${constructor.toString()}.data.${this.localKey}`)
+          .where(`${this.type}_type`, constructor.name)
+          .limit(1),
+        "relation"
+      )
+      .pipeline({
+        $project: {
+          data: 1,
+          count: { $size: "$relation" },
+        },
+      });
+  }
+
   public insert(items: T[]): Promise<undefined>;
   public insert(items: T[], callback: DB.Callback<undefined>): void;
   public async insert(items: T[], callback?: DB.Callback<undefined>) {

src/base/Query.ts

@@ -63,21 +63,25 @@ class Query<T extends object = {}> extends DB<T> {
 
   /****************************** Has & WhereHas ******************************/
 
-  // TODO: join relation's count
   public has(relation: string, operator: DB.Operator = ">", count: number = 0) {
+    if (!(this._model as any)._relations.includes(relation))
+      throw new Error(`Relation '${relation}' does not exist on '${this._model.name}' Model`);
+
     this.pipeline({
       $project: {
-        _id: 0,
         data: "$$ROOT",
       },
     });
 
     // join relation
+    (this._model.prototype as any)[relation]().loadCount(this);
 
     return this.pipeline(
       {
-        relation: {
-          [OPERATORS[operator]]: count, // filter data according to count and operator
+        $match: {
+          count: {
+            [`$${OPERATORS[operator]}`]: count, // filter data according to count and operator
+          },
         },
       },
       {

src/base/QueryBuilder.ts

@@ -47,6 +47,12 @@ class QueryBuilder<T extends object = {}> extends Base<T> {
     return this.query().lean();
   }
 
+  /****************************** Has & WhereHas ******************************/
+
+  public static has(relation: string, operator?: DB.Operator, count?: number) {
+    return this.query().has(relation, operator, count);
+  }
+
   /****************************** With Relations ******************************/
 
   public static with<T extends object>(...relations: string[]): Query<T>;

test/relations/HasMany.ts

@@ -1,4 +1,5 @@
 import * as Odin from "../../src";
+import { array } from "../../src/utils";
 
 declare global {
   namespace NodeJS {
@@ -207,3 +208,13 @@ test("Model.with deep", async () => {
 
   expect(results4.map((item: any) => item.toJSON())).toEqual(items);
 });
+
+test("Model.has", async () => {
+  expect.assertions(1);
+
+  const items = CHATS.filter(chat => array.any(MESSAGES, message => message.chatname === chat.name));
+
+  const results = await Chat.has("messages").lean().get();
+
+  expect(results).toEqual(items);
+});