Alias self-referencing relations in where_has/has

fastapi_startkit/src/fastapi_startkit/masoniteorm/models/builder.py

@@ -80,6 +80,7 @@ def __init__(self, connection: "Connection", grammar: Any, processor: Any):
 
         self._columns: list[Any] = []
         self._table = ""
+        self._alias: str | None = None
         self._limit = False
         self._offset = False
         self._wheres = []
@@ -111,10 +112,11 @@ def with_(self, *eagers) -> "Self":
         return self
 
     def get_table_name(self) -> str:
-        return self._table
+        return self._alias or self._table
 
-    def table(self, table: str) -> "Self":
+    def table(self, table: str, alias: str | None = None) -> "Self":
         self._table = table
+        self._alias = alias
         return self
 
     def where_in(self, column: str, values: Iterable[Any]) -> "Self":
@@ -256,6 +258,7 @@ def get_grammar(self):
         return self.grammar(
             columns=self._columns,
             table=self._table,
+            alias=self._alias,
             limit=self._limit,
             offset=self._offset,
             wheres=self._wheres,
@@ -550,7 +553,7 @@ def new(self):
         # subgroup) prefixes its columns correctly instead of rendering a
         # table-less ."column". Callers that want a different table override it
         # with .table(...) as usual.
-        return self.connection.query().table(self._table)
+        return self.connection.query().table(self._table, self._alias)
 
     def invalid_operator(self, operator: Any) -> bool:
         """Determine whether an operator is not supported by the builder."""

fastapi_startkit/src/fastapi_startkit/masoniteorm/query/grammars/BaseGrammar.py

@@ -98,9 +98,11 @@ def __init__(
         lock=False,
         having=(),
         connection_details=None,
+        alias=None,
     ):
         self._columns = columns
         self.table = table
+        self.alias = alias
         self.database = database
         self._wheres = wheres
         self._limit = limit
@@ -161,7 +163,7 @@ def _compile_select(self, qmark=False):
                 .format(
                     columns=self.process_columns(separator=", ", qmark=qmark),
                     keyword="DISTINCT" if self._distinct else "",
-                    table=self.process_table(self.table),
+                    table=self.process_from_table(),
                     joins=self.process_joins(qmark=qmark),
                     wheres=self.process_wheres(qmark=qmark),
                     limit=self.process_limit(),
@@ -560,6 +562,11 @@ def process_table(self, table):
             for t in table.name.split(".")
         )
 
+    def process_from_table(self):
+        if not self.alias:
+            return self.process_table(self.table)
+        return f"{self.process_table(self.table)} AS {self.process_table(self.alias)}"
+
     def process_limit(self):
         """Compiles the limit expression.
 
@@ -960,7 +967,7 @@ def process_column(self, column, separator=""):
         table = None
         if column and "." in column:
             table, column = column.split(".")
-        return self.column_string().format(column=column, separator=separator, table=table or self.table)
+        return self.column_string().format(column=column, separator=separator, table=table or self.alias or self.table)
 
     def _table_column_string(self, column, alias=None, separator=""):
         """Compiles a column into the column syntax.
@@ -982,15 +989,15 @@ def _table_column_string(self, column, alias=None, separator=""):
             return self.column_strings["select_all"].format(
                 column=column,
                 separator=separator,
-                table=self.process_table(table or self.table),
+                table=self.process_table(table or self.alias or self.table),
             )
 
         alias_string = " " + self.subquery_alias_string().format(alias=alias) if alias else ""
         return self.column_strings[self._action].format(
             column=column,
             separator=separator,
             alias=alias_string,
-            table=self.process_table(table or self.table),
+            table=self.process_table(table or self.alias or self.table),
         )
 
     def _compile_value(self, value, separator=""):

fastapi_startkit/src/fastapi_startkit/masoniteorm/relationships/BaseRelationship.py

@@ -68,6 +68,15 @@ def model_reference(self) -> str | type:
     def get_builder(self):
         return self.fn()().get_builder()
 
+    def exists_alias(self, query, parent):
+        if query.get_table_name() == parent._table:
+            return f"{parent.get_table_name()}_self"
+        return None
+
+    def get_exists_builder(self, parent):
+        query = self.get_builder()
+        return query.table(query.get_table_name(), self.exists_alias(query, parent))
+
     @overload
     def __get__(self, instance: None, owner: Any) -> Self: ...
     @overload

fastapi_startkit/src/fastapi_startkit/masoniteorm/relationships/BelongsTo.py

@@ -31,7 +31,7 @@ def apply_query(self, foreign, owner):
         return foreign.where(self.foreign_key, owner.__attributes__[self.local_key]).first()
 
     def query_has(self, current_query_builder, method="where_exists"):
-        related_builder = self.get_builder()
+        related_builder = self.get_exists_builder(current_query_builder)
 
         getattr(current_query_builder, method)(
             related_builder.where_column(
@@ -43,7 +43,7 @@ def query_has(self, current_query_builder, method="where_exists"):
         return related_builder
 
     def query_where_exists(self, builder, callback, method="where_exists"):
-        query = self.get_builder()
+        query = self.get_exists_builder(builder)
         getattr(builder, method)(
             callback(
                 query.where_column(

fastapi_startkit/src/fastapi_startkit/masoniteorm/relationships/BelongsToMany.py

@@ -3,6 +3,7 @@
 
 from .BaseRelationship import BaseRelationship, ManyResult, TModel
 from ..collection import Collection
+from ..models.builder import QueryBuilder
 from ..models.pivot import Pivot
 
 
@@ -401,43 +402,32 @@ def joins(self, builder, clause=None):
         return result
 
     def query_where_exists(self, builder, callback, method="where_exists"):
-        query = self.get_builder()
-        pivot_table = self._table or self.get_pivot_table_name(query, builder)
-        table = self.get_builder().get_table_name()
-
-        getattr(builder, method)(
-            query.new()
-            .table(table)
-            .join(
-                f"{pivot_table}",
-                f"{table}.{self.other_owner_key}",
-                "=",
-                f"{pivot_table}.{self.foreign_key}",
-            )
-            .where_column(
-                f"{pivot_table}.{self.local_key}",
-                f"{builder.get_table_name()}.{self.local_owner_key}",
+        related = self.related_exists_query(builder)
+        constrained = callback(related)
+        if isinstance(constrained, QueryBuilder) and constrained is not related:
+            raise TypeError(
+                "where_has callback must constrain and return the query it receives, not a different QueryBuilder"
             )
-            .where_in(self.other_owner_key, callback(query.select(self.other_owner_key)))
-        )
+        if constrained is not None and constrained is not related:
+            related.where_in(f"{related.get_table_name()}.{self.other_owner_key}", constrained)
+        return getattr(builder, method)(related)
 
     def query_has(self, current_query_builder, method="where_exists"):
+        return getattr(current_query_builder, method)(self.related_exists_query(current_query_builder))
+
+    def related_exists_query(self, builder):
         query = self.get_builder()
-        pivot_table = self._table or self.get_pivot_table_name(query, current_query_builder)
-        table = self.get_builder().get_table_name()
-        return getattr(current_query_builder, method)(
-            query.new()
-            .table(table)
-            .join(
-                f"{pivot_table}",
-                f"{table}.{self.other_owner_key}",
-                "=",
-                f"{pivot_table}.{self.foreign_key}",
-            )
-            .where_column(
-                f"{pivot_table}.{self.local_key}",
-                f"{current_query_builder.get_table_name()}.{self.local_owner_key}",
-            )
+        pivot_table = self._table or self.get_pivot_table_name(query, builder)
+        related = query.new().table(query.get_table_name(), self.exists_alias(query, builder))
+        table = related.get_table_name()
+        return related.join(
+            f"{pivot_table}",
+            f"{table}.{self.other_owner_key}",
+            "=",
+            f"{pivot_table}.{self.foreign_key}",
+        ).where_column(
+            f"{pivot_table}.{self.local_key}",
+            f"{builder.get_table_name()}.{self.local_owner_key}",
         )
 
     def get_pivot_table_name(self, query, builder):

fastapi_startkit/src/fastapi_startkit/masoniteorm/relationships/HasMany.py

@@ -40,7 +40,7 @@ async def attach(self, current_model, related_record):
         return await related_record.update({self.foreign_key: local_key_value})
 
     def query_has(self, current_query_builder, method="where_exists"):
-        related_builder = self.get_builder()
+        related_builder = self.get_exists_builder(current_query_builder)
 
         getattr(current_query_builder, method)(
             related_builder.where_column(
@@ -52,7 +52,7 @@ def query_has(self, current_query_builder, method="where_exists"):
         return related_builder
 
     def query_where_exists(self, builder, callback, method="where_exists"):
-        query = self.get_builder()
+        query = self.get_exists_builder(builder)
         getattr(builder, method)(
             callback(
                 query.where_column(

fastapi_startkit/src/fastapi_startkit/masoniteorm/relationships/HasOne.py

@@ -41,7 +41,7 @@ def map_related(self, related_result):
         return related_result
 
     def query_has(self, current_query_builder, method="where_exists"):
-        related_builder = self.get_builder()
+        related_builder = self.get_exists_builder(current_query_builder)
 
         getattr(current_query_builder, method)(
             related_builder.where_column(
@@ -58,7 +58,7 @@ def register_related(self, key, model, collection):
         model.add_relation({key: related or None})
 
     def query_where_exists(self, builder, callback, method="where_exists"):
-        query = self.get_builder()
+        query = self.get_exists_builder(builder)
         getattr(builder, method)(
             callback(
                 query.where_column(