WIP changes up to join redefinition pending - use fields instead of join_params

ormar/models/helpers/relations.py

@@ -109,6 +109,7 @@ def register_reverse_model_fields(model_field: Type["ForeignKeyField"]) -> None:
             virtual=True,
             related_name=model_field.name,
             owner=model_field.to,
+            self_reference=model_field.self_reference,
         )
         # register foreign keys on through model
         adjust_through_many_to_many_model(model_field=model_field)
@@ -119,12 +120,11 @@ def register_reverse_model_fields(model_field: Type["ForeignKeyField"]) -> None:
             virtual=True,
             related_name=model_field.name,
             owner=model_field.to,
+            self_reference=model_field.self_reference,
         )
 
 
-def register_relation_in_alias_manager(
-    field: Type[ForeignKeyField], field_name: str
-) -> None:
+def register_relation_in_alias_manager(field: Type[ForeignKeyField]) -> None:
     """
     Registers the relation (and reverse relation) in alias manager.
     The m2m relations require registration of through model between
@@ -136,8 +136,6 @@ def register_relation_in_alias_manager(
 
     :param field: relation field
     :type field: ForeignKey or ManyToManyField class
-    :param field_name: name of the relation key
-    :type field_name: str
     """
     if issubclass(field, ManyToManyField):
         if field.has_unresolved_forward_refs():

ormar/models/metaclass.py

@@ -587,9 +587,7 @@ class ModelMetaclass(pydantic.main.ModelMetaclass):
                 populate_meta_sqlalchemy_table_if_required(new_model.Meta)
                 expand_reverse_relationships(new_model)
                 for field_name, field in new_model.Meta.model_fields.items():
-                    register_relation_in_alias_manager(
-                        field=field, field_name=field_name
-                    )
+                    register_relation_in_alias_manager(field=field)
 
                 if new_model.Meta.pkname not in attrs["__annotations__"]:
                     field_name = new_model.Meta.pkname

ormar/models/mixins/prefetch_mixin.py

@@ -1,7 +1,7 @@
 from typing import Callable, Dict, List, TYPE_CHECKING, Tuple, Type
 
 import ormar
-from ormar.fields import BaseField
+from ormar.fields.foreign_key import ForeignKeyField
 from ormar.models.mixins.relation_mixin import RelationMixin
 
 
@@ -37,10 +37,7 @@ class PrefetchQueryMixin(RelationMixin):
         :rtype: Tuple[Type[Model], str]
         """
         if reverse:
-            field_name = (
-                parent_model.Meta.model_fields[related].related_name
-                or parent_model.get_name() + "s"
-            )
+            field_name = parent_model.Meta.model_fields[related].get_related_name()
             field = target_model.Meta.model_fields[field_name]
             if issubclass(field, ormar.fields.ManyToManyField):
                 field_name = field.default_target_field_name()
@@ -79,7 +76,7 @@ class PrefetchQueryMixin(RelationMixin):
         return column.get_alias() if use_raw else column.name
 
     @classmethod
-    def get_related_field_name(cls, target_field: Type["BaseField"]) -> str:
+    def get_related_field_name(cls, target_field: Type["ForeignKeyField"]) -> str:
         """
         Returns name of the relation field that should be used in prefetch query.
         This field is later used to register relation in prefetch query,
@@ -93,7 +90,7 @@ class PrefetchQueryMixin(RelationMixin):
         if issubclass(target_field, ormar.fields.ManyToManyField):
             return cls.get_name()
         if target_field.virtual:
-            return target_field.related_name or cls.get_name() + "s"
+            return target_field.get_related_name()
         return target_field.to.Meta.pkname
 
     @classmethod

ormar/models/newbasemodel.py

@@ -30,7 +30,7 @@ import sqlalchemy
 from pydantic import BaseModel
 
 import ormar  # noqa I100
-from ormar.exceptions import ModelError
+from ormar.exceptions import ModelError, ModelPersistenceError
 from ormar.fields import BaseField
 from ormar.fields.foreign_key import ForeignKeyField
 from ormar.models.helpers import register_relation_in_alias_manager
@@ -452,9 +452,7 @@ class NewBaseModel(pydantic.BaseModel, ModelTableProxy, metaclass=ModelMetaclass
                 field.evaluate_forward_ref(globalns=globalns, localns=localns)
                 field.set_self_reference_flag()
                 expand_reverse_relationship(model_field=field)
-                register_relation_in_alias_manager(
-                    field=field, field_name=field_name,
-                )
+                register_relation_in_alias_manager(field=field)
                 update_column_definition(model=cls, field=field)
         populate_meta_sqlalchemy_table_if_required(meta=cls.Meta)
         super().update_forward_refs(**localns)
@@ -731,9 +729,15 @@ class NewBaseModel(pydantic.BaseModel, ModelTableProxy, metaclass=ModelMetaclass
             if self.get_column_alias(k) in self.Meta.table.columns
         }
         for field in self._extract_db_related_names():
-            target_pk_name = self.Meta.model_fields[field].to.Meta.pkname
+            relation_field = self.Meta.model_fields[field]
+            target_pk_name = relation_field.to.Meta.pkname
             target_field = getattr(self, field)
             self_fields[field] = getattr(target_field, target_pk_name, None)
+            if not relation_field.nullable and not self_fields[field]:
+                raise ModelPersistenceError(
+                    f"You cannot save {relation_field.to.get_name()} "
+                    f"model without pk set!"
+                )
         return self_fields
 
     def get_relation_model_id(self, target_field: Type["BaseField"]) -> Optional[int]: