Merge pull request #239 from MasoniteFramework/feature/233

Feature/233

Author: josephmancuso

cc.py

@@ -2,9 +2,11 @@
 from src.masoniteorm.connections import MySQLConnection, PostgresConnection
 from src.masoniteorm.query.grammars import MySQLGrammar, PostgresGrammar
 from src.masoniteorm.models import Model
+from src.masoniteorm.relationships import has_many
+import inspect
 
 
-builder = QueryBuilder(connection=PostgresConnection, grammar=PostgresGrammar).table("users").on("postgres")
+# builder = QueryBuilder(connection=PostgresConnection, grammar=PostgresGrammar).table("users").on("postgres")
 
 
 
@@ -14,8 +16,16 @@ class User(Model):
     __connection__ = "sqlite"
     __table__ = "users"
 
-user = User.create({"name": "phill", "email": "phill"})
-print(User.get().count())
+    @has_many("id", "user_id")
+    def articles(self):
+        return Article
+class Article(Model):
+    __connection__ = "sqlite"
+
+
+# user = User.create({"name": "phill", "email": "phill"})
+# print(inspect.isclass(User))
+print(User.find(1).with_("articles").first().serialize())
 
-print(user.serialize())
+# print(user.serialize())
 # print(User.first())

queries.log

@@ -6,7 +6,7 @@
     # Versions should comply with PEP440.  For a discussion on single-sourcing
     # the version across setup.py and the project code, see
     # https://packaging.python.org/en/latest/single_source_version.html
-    version='0.8.0b',
+    version='0.8.0b1',
     package_dir={'': 'src'},
 
     description='The Official Masonite ORM',

setup.py

@@ -611,6 +611,10 @@ def related(self, relation):
         related = getattr(self.__class__, relation)
         return related.where(related.foreign_key, self.get_primary_key_value())
 
