fastapi-startkit 0.63.0__tar.gz → 0.64.0__tar.gz

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.63.0
+Version: 0.64.0
 Summary: A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console.
 Keywords: fastapi,framework,async,web,asgi,orm,sqlalchemy,pydantic,ioc-container,dependency-injection,service-provider,cli,console,configuration,microservices,starter-kit,boilerplate
 Author: Bedram Tamang
@@ -12,6 +12,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Requires-Dist: dotty-dict>=1.3.1
 Requires-Dist: pendulum>=3.1.0,<4.0.0
@@ -20,6 +22,7 @@ Requires-Dist: requests>=2.32.5,<3.0.0
 Requires-Dist: cleo>=2.1.0,<3.0.0
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: pydantic>=2.12.5
+Requires-Dist: typing-extensions>=4.12.0
 Requires-Dist: langchain>=1.0.0 ; extra == 'ai'
 Requires-Dist: langchain-core>=1.0.0 ; extra == 'ai'
 Requires-Dist: langgraph>=1.0.0 ; extra == 'ai'
@@ -74,8 +77,18 @@ Optional extras enable additional capabilities:
 fastapi-startkit[fastapi]    # FastAPI + Starlette
 fastapi-startkit[database]   # SQLAlchemy async ORM
 fastapi-startkit[vite]       # Jinja2 for Vite integration
+fastapi-startkit[ai]         # LangChain agents
 ```
 
+### Python versions
+
+Python 3.12, 3.13, 3.14 and 3.15 are supported.
+
+> [!NOTE]
+> The `ai` extra cannot be installed on Python 3.15 or newer yet. It depends on `langgraph`, which
+> requires `ormsgpack`, and `ormsgpack` does not support Python 3.15 yet. Use Python 3.14 or older for the
+> `ai` extra. Every other extra works on 3.15.
+
 ## Features
 
 - **Service container** — IoC container with `bind`/`make`/`resolve` auto-wiring and lifecycle hooks.

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/README.md

@@ -20,8 +20,18 @@ Optional extras enable additional capabilities:
 fastapi-startkit[fastapi]    # FastAPI + Starlette
 fastapi-startkit[database]   # SQLAlchemy async ORM
 fastapi-startkit[vite]       # Jinja2 for Vite integration
+fastapi-startkit[ai]         # LangChain agents
 ```
 
