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

orionis/foundation/config/cors/entities/cors.py

@@ -1,11 +1,13 @@
-from dataclasses import dataclass, field, asdict, fields
+from dataclasses import dataclass, field
 from typing import List, Optional
 from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Cors:
+class Cors(BaseEntity):
     """
     CORS configuration compatible with Starlette CORSMiddleware.
+
     Attributes:
         allow_origins (List[str]): List of allowed origins. Use ["*"] to allow all origins.
         allow_origin_regex (Optional[str]): Regular expression to match allowed origins.
@@ -14,6 +16,7 @@ class Cors:
         expose_headers (List[str]): List of headers exposed to the browser.
         allow_credentials (bool): Whether to allow credentials (cookies, authorization headers, etc.).
         max_age (Optional[int]): Maximum time (in seconds) for the preflight request to be cached.
+
     Methods:
         __post_init__():
             Validates the types of the configuration attributes after initialization.
@@ -22,58 +25,58 @@ class Cors:
     """
 
     allow_origins: List[str] = field(
-        default_factory=lambda: ["*"],
-        metadata={
+        default_factory = lambda: ["*"],
+        metadata = {
             "description": "List of allowed origins. Use [\"*\"] to allow all origins.",
-            "deafault": ["*"],
+            "deafault": ["*"]
         },
     )
 
     allow_origin_regex: Optional[str] = field(
-        default=None,
-        metadata={
+        default = None,
+        metadata = {
             "description": "Regular expression pattern to match allowed origins.",
-            "default": None,
+            "default": None
         },
     )
 
     allow_methods: List[str] = field(
-        default_factory=lambda: ["*"],
-        metadata={
+        default_factory = lambda: ["*"],
+        metadata = {
             "description": "List of allowed HTTP methods. Use [\"*\"] to allow all methods.",
-            "default": ["*"],
+            "default": ["*"]
         },
     )
 
     allow_headers: List[str] = field(
-        default_factory=lambda: ["*"],
-        metadata={
+        default_factory = lambda: ["*"],
+        metadata = {
             "description": "List of allowed HTTP headers. Use [\"*\"] to allow all headers.",
-            "default": ["*"],
+            "default": ["*"]
         },
     )
 
     expose_headers: List[str] = field(
-        default_factory=lambda:[],
-        metadata={
+        default_factory = lambda: [],
+        metadata = {
             "description": "List of headers exposed to the browser.",
-            "default": [],
+            "default": []
         },
     )
 
     allow_credentials: bool = field(
-        default=False,
-        metadata={
+        default = False,
+        metadata = {
             "description": "Whether to allow credentials (cookies, authorization headers, etc.).",
-            "default": False,
+            "default": False
         },
     )
 
     max_age: Optional[int] = field(
-        default=600,
-        metadata={
+        default = 600,
+        metadata = {
             "description": "Maximum time (in seconds) for preflight request caching.",
-            "default": 600,
+            "default": 600
         },
     )
 
@@ -91,61 +94,45 @@ class Cors:
                 - allow_credentials is not a boolean.
                 - max_age is not an integer or None.
         """
+
+        # Validate `allow_origins` attribute
         if not isinstance(self.allow_origins, list):
             raise OrionisIntegrityException(
                 "Invalid type for 'allow_origins': expected a list of strings."
             )
+
+        # Validate `allow_origin_regex` attribute
         if self.allow_origin_regex is not None and not isinstance(self.allow_origin_regex, str):
             raise OrionisIntegrityException(
                 "Invalid type for 'allow_origin_regex': expected a string or None."
             )
+
+        # Validate `allow_methods` attribute
         if not isinstance(self.allow_methods, list):
             raise OrionisIntegrityException(
                 "Invalid type for 'allow_methods': expected a list of strings."
             )
+
+        # Validate `allow_headers` attribute
         if not isinstance(self.allow_headers, list):
             raise OrionisIntegrityException(
                 "Invalid type for 'allow_headers': expected a list of strings."
             )
+
+        # Validate `expose_headers` attribute
         if not isinstance(self.expose_headers, list):
             raise OrionisIntegrityException(
                 "Invalid type for 'expose_headers': expected a list of strings."
             )
+
+        # Validate `allow_credentials` attribute
         if not isinstance(self.allow_credentials, bool):
             raise OrionisIntegrityException(
                 "Invalid type for 'allow_credentials': expected a boolean."
             )
+
+        # Validate `max_age` attribute
         if self.max_age is not None and not isinstance(self.max_age, int):
             raise OrionisIntegrityException(
                 "Invalid type for 'max_age': expected an integer or None."
-            )
-
-    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
+            )

orionis/foundation/config/database/entities/connections.py

@@ -1,12 +1,13 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.config.database.entities.mysql import MySQL
 from orionis.foundation.config.database.entities.oracle import Oracle
 from orionis.foundation.config.database.entities.pgsql import PGSQL
 from orionis.foundation.config.database.entities.sqlite import SQLite
 from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Connections:
+class Connections(BaseEntity):
     """
     Data class to represent all database connections used by the application.
 
@@ -21,35 +22,35 @@ class Connections:
     oracle : Oracle
         Configuration for the Oracle database connection.
     """
-    sqlite: SQLite = field(
-        default_factory=SQLite,
-        metadata={
+    sqlite: SQLite | dict = field(
+        default_factory = lambda: SQLite(),
+        metadata = {
             "description": "SQLite database connection configuration",
-            "default": "SQLite()"
+            "default": SQLite().toDict()
         }
     )
 
-    mysql: MySQL = field(
-        default_factory=MySQL,
-        metadata={
+    mysql: MySQL | dict = field(
+        default_factory = lambda: MySQL(),
+        metadata = {
             "description": "MySQL database connection configuration",
-            "default": "MySQL()"
+            "default": MySQL().toDict()
         }
     )
 
-    pgsql: PGSQL = field(
-        default_factory=PGSQL,
-        metadata={
+    pgsql: PGSQL | dict = field(
+        default_factory = lambda: PGSQL(),
+        metadata = {
             "description": "PostgreSQL database connection configuration",
-            "default": "PGSQL()"
+            "default": PGSQL().toDict()
         }
     )
 
-    oracle: Oracle = field(
-        default_factory=Oracle,
-        metadata={
+    oracle: Oracle | dict = field(
+        default_factory = lambda: Oracle(),
+        metadata = {
             "description": "Oracle database connection configuration",
-            "default": "Oracle()"
+            "default": Oracle().toDict()
         }
     )
 
@@ -60,52 +61,35 @@ class Connections:
         Raises:
             OrionisIntegrityException: If any attribute is not an instance of its expected class.
         """
-        if not isinstance(self.sqlite, SQLite):
+
+        # Validate `sqlite` attribute
+        if not isinstance(self.sqlite, (SQLite, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'sqlite': expected 'Sqlite', got '{type(self.sqlite).__name__}'."
+                f"Invalid type for 'sqlite': expected 'SQLite' or 'dict', got '{type(self.sqlite).__name__}'."
             )
+        if isinstance(self.sqlite, dict):
+            self.sqlite = SQLite(**self.sqlite)
 
-        if not isinstance(self.mysql, MySQL):
+        # Validate `mysql` attribute
+        if not isinstance(self.mysql, (MySQL, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'mysql': expected 'Mysql', got '{type(self.mysql).__name__}'."
+                f"Invalid type for 'mysql': expected 'MySQL' or 'dict', got '{type(self.mysql).__name__}'."
             )
+        if isinstance(self.mysql, dict):
+            self.mysql = MySQL(**self.mysql)
 
-        if not isinstance(self.pgsql, PGSQL):
+        # Validate `pgsql` attribute
+        if not isinstance(self.pgsql, (PGSQL, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'pgsql': expected 'Pgsql', got '{type(self.pgsql).__name__}'."
+                f"Invalid type for 'pgsql': expected 'PGSQL' or 'dict', got '{type(self.pgsql).__name__}'."
             )
+        if isinstance(self.pgsql, dict):
+            self.pgsql = PGSQL(**self.pgsql)
 
-        if not isinstance(self.oracle, Oracle):
+        # Validate `oracle` attribute
+        if not isinstance(self.oracle, (Oracle, dict)):
             raise OrionisIntegrityException(
-                f"Invalid type for 'oracle': expected 'Oracle', got '{type(self.oracle).__name__}'."
+                f"Invalid type for 'oracle': expected 'Oracle' or 'dict', got '{type(self.oracle).__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.oracle, dict):
+            self.oracle = Oracle(**self.oracle)

orionis/foundation/config/database/entities/database.py

@@ -1,10 +1,11 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field, fields
 from orionis.foundation.config.database.entities.connections import Connections
 from orionis.services.environment.env import Env
 from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class Database:
+class Database(BaseEntity):
     """
     Data class to represent the general database configuration.
 
@@ -16,18 +17,18 @@ class Database:
         The different database connections available to the application.
     """
     default: str = field(
-        default_factory=lambda: Env.get("DB_CONNECTION", "sqlite"),
+        default = Env.get("DB_CONNECTION", "sqlite"),
         metadata={
             "description": "Default database connection name",
             "default": "sqlite"
         }
     )
 
-    connections: Connections = field(
-        default_factory=Connections,
+    connections: Connections | dict = field(
+        default_factory = lambda: Connections(),
         metadata={
             "description": "Database connections",
-            "default": "Connections()"
+            "default": Connections().toDict()
         }
     )
 
@@ -50,35 +51,7 @@ class Database:
             raise OrionisIntegrityException(f"The 'default' attribute cannot be empty. Options are: {str(options)}")
 
         # Validate connections attribute
-        if not self.connections or not isinstance(self.connections, Connections):
-            raise OrionisIntegrityException("The 'connections' attribute must be of type Connections.")
-
-    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 not self.connections or not isinstance(self.connections, (Connections, dict)):
+            raise OrionisIntegrityException("The 'connections' attribute must be an instance of Connections or a non-empty dictionary.")
+        if isinstance(self.connections, dict):
+            self.connections = Connections(**self.connections)

orionis/foundation/config/database/entities/mysql.py

@@ -1,4 +1,4 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from typing import Optional
 from orionis.foundation.config.database.enums import (
     MySQLCharset,
@@ -7,9 +7,10 @@ from orionis.foundation.config.database.enums import (
 )
 from orionis.foundation.exceptions import OrionisIntegrityException
 from orionis.services.environment.env import Env
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class MySQL:
+class MySQL(BaseEntity):
     """
     Data class to represent the MySQL database configuration.
 
@@ -44,107 +45,106 @@ class MySQL:
     """
 
     driver: str = field(
-        default="mysql",
-        metadata={
+        default = "mysql",
+        metadata = {
             "description": "The database driver being used.",
-            "default": "mysql",
+            "default": "mysql"
         }
     )
 
     host: str = field(
-        default_factory=lambda: Env.get("DB_HOST", "127.0.0.1"),
-        metadata={
+        default = Env.get("DB_HOST", "127.0.0.1"),
+        metadata = {
             "description": "The host address for the MySQL server.",
-            "default": "127.0.0.1",
+            "default": "127.0.0.1"
         }
     )
 
     port: int = field(
-        default_factory=lambda: Env.get("DB_PORT", 3306),
-        metadata={
+        default = Env.get("DB_PORT", 3306),
+        metadata = {
             "description": "The port for connecting to the MySQL server.",
-            "default": 3306,
+            "default": 3306
         }
     )
 
     database: str = field(
-        default_factory=lambda: Env.get("DB_DATABASE", "orionis"),
-        metadata={
+        default = Env.get("DB_DATABASE", "orionis"),
+        metadata = {
             "description": "The name of the MySQL database.",
-            "default": "orionis",
+            "default": "orionis"
         }
     )
 
     username: str = field(
-        default_factory=lambda: Env.get("DB_USERNAME", "root"),
-        metadata={
+        default = Env.get("DB_USERNAME", "root"),
+        metadata = {
             "description": "The username for connecting to the MySQL database.",
-            "default": "root",
+            "default": "root"
         }
     )
 
     password: str = field(
-        default_factory=lambda: Env.get("DB_PASSWORD", ""),
-        metadata={
+        default = Env.get("DB_PASSWORD", ""),
+        metadata = {
             "description": "The password for the MySQL database.",
-            "default": "secret",
+            "default": ""
         }
     )
 
     unix_socket: str = field(
-        default_factory=lambda: Env.get("DB_SOCKET", ""),
-        metadata={
+        default = Env.get("DB_SOCKET", ""),
+        metadata = {
             "description": "The path to the Unix socket for MySQL connections (optional).",
-            "default": "",
+            "default": ""
         }
     )
 
     charset: str | MySQLCharset = field(
-        default=MySQLCharset.UTF8MB4,
-        metadata={
+        default = MySQLCharset.UTF8MB4.value,
+        metadata = {
             "description": "The charset used for the connection.",
-            "default": "utf8mb4",
+            "default": MySQLCharset.UTF8MB4.value
         }
     )
 
     collation: str | MySQLCollation = field(
-        default=MySQLCollation.UTF8MB4_UNICODE_CI,
-        metadata={
+        default = MySQLCollation.UTF8MB4_UNICODE_CI.value,
+        metadata = {
             "description": "The collation for the database.",
-            "default": "utf8mb4_unicode_ci",
+            "default": MySQLCollation.UTF8MB4_UNICODE_CI.value
         }
     )
 
     prefix: str = field(
-        default="",
-        metadata={
+        default = "",
+        metadata = {
             "description": "Prefix for table names.",
-            "default": "",
+            "default": ""
         }
     )
 
     prefix_indexes: bool = field(
-        default=True,
-        metadata={
+        default = True,
+        metadata = {
             "description": "Whether to prefix index names.",
-            "default": True,
+            "default": True
         }
     )
 
     strict: bool = field(
-        default=True,
-        metadata={
+        default = True,
+        metadata = {
             "description": "Whether to enforce strict SQL mode.",
-            "default": True,
+            "default": True
         }
     )
 
-    engine: Optional[str | MySQLEngine] = field(
-        default=MySQLEngine.INNODB,
-        metadata={
+    engine: str | MySQLEngine = field(
+        default = MySQLEngine.INNODB.value,
+        metadata = {
             "description": "The storage engine for the MySQL database (optional).",
-            "default": MySQLEngine.INNODB,
-            "type": str,
+            "default": MySQLEngine.INNODB.value
         }
     )
 
@@ -154,6 +154,7 @@ class MySQL:
         This method performs comprehensive validation on the instance attributes to ensure
         that all required fields are present and correctly typed. It raises an
         OrionisIntegrityException with a descriptive message if any validation fails.
+
         Validations performed:
         - Host: Must be a non-empty string.
         - Port: Must be an integer between 1 and 65535.
@@ -167,12 +168,13 @@ class MySQL:
         - Prefix indexes: Must be a boolean.
         - Strict: Must be a boolean.
         - Engine: If provided, must be a string.
+
         Raises:
             OrionisIntegrityException: If any attribute fails validation.
         """
 
         # Validate driver
-        if self.driver != 'mysql':
+        if self.driver not in ['mysql']:
             raise OrionisIntegrityException("Invalid driver: expected 'mysql'. Please ensure the 'driver' attribute is set to 'mysql'.")
 
         # Validate host
@@ -180,7 +182,7 @@ class MySQL:
             raise OrionisIntegrityException("Database host must be a non-empty string.")
 
         # Validate port type
-        if not isinstance(self.port, (int)):
+        if not isinstance(self.port, int):
             raise OrionisIntegrityException("Database port must be an integer.")
 
         # Validate port range
@@ -261,34 +263,4 @@ class MySQL:
                 else:
                     self.engine = MySQLEngine[_value].value
             elif isinstance(self.engine, MySQLEngine):
-                self.engine = self.engine.value
-
-    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
+                self.engine = self.engine.value