+    def get_related(self, relation):
+        related = getattr(self.__class__, relation)
+        return related
+
     def attach(self, relation, related_record):
         related = getattr(self.__class__, relation)
         setattr(

src/masoniteorm/models/Model.py

@@ -0,0 +1,38 @@
+class EagerRelations:
+    def __init__(self, relation=None):
+        self.eagers = []
+        self.nested_eagers = {}
+        self.is_nested = False
+        self.relation = relation
+
+    def register(self, *relations):
+        for relation in relations:
+            if isinstance(relation, str) and "." not in relation:
+                self.eagers += [relation]
+            elif isinstance(relation, str) and "." in relation:
+                self.is_nested = True
+                relation_key = relation.split(".")[0]
+                if relation_key not in self.nested_eagers:
+                    self.nested_eagers = {relation_key: relation.split(".")[1:]}
+                else:
+                    self.nested_eagers[relation_key] += relation.split(".")[1:]
+            elif isinstance(relation, tuple):
+                for eagers in relations:
+                    for eager in eagers:
+                        self.register(eager)
+            elif isinstance(relation, list):
+                for eagers in relations:
+                    for eager in eagers:
+                        self.register(eager)
+
+        return self
+
+    def get_eagers(self):
+        eagers = []
+        if self.eagers:
+            eagers.append(self.eagers)
+
+        if self.nested_eagers:
+            eagers.append(self.nested_eagers)
+
+        return eagers

src/masoniteorm/query/EagerRelation.py

@@ -24,6 +24,8 @@
 
 from ..pagination import LengthAwarePaginator, SimplePaginator
 
+from .EagerRelation import EagerRelations
+
 
 class QueryBuilder(ObservesEvents):
     """A builder class to manage the building and creation of query expressions."""
@@ -56,7 +58,7 @@ def __init__(
         self._connection_details = connection_details
         self._connection_driver = connection_driver
         self._scopes = scopes
-        self._eager_loads = ()
+        self._eager_relation = EagerRelations()
         if model:
             self._global_scopes = model._global_scopes
             if model.__with__:
@@ -1095,27 +1097,39 @@ def prepare_result(self, result, collection=False):
         if self._model:
             # eager load here
             hydrated_model = self._model.hydrate(result)
-            if self._eager_loads and hydrated_model:
-                for eager in self._eager_loads:
-                    if "." in eager:
-                        last_owner = self._model
-                        last_result = hydrated_model
-                        for eager in eager.split("."):
-                            related = getattr(last_owner, eager)
-                            result_set = related.get_related(last_result)
+            if self._eager_relation.eagers and hydrated_model:
+                for eager_load in self._eager_relation.get_eagers():
+                    if isinstance(eager_load, dict):
+                        # Nested
+                        for relation, eagers in eager_load.items():
+                            if inspect.isclass(self._model):
+                                related = getattr(self._model, relation)
+                            else:
+                                related = self._model.get_related(relation)
+
+                            result_set = related.get_related(
+                                hydrated_model, eagers=eagers
+                            )
 
                             self._register_relationships_to_model(
-                                related, result_set, last_result, relation_key=eager
+                                related,
+                                result_set,
+                                hydrated_model,
+                                relation_key=relation,
                             )
-
-                            last_result = result_set
-                            last_owner = related.get_builder()._model
                     else:
-                        related = getattr(self._model, eager)
-                        related_result = related.get_related(hydrated_model)
-                        self._register_relationships_to_model(
-                            related, related_result, hydrated_model, relation_key=eager
-                        )
+                        # Not Nested
+                        for eager in eager_load:
+                            if inspect.isclass(self._model):
+                                related = getattr(self._model, eager)
+                            else:
+                                related = self._model.get_related(eager)
+
+                            result_set = related.get_related(hydrated_model)
+
+                            self._register_relationships_to_model(
+                                related, result_set, hydrated_model, relation_key=eager
+                            )
 
             if collection:
                 return hydrated_model if result else Collection([])
@@ -1149,7 +1163,6 @@ def _register_relationships_to_model(
                 else:
                     model.add_relation({relation_key: related_result or None})
         else:
-
             hydrated_model.add_relation({relation_key: related_result or None})
         return self
 
@@ -1192,14 +1205,8 @@ def without_eager(self):
         self._should_eager = False
         return self
 
-    def with_(self, eagers=(), *others):
-        if not isinstance(eagers, (tuple, list)):
-            eagers = (eagers,)
-
-        if others:
-            eagers += others
-
-        self._eager_loads += eagers
+    def with_(self, *eagers):
+        self._eager_relation.register(eagers)
         return self
 
     def paginate(self, per_page, page=1):

src/masoniteorm/query/QueryBuilder.py

@@ -19,7 +19,7 @@ def apply_query(self, foreign, owner):
             self.foreign_key, owner.__attributes__[self.local_key]
         ).first()
 
-    def get_related(self, relation):
+    def get_related(self, relation, eagers=()):
         """Gets the relation needed between the relation and the related builder. If the relation is a collection
         then will need to pluck out all the keys from the collection and fetch from the related builder. If
         relation is just a Model then we can just call the model based on the value of the related
@@ -31,7 +31,7 @@ def get_related(self, relation):
         Returns:
             Model|Collection
         """
-        builder = self.get_builder()
+        builder = self.get_builder().with_(eagers)
         if isinstance(relation, Collection):
             return builder.where_in(
                 f"{builder.get_table_name()}.{self.foreign_key}",

src/masoniteorm/relationships/BelongsTo.py

@@ -21,8 +21,8 @@ def apply_query(self, foreign, owner):
 
         return result
 
-    def get_related(self, relation):
-        builder = self.get_builder()
+    def get_related(self, relation, eagers=[]):
+        builder = self.get_builder().with_(eagers)
         if isinstance(relation, Collection):
             return builder.where_in(
                 f"{builder.get_table_name()}.{self.foreign_key}",

src/masoniteorm/relationships/HasMany.py

@@ -0,0 +1,73 @@
+import os
+import unittest
+
+from src.masoniteorm.query.EagerRelation import EagerRelations
+
+
+class TestEagerRelation(unittest.TestCase):
+    def test_can_register_string_eager_load(self):
+
+        self.assertEqual(
+            EagerRelations().register("profile").get_eagers(), [["profile"]]
+        )
+        self.assertEqual(EagerRelations().register("profile").is_nested, False)
+        self.assertEqual(
+            EagerRelations().register("profile.user").get_eagers(),
+            [{"profile": ["user"]}],
+        )
+        self.assertEqual(
+            EagerRelations().register("profile.user", "profile.logo").get_eagers(),
+            [{"profile": ["user", "logo"]}],
+        )
+        self.assertEqual(
+            EagerRelations()
+            .register("profile.user", "profile.logo", "profile.bio")
+            .get_eagers(),
+            [{"profile": ["user", "logo", "bio"]}],
+        )
+        self.assertEqual(
+            EagerRelations().register("user", "logo", "bio").get_eagers(),
+            [["user", "logo", "bio"]],
+        )
+
+    def test_can_register_tuple_eager_load(self):
+
+        self.assertEqual(
+            EagerRelations().register(("profile",)).get_eagers(), [["profile"]]
+        )
+        self.assertEqual(
+            EagerRelations().register(("profile", "user")).get_eagers(),
+            [["profile", "user"]],
+        )
+        self.assertEqual(
+            EagerRelations().register(("profile.name", "profile.user")).get_eagers(),
+            [{"profile": ["name", "user"]}],
+        )
+
+    def test_can_register_list_eager_load(self):
+
+        self.assertEqual(
+            EagerRelations().register(["profile"]).get_eagers(), [["profile"]]
+        )
+        self.assertEqual(
+            EagerRelations().register(["profile", "user"]).get_eagers(),
+            [["profile", "user"]],
+        )
+        self.assertEqual(
+            EagerRelations().register(["profile.name", "profile.user"]).get_eagers(),
+            [{"profile": ["name", "user"]}],
+        )
+        self.assertEqual(
+            EagerRelations().register(["profile.name"]).get_eagers(),
+            [{"profile": ["name"]}],
+        )
+        self.assertEqual(
+            EagerRelations().register(["profile.name", "logo"]).get_eagers(),
+            [["logo"], {"profile": ["name"]}],
+        )
+        self.assertEqual(
+            EagerRelations()
+            .register(["profile.name", "logo", "profile.user"])
+            .get_eagers(),
+            [["logo"], {"profile": ["name", "user"]}],
+        )

tests/eagers/test_eager.py

@@ -6,7 +6,7 @@
 from src.masoniteorm.models import Model
 from src.masoniteorm.query import QueryBuilder
 from src.masoniteorm.query.grammars import SQLiteGrammar
-from src.masoniteorm.relationships import belongs_to
+from src.masoniteorm.relationships import belongs_to, has_many
 from tests.utils import MockConnectionFactory
 
 
@@ -21,6 +21,10 @@ class Article(Model):
     def logo(self):
         return Logo
 
+    @belongs_to("user_id", "id")
+    def user(self):
+        return User
+
 
 class Profile(Model):
     __connection__ = "sqlite"
@@ -29,9 +33,9 @@ class Profile(Model):
 class User(Model):
     __connection__ = "sqlite"
 
-    __with__ = ("profile",)
+    __with__ = ["articles.logo"]
 
-    @belongs_to("id", "user_id")
+    @has_many("id", "user_id")
     def articles(self):
         return Article
 
@@ -88,3 +92,9 @@ def test_with_where_no_relation(self):
         builder = self.get_builder()
         result = builder.with_("profile").where("id", 5).first()
         result.serialize()
+
+    def test_with_multiple_per_same_relation(self):
+        builder = self.get_builder()
+        result = User.with_("articles", "articles.logo").where("id", 1).first()
+        self.assertTrue(result.serialize()["articles"])
+        self.assertTrue(result.serialize()["articles"][0]["logo"])

tests/sqlite/builder/test_sqlite_query_builder_eager_loading.py

@@ -77,7 +77,6 @@ def test_loading(self):
     def test_loading_with_nested_with(self):
         users = User.with_("articles", "articles.logo").get()
         for user in users:
-            print(user.articles)
             for article in user.articles:
                 if article.logo:
                     print("aa", article.logo.url)