+### Python versions
+
+Python 3.12, 3.13, 3.14 and 3.15 are supported.
+
+> [!NOTE]
+> The `ai` extra cannot be installed on Python 3.15 or newer yet. It depends on `langgraph`, which
+> requires `ormsgpack`, and `ormsgpack` does not support Python 3.15 yet. Use Python 3.14 or older for the
+> `ai` extra. Every other extra works on 3.15.
+
 ## Features
 
 - **Service container** — IoC container with `bind`/`make`/`resolve` auto-wiring and lifecycle hooks.

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.63.0"
+version = "0.64.0"
 description = "A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console."
 readme = "README.md"
 keywords = [
@@ -34,6 +34,8 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Software Development :: Libraries :: Application Frameworks",
 ]
 dependencies = [
@@ -44,6 +46,7 @@ dependencies = [
     "cleo>=2.1.0,<3.0.0",
     "dotenv>=0.9.9",
     "pydantic>=2.12.5",
+    "typing-extensions>=4.12.0",
 ]
 
 [project.urls]
@@ -109,7 +112,7 @@ dev = [
     "sqlalchemy[asyncio]>=2.0.38",
     "fastapi[standard]>=0.124.4",
     "faker>=40.13.0",
-    "langchain>=1.0.0",
+    "langchain>=1.0.0; python_version < '3.15'",
     "langchain-core>=1.0.0",
     "basedpyright>=1.31.4",
     "pyright>=1.1.411",

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/fastapi/exceptions.py

@@ -44,6 +44,8 @@ class ValidationExceptionHandler:
         pass
 
     async def render(self, request, exc):
+        from fastapi_startkit.inertia.constant import Header
+
         accept = request.headers.get("accept", "")
         content_type = request.headers.get("content-type", "")
 
@@ -54,6 +56,9 @@ class ValidationExceptionHandler:
             field = ".".join(str(x) for x in err["loc"][1:])
             errors.setdefault(field, []).append(err["msg"])
 
+        if request.headers.get(Header.INERTIA):
+            return self.redirect_back_with_errors(request, errors)
+
         if wants_json:
             from fastapi.responses import JSONResponse
 
@@ -67,3 +72,13 @@ class ValidationExceptionHandler:
         from fastapi_startkit.fastapi.referer import same_origin_referer
 
         return RedirectResponse(url=same_origin_referer(request), status_code=303)
+
+    @staticmethod
+    def redirect_back_with_errors(request, errors: dict):
+        from fastapi_startkit.fastapi.referer import same_origin_referer
+        from fastapi_startkit.inertia import session
+        from fastapi_startkit.inertia.constant import Header
+        from fastapi_startkit.inertia.redirect import InertiaRedirect
+
+        session.put_errors(request, errors, request.headers.get(Header.ERROR_BAG) or session.DEFAULT_BAG)
+        return InertiaRedirect(same_origin_referer(request), status_code=303)

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/inertia/session.py

@@ -52,7 +52,10 @@ def flash(key: Union[str, Dict[str, Any]], value: Any = None) -> None:
 
 
 def with_errors(errors: ErrorsInput, bag: str = DEFAULT_BAG) -> None:
-    request = active_request()
+    put_errors(active_request(), errors, bag)
+
+
+def put_errors(request: Request, errors: ErrorsInput, bag: str = DEFAULT_BAG) -> None:
     bags = dict(store(request).get(ERRORS) or {})
     bags[bag] = ValidationErrors(bags.get(bag)).merge(ValidationErrors.make(errors)).all()
     put(request, ERRORS, bags)

fastapi_startkit-0.64.0/src/fastapi_startkit/inertia/testing.py

@@ -0,0 +1,140 @@
+import html
+import json
+import re
+from collections.abc import Mapping, Sequence
+from typing import Any, Optional, Self
+
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from fastapi_startkit.inertia.constant import Header
+
+MISSING: Any = object()
+SCRIPT_PAGE = re.compile(r"<script\b[^>]*\bdata-page=[\"'][^\"']*[\"'][^>]*>(.*?)</script>", re.DOTALL)
+ATTRIBUTE_PAGE = re.compile(r"\bdata-page=(?:\"([^\"]*)\"|'([^']*)')")
+
+
+class FakeSessionMiddleware:
+    def __init__(self, app: ASGIApp, session: Optional[dict] = None):
+        self.app = app
+        self.session = session if session is not None else {}
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] in ("http", "websocket"):
+            scope["session"] = self.session
+        await self.app(scope, receive, send)
+
+
+def response_text(response: Any) -> str:
+    text = getattr(response, "text", None)
+    if isinstance(text, str):
+        return text
+    body = getattr(response, "body", b"")
+    return body.decode() if isinstance(body, bytes) else str(body)
+
+
+def is_json(response: Any) -> bool:
+    return bool(response.headers.get(Header.INERTIA)) or "json" in response.headers.get("content-type", "")
+
+
+def extract_page(response: Any) -> dict:
+    text = response_text(response)
+    if is_json(response):
+        return json.loads(text)
+    script = SCRIPT_PAGE.search(text)
+    if script:
+        return json.loads(script.group(1))
+    attribute = ATTRIBUTE_PAGE.search(text)
+    if attribute:
+        return json.loads(html.unescape(attribute.group(1) or attribute.group(2)))
+    raise AssertionError(f"Response does not contain an Inertia page: {text[:200]!r}")
+
+
+def ensure(condition: bool, message: str) -> None:
+    if not condition:
+        raise AssertionError(message)
+
+
+def lookup(value: Any, path: str) -> Any:
+    for segment in path.split("."):
+        if isinstance(value, Mapping) and segment in value:
+            value = value[segment]
+        elif isinstance(value, Sequence) and not isinstance(value, str) and segment.isdigit():
+            if int(segment) >= len(value):
+                return MISSING
+            value = value[int(segment)]
+        else:
+            return MISSING
+    return value
+
+
+class AssertablePage:
+    def __init__(self, page: dict):
+        self.page = page
+
+    @classmethod
+    def from_response(cls, response: Any) -> "AssertablePage":
+        return cls(extract_page(response))
+
+    @property
+    def props(self) -> dict:
+        return self.page.get("props", {})
+
+    def prop(self, path: str) -> Any:
+        value = lookup(self.props, path)
+        ensure(value is not MISSING, f"Expected prop {path!r} to exist in props {self.props!r}")
+        return value
+
+    def component(self, name: str) -> Self:
+        actual = self.page.get("component")
+        ensure(actual == name, f"Expected component {name!r}, got {actual!r}")
+        return self
+
+    def url(self, url: str) -> Self:
+        actual = self.page.get("url")
+        ensure(actual == url, f"Expected url {url!r}, got {actual!r}")
+        return self
+
+    def version(self, version: str) -> Self:
+        actual = self.page.get("version")
+        ensure(actual == version, f"Expected version {version!r}, got {actual!r}")
+        return self
+
+    def has(self, path: str) -> Self:
+        self.prop(path)
+        return self
+
+    def has_count(self, path: str, count: int) -> Self:
+        value = self.prop(path)
+        size = len(value) if isinstance(value, (Mapping, Sequence)) and not isinstance(value, str) else None
+        ensure(size == count, f"Expected prop {path!r} to have {count} items, got {size}")
+        return self
+
+    def missing(self, path: str) -> Self:
+        value = lookup(self.props, path)
+        ensure(value is MISSING, f"Expected prop {path!r} to be missing, got {value!r}")
+        return self
+
+    def equals(self, path: str, expected: Any) -> Self:
+        value = self.prop(path)
+        ensure(value == expected, f"Expected prop {path!r} to equal {expected!r}, got {value!r}")
+        return self
+
+    def deferred(self, group: str, props: Sequence[str]) -> Self:
+        groups = self.page.get("deferredProps", {})
+        actual = groups.get(group)
+        ensure(
+            actual is not None and sorted(actual) == sorted(props),
+            f"Expected deferred group {group!r} to be {sorted(props)!r}, got {actual!r} in {groups!r}",
+        )
+        return self
+
+    def flash(self, key: str, value: Any = MISSING) -> Self:
+        flash = self.page.get("flash", {})
+        ensure(key in flash, f"Expected flash {key!r} to exist in {flash!r}")
+        if value is not MISSING:
+            ensure(flash[key] == value, f"Expected flash {key!r} to equal {value!r}, got {flash[key]!r}")
+        return self
+
+
+def assert_inertia(response: Any) -> AssertablePage:
+    return AssertablePage.from_response(response)

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/collection/Collection.py

@@ -33,14 +33,13 @@ class Collection(BaseCollection, Generic[T]):
         first = self._items[0]
         for relation in relations:
             relationship = getattr(first.__class__, relation)
-            result_set = await relationship.get_related(None, self)
-            if result_set:
-                map_related = relationship.map_related(result_set)
-                for model in self._items:
-                    if isinstance(result_set, Collection):
-                        relationship.register_related(relation, model, map_related)
-                    else:
-                        # load() only runs on model collections; T is generic.
-                        model.add_relation({relation: map_related or None})  # type: ignore
+            result_set = await relationship.get_related(first.get_builder(), self)
+            map_related = relationship.map_related(result_set)
+            for model in self._items:
+                if isinstance(result_set, Collection):
+                    relationship.register_related(relation, model, map_related)
+                else:
+                    # load() only runs on model collections; T is generic.
+                    model.add_relation({relation: map_related or None})  # type: ignore
 
         return self

fastapi_startkit-0.64.0/src/fastapi_startkit/masoniteorm/exceptions.py

@@ -0,0 +1,22 @@
+class ModelNotFoundException(Exception):
+    is_http_exception = True
+
+    def __init__(self, message="Model Not Found"):
+        super().__init__(message)
+        self.message = message
+
+    def get_response(self):
+        return self.message
+
+    def get_status(self):
+        return 404
+
+
+class LazyLoadingViolation(Exception):
+    def __init__(self, model: object, relation: str | None):
+        self.model = type(model).__name__
+        self.relation = relation
+        super().__init__(
+            f"Attempted to lazy load [{relation}] on model [{self.model}]. "
+            f'Eager load it with {self.model}.with_("{relation}") or await the model\'s load("{relation}") first.'
+        )

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/models/caster.py

@@ -3,6 +3,7 @@ import pendulum
 import datetime
 from decimal import Decimal
 from enum import Enum
+from inspect import get_annotations
 from dataclasses import dataclass, field
 from collections.abc import Callable
 from typing import Any, get_args, get_type_hints, Optional
@@ -208,7 +209,7 @@ class Caster:
         except NameError:
             annotations = {}
             for klass in reversed(model.__mro__):
-                for name, hint in vars(klass).get("__annotations__", {}).items():
+                for name, hint in get_annotations(klass).items():
                     if not isinstance(getattr(model, name, None), BaseRelationship):
                         annotations[name] = hint
 

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/models/model.py

@@ -107,6 +107,10 @@ class Model(Attribute, Relationship, ObservesEvents):
     def get_related(self, key: str):
         return getattr(self.__class__, key)
 
+    async def load(self, *relations: str) -> Self:
+        await self.new_collection([self]).load(*relations)
+        return self
+
     @classmethod
     def with_(cls, *eagers) -> "QueryBuilder[Self]":
         return cls.query().with_(*eagers)

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/query/EagerLoadMixin.py

@@ -1,6 +1,5 @@
 import inspect
 
-from fastapi_startkit.masoniteorm.collection import Collection
 from fastapi_startkit.masoniteorm.query.EagerRelation import EagerRelations
 
 
@@ -9,6 +8,9 @@ class EagerLoadMixin:
         self._eager_relation = EagerRelations()
 
     async def _load_eagers(self, models, model):
+        if not models:
+            return
+
         for eager_load in self._eager_relation.get_eagers():
             if isinstance(eager_load, dict):
                 # Nested or callback eagers
@@ -53,15 +55,9 @@ class EagerLoadMixin:
                     )
 
     async def _register_relationships_to_model(self, related, related_result, models, relation_key):
