orionis 0.405.0__py3-none-any.whl → 0.406.0__py3-none-any.whl

orionis/foundation/config/session/entities/session.py

@@ -1,12 +1,13 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from typing import Optional
 from orionis.foundation.exceptions import OrionisIntegrityException
 from orionis.foundation.config.session.enums import SameSitePolicy
 from orionis.foundation.config.session.helpers.secret_key import SecretKey
 from orionis.services.environment.env import Env
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Session:
+class Session(BaseEntity):
     """
     Configuration for Starlette session middleware.
 
@@ -19,58 +20,58 @@ class Session:
         https_only (bool): Restrict cookies to HTTPS. Defaults to False.
         domain (Optional[str]): Cookie domain for cross-subdomain usage.
     """
+
     secret_key: str = field(
-        default_factory=lambda: Env.get('APP_KEY', SecretKey.random()),
-        metadata={
+        default = Env.get('APP_KEY', SecretKey.random()),
+        metadata = {
             "description": "Secret key for signing session cookies (required).",
-            "default": "APP_KEY"
+            "default": SecretKey.random()
         }
     )
 
     session_cookie: str = field(
-        default_factory=lambda: Env.get('SESSION_COOKIE_NAME', 'orionis_session'),
-        metadata={
+        default = Env.get('SESSION_COOKIE_NAME', 'orionis_session'),
+        metadata = {
             "description": "Name of the session cookie.",
-            "default": "orionis_session"
+            "default": 'orionis_session'
         }
     )
 
     max_age: Optional[int] = field(
-        default_factory=lambda: Env.get('SESSION_MAX_AGE', 30*60),
-        metadata={
+        default = Env.get('SESSION_MAX_AGE', 30 * 60),
+        metadata = {
             "description": "Session expiration in seconds. None for browser session.",
-            "default": "1800 (30 minutes)"
+            "default": 30 * 60
         }
     )
 
     same_site: str | SameSitePolicy = field(
-        default_factory=lambda: Env.get('SESSION_SAME_SITE', SameSitePolicy.LAX),
-        metadata={
+        default = Env.get('SESSION_SAME_SITE', SameSitePolicy.LAX.value),
+        metadata = {
             "description": "SameSite cookie policy.",
-            "options": ["lax", "strict", "none"],
-            "default": "lax"
+            "default": SameSitePolicy.LAX.value
         }
     )
 
     path: str = field(
-        default_factory=lambda: Env.get('SESSION_PATH', '/'),
-        metadata={
+        default = Env.get('SESSION_PATH', '/'),
+        metadata = {
             "description": "Cookie path.",
             "default": "/"
         }
     )
 
     https_only: bool = field(
-        default_factory=lambda: Env.get('SESSION_HTTPS_ONLY', False),
-        metadata={
+        default = Env.get('SESSION_HTTPS_ONLY', False),
+        metadata = {
             "description": "Restrict cookies to HTTPS.",
             "default": False
         }
     )
 
     domain: Optional[str] = field(
-        default_factory=lambda: Env.get('SESSION_DOMAIN'),
-        metadata={
+        default = Env.get('SESSION_DOMAIN'),
+        metadata = {
             "description": "Cookie domain for cross-subdomain usage.",
             "default": None
         }
@@ -134,35 +135,4 @@ class Session:
             if self.domain.startswith('.') or self.domain.endswith('.'):
                 raise OrionisIntegrityException("domain must not start or end with a dot")
             if '..' in self.domain:
-                raise OrionisIntegrityException("domain must not contain consecutive dots")
-
-    def toDict(self) -> dict:
-        """
-        Converts the Session entity instance into a dictionary.
-
-        Returns:
-            dict: A dictionary representation of the Session instance, with all fields serialized.
-        """
-        return asdict(self)
-
-    def getFields(self):
-        """
-        Retrieves a list of field information for the current dataclass instance.
-
-        Returns:
-            list: A list of dictionaries, each containing details about a field:
-                - name (str): The name of the field.
-                - type (type): The type of the field.
-                - default: The default value of the field, if specified; otherwise, the value from metadata or None.
-                - metadata (mapping): The metadata associated with the field.
-        """
-        __fields = []
-        for field in fields(self):
-            __metadata = dict(field.metadata) or {}
-            __fields.append({
-                "name": field.name,
-                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
-                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
-                "metadata": __metadata
-            })
-        return __fields
+                raise OrionisIntegrityException("domain must not contain consecutive dots")

orionis/foundation/config/startup.py

@@ -1,225 +1,255 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.config.app.entities.app import App
 from orionis.foundation.config.auth.entities.auth import Auth
 from orionis.foundation.config.cache.entities.cache import Cache
 from orionis.foundation.config.cors.entities.cors import Cors
 from orionis.foundation.config.database.entities.database import Database
-from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.foundation.config.roots.paths import Paths
+from orionis.foundation.exceptions.integrity import OrionisIntegrityException
 from orionis.foundation.config.filesystems.entitites.filesystems import Filesystems
 from orionis.foundation.config.logging.entities.logging import Logging
 from orionis.foundation.config.mail.entities.mail import Mail
 from orionis.foundation.config.queue.entities.queue import Queue
-from orionis.foundation.config.roots.paths import Paths
 from orionis.foundation.config.session.entities.session import Session
 from orionis.foundation.config.testing.entities.testing import Testing
+from orionis.support.entities.base import BaseEntity
 
-@dataclass
-class Configuration:
+@dataclass(unsafe_hash=True, kw_only=True)
+class Configuration(BaseEntity):
     """
-    Configuration class encapsulates all major configuration sections for the application.
-    Attributes:
-        paths (Paths): Paths configuration settings.
-        app (App): Application configuration settings.
-        auth (Auth): Authentication configuration settings.
-        cache (Cache): Cache configuration settings.
-        cors (Cors): CORS configuration settings.
-        database (Database): Database configuration settings.
-        filesystems (Filesystems): Filesystem configuration settings.
-        logging (Logging): Logging configuration settings.
-        mail (Mail): Mail configuration settings.
-        queue (Queue): Queue configuration settings.
-        session (Session): Session configuration settings.
-        testing (Testing): Testing configuration settings.
+    Main configuration dataclass for Orionis Framework startup.
+
+    Parameters
+    ----------
+    app : App or dict, optional
+        Application configuration settings.
+    auth : Auth or dict, optional
+        Authentication configuration settings.
+    cache : Cache or dict, optional
+        Cache configuration settings.
+    cors : Cors or dict, optional
+        CORS configuration settings.
+    database : Database or dict, optional
+        Database configuration settings.
+    filesystems : Filesystems or dict, optional
+        Filesystem configuration settings.
+    logging : Logging or dict, optional
+        Logging configuration settings.
+    mail : Mail or dict, optional
+        Mail configuration settings.
+    path : Paths or dict, optional
+        Path configuration settings.
+    queue : Queue or dict, optional
+        Queue configuration settings.
+    session : Session or dict, optional
+        Session configuration settings.
+    testing : Testing or dict, optional
+        Testing configuration settings.
+
+    Raises
+    ------
+    OrionisIntegrityException
+        If any configuration section is initialized with an invalid type.
     """
-    paths : Paths = field(
-        default_factory=Paths,
-        metadata={
-            "description": "Paths configuration settings."
+
+    app : App | dict = field(
+        default_factory = lambda: App(),
+        metadata = {
+            "description": "Application configuration settings.",
+            "default": App().toDict()
         }
     )
 
-    app : App = field(
-        default_factory=App,
-        metadata={
-            "description": "Application configuration settings."
+    auth : Auth | dict = field(
+        default_factory = lambda: Auth(),
+        metadata = {
+            "description": "Authentication configuration settings.",
+            "default": Auth().toDict()
         }
     )
 
-    auth : Auth = field(
-        default_factory=Auth,
-        metadata={
-            "description": "Authentication configuration settings."
+    cache : Cache | dict = field(
+        default_factory = lambda: Cache(),
+        metadata = {
+            "description": "Cache configuration settings.",
+            "default": Cache().toDict()
         }
     )
 
-    cache : Cache = field(
-        default_factory=Cache,
-        metadata={
-            "description": "Cache configuration settings."
+    cors : Cors | dict = field(
+        default_factory = lambda: Cors(),
+        metadata = {
+            "description": "CORS configuration settings.",
+            "default": Cors().toDict()
         }
     )
 
-    cors : Cors = field(
-        default_factory=Cors,
-        metadata={
-            "description": "CORS configuration settings."
+    database : Database | dict = field(
+        default_factory = lambda: Database(),
+        metadata = {
+            "description": "Database configuration settings.",
+            "default": Database().toDict()
         }
     )
 
-    database : Database = field(
-        default_factory=Database,
-        metadata={
-            "description": "Database configuration settings."
+    filesystems : Filesystems | dict = field(
+        default_factory = lambda: Filesystems(),
+        metadata = {
+            "description": "Filesystem configuration settings.",
+            "default": Filesystems().toDict()
         }
     )
 
-    filesystems : Filesystems = field(
-        default_factory=Filesystems,
-        metadata={
-            "description": "Filesystem configuration settings."
+    logging : Logging | dict = field(
+        default_factory = lambda: Logging(),
+        metadata = {
+            "description": "Logging configuration settings.",
+            "default": Logging().toDict()
         }
     )
 
-    logging : Logging = field(
-        default_factory=Logging,
-        metadata={
-            "description": "Logging configuration settings."
+    mail : Mail | dict = field(
+        default_factory = lambda: Mail(),
+        metadata = {
+            "description": "Mail configuration settings.",
+            "default": Mail().toDict()
         }
     )
 
-    mail : Mail = field(
-        default_factory=Mail,
+    path : Paths | dict = field(
+        default_factory = lambda: Paths(),
         metadata={
-            "description": "Mail configuration settings."
+            "description": "Path configuration settings.",
+            "default": Paths().toDict()
         }
     )
 
-    queue : Queue = field(
-        default_factory=Queue,
-        metadata={
-            "description": "Queue configuration settings."
+    queue : Queue | dict = field(
+        default_factory = lambda: Queue(),
+        metadata = {
+            "description": "Queue configuration settings.",
+            "default": Queue().toDict()
         }
     )
 
-    session : Session = field(
-        default_factory=Session,
-        metadata={
-            "description": "Session configuration settings."
+    session : Session | dict = field(
+        default_factory = lambda: Session(),
+        metadata = {
+            "description": "Session configuration settings.",
+            "default": Session().toDict()
         }
     )
 
-    testing : Testing = field(
-        default_factory=Testing,
-        metadata={
-            "description": "Testing configuration settings."
+    testing : Testing | dict = field(
+        default_factory = lambda: Testing(),
+        metadata = {
+            "description": "Testing configuration settings.",
+            "default": Testing().toDict()
         }
     )
 
     def __post_init__(self):
         """
-        Validates the types of the configuration attributes after initialization.
-        Raises:
-            OrionisIntegrityException: If any of the following attributes are not instances of their expected types:
-                - paths (Paths)
-                - app (App)
-                - auth (Auth)
-                - cache (Cache)
-                - cors (Cors)
-                - database (Database)
-                - filesystems (Filesystems)
-                - logging (Logging)
-                - mail (Mail)
-                - queue (Queue)
-                - session (Session)
-                - testing (Testing)
+        Validates and converts configuration attributes to their respective entity types.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If any attribute is not an instance of the expected type or a dictionary.
         """
 
-        if not isinstance(self.paths, Paths):
+        # Validate `app` attribute
+        if not isinstance(self.app, (App, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'paths': expected Paths, got {type(self.paths).__name__}"
+                f"Invalid type for 'app': expected App or dict, got {type(self.app).__name__}"
             )
+        if isinstance(self.app, dict):
+            self.app = App(**self.app)
 
-        if not isinstance(self.app, App):
+        # Validate `auth` attribute
+        if not isinstance(self.auth, (Auth, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'app': expected App, got {type(self.app).__name__}"
+                f"Invalid type for 'auth': expected Auth or dict, got {type(self.auth).__name__}"
             )
+        if isinstance(self.auth, dict):
+            self.auth = Auth(**self.auth)
 
-        if not isinstance(self.auth, Auth):
+        # Validate `cache` attribute
+        if not isinstance(self.cache, (Cache, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'auth': expected Auth, got {type(self.auth).__name__}"
+                f"Invalid type for 'cache': expected Cache or dict, got {type(self.cache).__name__}"
             )
+        if isinstance(self.cache, dict):
+            self.cache = Cache(**self.cache)
 
-        if not isinstance(self.cache, Cache):
+        # Validate `cors` attribute
+        if not isinstance(self.cors, (Cors, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'cache': expected Cache, got {type(self.cache).__name__}"
+                f"Invalid type for 'cors': expected Cors or dict, got {type(self.cors).__name__}"
             )
+        if isinstance(self.cors, dict):
+            self.cors = Cors(**self.cors)
 
-        if not isinstance(self.cors, Cors):
+        # Validate `database` attribute
+        if not isinstance(self.database, (Database, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'cors': expected Cors, got {type(self.cors).__name__}"
+                f"Invalid type for 'database': expected Database or dict, got {type(self.database).__name__}"
             )
+        if isinstance(self.database, dict):
+            self.database = Database(**self.database)
 
-        if not isinstance(self.database, Database):
+        # Validate `filesystems` attribute
+        if not isinstance(self.filesystems, (Filesystems, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'database': expected Database, got {type(self.database).__name__}"
+                f"Invalid type for 'filesystems': expected Filesystems or dict, got {type(self.filesystems).__name__}"
             )
+        if isinstance(self.filesystems, dict):
+            self.filesystems = Filesystems(**self.filesystems)
 
-        if not isinstance(self.filesystems, Filesystems):
+        # Validate `logging` attribute
+        if not isinstance(self.logging, (Logging, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'filesystems': expected Filesystems, got {type(self.filesystems).__name__}"
+                f"Invalid type for 'logging': expected Logging or dict, got {type(self.logging).__name__}"
             )
+        if isinstance(self.logging, dict):
+            self.logging = Logging(**self.logging)
 
-        if not isinstance(self.logging, Logging):
+        # Validate `mail` attribute
+        if not isinstance(self.mail, (Mail, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'logging': expected Logging, got {type(self.logging).__name__}"
+                f"Invalid type for 'mail': expected Mail or dict, got {type(self.mail).__name__}"
             )
+        if isinstance(self.mail, dict):
+            self.mail = Mail(**self.mail)
 
-        if not isinstance(self.mail, Mail):
+        # Validate `path` attribute
+        if not isinstance(self.path, (Paths, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'mail': expected Mail, got {type(self.mail).__name__}"
+                f"Invalid type for 'path': expected Paths or dict, got {type(self.path).__name__}"
             )
+        if isinstance(self.path, dict):
+            self.path = Paths(**self.path)
 
-        if not isinstance(self.queue, Queue):
+        # Validate `queue` attribute
+        if not isinstance(self.queue, (Queue, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'queue': expected Queue, got {type(self.queue).__name__}"
+                f"Invalid type for 'queue': expected Queue or dict, got {type(self.queue).__name__}"
             )
+        if isinstance(self.queue, dict):
+            self.queue = Queue(**self.queue)
 
-        if not isinstance(self.session, Session):
+        # Validate `session` attribute
+        if not isinstance(self.session, (Session, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'session': expected Session, got {type(self.session).__name__}"
+                f"Invalid type for 'session': expected Session or dict, got {type(self.session).__name__}"
             )
+        if isinstance(self.session, dict):
+            self.session = Session(**self.session)
 
-        if not isinstance(self.testing, Testing):
+        # Validate `testing` attribute
+        if not isinstance(self.testing, (Testing, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'testing': expected Testing, got {type(self.testing).__name__}"
+                f"Invalid type for 'testing': expected Testing or dict, got {type(self.testing).__name__}"
             )
-
-    def toDict(self) -> dict:
-        """
-        Convert the object to a dictionary representation.
-        Returns:
-            dict: A dictionary representation of the Dataclass object.
-        """
-        return asdict(self)
-
-    def getFields(self):
-        """
-        Retrieves a list of field information for the current dataclass instance.
-
-        Returns:
-            list: A list of dictionaries, each containing details about a field:
-                - name (str): The name of the field.
-                - type (type): The type of the field.
-                - default: The default value of the field, if specified; otherwise, the value from metadata or None.
-                - metadata (mapping): The metadata associated with the field.
-        """
-        __fields = []
-        for field in fields(self):
-            __metadata = dict(field.metadata) or {}
-            __fields.append({
-                "name": field.name,
-                "type": field.type.__name__ if hasattr(field.type, '__name__') else str(field.type),
-                "default": field.default if (field.default is not None and '_MISSING_TYPE' not in str(field.default)) else __metadata.get('default', None),
-                "metadata": __metadata
-            })
-        return __fields
+        if isinstance(self.testing, dict):
+            self.testing = Testing(**self.testing)