-        if related_result and isinstance(models, Collection):
-            map_related = self._map_related(related_result, related)
-            for model in models:
-                if isinstance(related_result, Collection):
-                    related.register_related(relation_key, model, map_related)
-                else:
-                    model.add_relation({relation_key: map_related or None})
-        else:
-            models.add_relation({relation_key: related_result or None})
+        map_related = self._map_related(related_result, related)
+        for model in models:
+            related.register_related(relation_key, model, map_related)
         return self
 
     def _map_related(self, related_result, related):

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/relationships/BaseRelationship.py

@@ -1,12 +1,27 @@
+import os
+import typing
+import warnings
+from typing import TYPE_CHECKING, Any, ForwardRef, Generic, Self, get_args, overload
+
+from typing_extensions import TypeVar
+
 from fastapi_startkit.masoniteorm.models import registry
+from ..collection import Collection
+from ..exceptions import LazyLoadingViolation
 
+if TYPE_CHECKING:
+    from ..models.model import Model
+
+TModel = TypeVar("TModel", bound="Model", default="Model")
+TResult = TypeVar("TResult", default=Any)
+
+type SingleResult[T] = T | None
+type ManyResult[T] = Collection[T]
 
-class BaseRelationship:
-    def __init__(self, fn: str | list[str], local_key=None, foreign_key=None):
-        if not isinstance(fn, str):
-            raise TypeError(f"Relationship {self.__class__.__name__} expects a string as the first argument")
-        fn_str: str = fn  # For type checking
-        self.fn = lambda: registry.Registry.resolve(fn_str)
+
+class BaseRelationship(Generic[TModel, TResult]):
+    def __init__(self, fn: str | None = None, local_key=None, foreign_key=None):
+        self.bind_model(fn)
 
         self.local_key = local_key
         self.foreign_key = foreign_key
@@ -15,11 +30,54 @@ class BaseRelationship:
     def __set_name__(self, cls, name):
         self.attribute = name
         self.owner_class = cls
+        if "_model_name" in self.__dict__:
+            self.model_reference()
+
+    def bind_model(self, fn: str | None) -> None:
+        if fn is not None and not isinstance(fn, str):
+            raise TypeError(f"Relationship {self.__class__.__name__} expects a string as the first argument")
+        if fn is not None:
+            klass = self.__class__.__name__
+            warnings.warn(
+                f'Passing the related model as {klass}("{fn}", ...) is deprecated and will be removed in 1.x; '
+                f'declare it as {klass}["{fn}"](...) instead.',
+                DeprecationWarning,
+                skip_file_prefixes=(os.path.dirname(__file__), typing.__file__),
+            )
+        self._model_name = fn
+        self.fn = self.related_model
+
+    def related_model(self) -> type:
+        model = self.model_reference()
+        return registry.Registry.resolve(model) if isinstance(model, str) else model
+
+    def model_reference(self) -> str | type:
+        if self._model_name is not None:
+            return self._model_name
+
+        alias = self.__dict__.get("__orig_class__")
+        if alias is None:
+            klass = self.__class__.__name__
+            owner = self.__dict__.get("owner_class")
+            subject = f"{owner.__name__}.{self.__dict__.get('attribute')}" if owner else klass
+            raise TypeError(f'{subject} needs its related model: declare it as {klass}["Model"](...)')
+
+        model = get_args(alias)[0]
+        return model.__forward_arg__ if isinstance(model, ForwardRef) else model
 
     def get_builder(self):
         return self.fn()().get_builder()
 
-    def __get__(self, instance, owner):
+    @overload
+    def __get__(self, instance: None, owner: Any) -> Self: ...
+    @overload
+    def __get__(self: "BaseRelationship[Model, Any]", instance: object, owner: Any) -> Any: ...
+    @overload
+    def __get__(self, instance: object, owner: Any) -> TResult: ...
+    def __get__(self, instance, owner) -> Any:
+        return self.access(instance, owner)
+
+    def access(self, instance, owner):
         """
         This method is called when the decorated method is accessed.
 
@@ -43,7 +101,7 @@ class BaseRelationship:
         if self.attribute in instance._relationships:
             return instance._relationships[self.attribute]
 
-        return self.apply_query(self.get_builder(), instance)
+        raise LazyLoadingViolation(instance, self.attribute)
 
     def __getattr__(self, attribute):
         return getattr(self.get_builder(), attribute)

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/relationships/BelongsTo.py

@@ -1,16 +1,14 @@
 from typing import cast
 
 from ..collection import Collection
-from . import BaseRelationship
-from fastapi_startkit.masoniteorm.models import registry
+from .BaseRelationship import BaseRelationship, SingleResult, TModel
 
 
-class BelongsTo(BaseRelationship):
+class BelongsTo(BaseRelationship[TModel, SingleResult[TModel]]):
     """Belongs To Relationship Class."""
 
-    def __init__(self, fn: str, local_key=None, foreign_key=None):
-        # If user provides string instead of Model, we will resolve it here
-        self.fn = lambda: registry.Registry.resolve(fn)
+    def __init__(self, fn: str | None = None, local_key=None, foreign_key=None):
+        self.bind_model(fn)
 
         self.local_key = local_key or "id"
         self.foreign_key = foreign_key

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/relationships/BelongsToMany.py

@@ -1,18 +1,17 @@
 import pendulum
 from inflection import singularize
 
-from fastapi_startkit.masoniteorm.models import registry
-from .BaseRelationship import BaseRelationship
+from .BaseRelationship import BaseRelationship, ManyResult, TModel
 from ..collection import Collection
 from ..models.pivot import Pivot
 
 
-class BelongsToMany(BaseRelationship):
+class BelongsToMany(BaseRelationship[TModel, ManyResult[TModel]]):
     """Has Many Relationship Class."""
 
     def __init__(
         self,
-        fn: str,
+        fn: str | None = None,
         local_foreign_key=None,
         other_foreign_key=None,
         local_owner_key=None,
@@ -23,7 +22,7 @@ class BelongsToMany(BaseRelationship):
         attribute="pivot",
         with_fields=[],
     ):
-        self.fn = lambda: registry.Registry.resolve(fn)
+        self.bind_model(fn)
 
         self.local_key = local_foreign_key
         self.foreign_key = other_foreign_key

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/relationships/HasMany.py

@@ -1,8 +1,8 @@
-from .BaseRelationship import BaseRelationship
+from .BaseRelationship import BaseRelationship, ManyResult, TModel
 from ..collection import Collection
 
 
-class HasMany(BaseRelationship):
+class HasMany(BaseRelationship[TModel, ManyResult[TModel]]):
     """Has Many Relationship Class."""
 
     def apply_query(self, foreign, owner):
@@ -26,7 +26,7 @@ class HasMany(BaseRelationship):
         return self
 
     def register_related(self, key, model, collection):
-        model.add_relation({key: collection.get(getattr(model, self.local_key)) or Collection()})
+        model.add_relation({key: Collection(collection.get(getattr(model, self.local_key)) or [])})
 
     def map_related(self, related_result):
         return related_result.group_by(self.foreign_key)

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/relationships/HasManyThrough.py

@@ -1,9 +1,10 @@
 from fastapi_startkit.masoniteorm.models import registry
-from .BaseRelationship import BaseRelationship
+from ..exceptions import LazyLoadingViolation
+from .BaseRelationship import BaseRelationship, ManyResult, TModel
 from ..collection import Collection
 
 
-class HasManyThrough(BaseRelationship):
+class HasManyThrough(BaseRelationship[TModel, ManyResult[TModel]]):
     """HasManyThrough Relationship Class."""
 
     def __init__(
@@ -43,18 +44,14 @@ class HasManyThrough(BaseRelationship):
         self.other_owner_key = self.other_owner_key or "id"
         return self
 
-    def __get__(self, instance, owner):
+    def access(self, instance, owner):
         if instance is None or not instance.is_loaded():
             return self
 
         if instance.relationship_loaded(self.attribute):
             return instance.get_relationship(self.attribute)
 
-        return self.apply_related_query(
-            distant_builder=self.get_distance_builder(),
-            intermediary_builder=self.get_intermediary_builder(),
-            owner=instance,
-        )
+        raise LazyLoadingViolation(instance, self.attribute)
 
     def apply_related_query(self, distant_builder, intermediary_builder, owner):
         distant_table = distant_builder.get_table_name()
@@ -96,11 +93,11 @@ class HasManyThrough(BaseRelationship):
         return builder
 
     def register_related(self, key, model, collection):
-        related = collection.get(getattr(model, self.local_owner_key), None)
-        if related and not isinstance(related, Collection):
+        related = collection.get(getattr(model, self.local_owner_key)) or Collection()
+        if not isinstance(related, Collection):
             related = Collection(related)
 
-        model.add_relation({key: related if related else None})
+        model.add_relation({key: related})
 
     async def get_related(self, query, relation, eagers=None, callback=None):
         distant_builder = self.get_distance_builder()

{fastapi_startkit-0.63.0 → fastapi_startkit-0.64.0}/src/fastapi_startkit/masoniteorm/relationships/HasOne.py

@@ -1,13 +1,12 @@
 from ..collection import Collection
-from .BaseRelationship import BaseRelationship
-from fastapi_startkit.masoniteorm.models import registry
+from .BaseRelationship import BaseRelationship, SingleResult, TModel
 
 
-class HasOne(BaseRelationship):
+class HasOne(BaseRelationship[TModel, SingleResult[TModel]]):
     """Has One Relationship Class."""
 
-    def __init__(self, fn: str, foreign_key=None, local_key=None):
-        self.fn = lambda: registry.Registry.resolve(fn)
+    def __init__(self, fn: str | None = None, foreign_key=None, local_key=None):
+        self.bind_model(fn)
 
         self.local_key = local_key or "id"
         self.foreign_key = foreign_key