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

orionis/foundation/config/database/entities/oracle.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 (
     OracleEncoding,
@@ -6,9 +6,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 Oracle:
+class Oracle(BaseEntity):
     """
     Data class to represent Oracle database configuration using oracledb.
 
@@ -37,90 +38,90 @@ class Oracle:
     """
 
     driver: str = field(
-        default="oracle",
-        metadata={
+        default = "oracle",
+        metadata = {
             "description": "The database driver being used, typically 'oracle'.",
             "default": "oracle"
         }
     )
 
     username: str = field(
-        default_factory=lambda: Env.get("DB_USERNAME", "sys"),
-        metadata={
+        default = Env.get("DB_USERNAME", "sys"),
+        metadata = {
             "description": "Oracle DB username.",
             "default": "sys"
         }
     )
 
     password: str = field(
-        default_factory=lambda: Env.get("DB_PASSWORD", ""),
-        metadata={
+        default = Env.get("DB_PASSWORD", ""),
+        metadata = {
             "description": "Oracle DB password.",
             "default": ""
         }
     )
 
     host: str = field(
-        default_factory=lambda: Env.get("DB_HOST", "localhost"),
-        metadata={
+        default = Env.get("DB_HOST", "localhost"),
+        metadata = {
             "description": "Oracle DB host address.",
             "default": "localhost"
         }
     )
 
     port: int = field(
-        default_factory=lambda: Env.get("DB_PORT", 1521),
-        metadata={
+        default = Env.get("DB_PORT", 1521),
+        metadata = {
             "description": "Oracle DB listener port.",
             "default": 1521
         }
     )
 
     service_name: Optional[str] = field(
-        default_factory=lambda: Env.get("DB_SERVICE_NAME", "ORCL"),
-        metadata={
+        default = Env.get("DB_SERVICE_NAME", "ORCL"),
+        metadata = {
             "description": "Service name for Oracle DB.",
             "default": "ORCL"
         }
     )
 
     sid: Optional[str] = field(
-        default_factory=lambda: Env.get("DB_SID", None),
-        metadata={
+        default = Env.get("DB_SID", None),
+        metadata = {
             "description": "SID for Oracle DB.",
             "default": None
         }
     )
 
     dsn: Optional[str] = field(
-        default_factory=lambda: Env.get("DB_DSN", None),
-        metadata={
+        default  = Env.get("DB_DSN", None),
+        metadata = {
             "description": "DSN string (overrides host/port/service/sid).",
             "default": None
         }
     )
 
     tns_name: Optional[str] = field(
-        default_factory=lambda: Env.get("DB_TNS", None),
-        metadata={
+        default = Env.get("DB_TNS", None),
+        metadata = {
             "description": "TNS alias defined in tnsnames.ora file.",
             "default": None
         }
     )
 
     encoding: str | OracleEncoding = field(
-        default_factory=lambda: Env.get("DB_ENCODING", OracleEncoding.AL32UTF8),
-        metadata={
+        default = Env.get("DB_ENCODING", OracleEncoding.AL32UTF8.value),
+        metadata = {
             "description": "Database charset (CHAR/VARCHAR2)",
-            "default": "AL32UTF8"
+            "default": OracleEncoding.AL32UTF8.value
         }
     )
 
     nencoding: str | OracleNencoding = field(
-        default_factory=lambda: Env.get("DB_NENCODING", OracleNencoding.AL32UTF8),
-        metadata={
+        default = Env.get("DB_NENCODING", OracleNencoding.AL32UTF8.value),
+        metadata = {
             "description": "Database charset (NCHAR/NVARCHAR2)",
-            "default": "AL32UTF8"
+            "default": OracleNencoding.AL32UTF8.value
         }
     )
 
@@ -130,6 +131,7 @@ class Oracle:
         This method performs strict validation on the configuration fields required to establish
         an Oracle database connection. It ensures that all necessary parameters are present and
         correctly formatted, raising an `OrionisIntegrityException` if any validation fails.
+
         Validation rules:
         - `driver` must be the string 'oracle'.
         - `username` and `password` must be non-empty strings.
@@ -141,6 +143,7 @@ class Oracle:
             - If provided, `service_name` and `sid` must be non-empty strings or None.
         - `encoding` must be a non-empty string or an instance of `OracleEncoding`.
         - `nencoding` must be a non-empty string.
+
         Raises:
             OrionisIntegrityException: If any configuration parameter is invalid.
         """
@@ -218,34 +221,4 @@ class Oracle:
         elif isinstance(self.nencoding, OracleNencoding):
             self.nencoding = self.nencoding.value
         else:
-            raise OrionisIntegrityException("Invalid 'nencoding': must be a string or OracleNencoding.")
-
-    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
+            raise OrionisIntegrityException("Invalid 'nencoding': must be a string or OracleNencoding.")

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

@@ -1,15 +1,17 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.config.database.enums import (
     PGSQLCharset,
     PGSQLSSLMode
 )
 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 PGSQL:
+class PGSQL(BaseEntity):
     """
     Pgsql database configuration entity.
+
     Attributes:
         driver (str): Database driver type. Default: "pgsql".
         host (str): Database host. Default: value of the environment variable DB_HOST or "127.0.0.1".
@@ -25,90 +27,90 @@ class PGSQL:
     """
 
     driver: str = field(
-        default="pgsql",
-        metadata={
+        default = "pgsql",
+        metadata = {
             "description": "Database driver type",
             "default": "pgsql"
         }
     )
 
     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": "Database host",
             "default": "127.0.0.1"
         }
     )
 
-    port: str = field(
-        default_factory=lambda: Env.get("DB_PORT", "5432"),
-        metadata={
+    port: str | int = field(
+        default = Env.get("DB_PORT", 5432),
+        metadata = {
             "description": "Database port",
-            "default": "5432"
+            "default": 5432
         }
     )
 
     database: str = field(
-        default_factory=lambda: Env.get("DB_DATABASE", "orionis"),
-        metadata={
+        default = Env.get("DB_DATABASE", "orionis"),
+        metadata = {
             "description": "Database name",
             "default": "orionis"
         }
     )
 
     username: str = field(
-        default_factory=lambda: Env.get("DB_USERNAME", "root"),
-        metadata={
+        default = Env.get("DB_USERNAME", "postgres"),
+        metadata = {
             "description": "Database user",
-            "default": "root"
+            "default": "postgres"
         }
     )
 
     password: str = field(
-        default_factory=lambda: Env.get("DB_PASSWORD", ""),
-        metadata={
+        default = Env.get("DB_PASSWORD", ""),
+        metadata = {
             "description": "Database password",
             "default": ""
         }
     )
 
     charset: str | PGSQLCharset = field(
-        default_factory=lambda: Env.get("DB_CHARSET", PGSQLCharset.UTF8),
-        metadata={
+        default = Env.get("DB_CHARSET", PGSQLCharset.UTF8),
+        metadata = {
             "description": "Database charset",
-            "default": "utf8"
+            "default": PGSQLCharset.UTF8.value
         }
     )
 
     prefix: str = field(
-        default="",
-        metadata={
+        default = "",
+        metadata = {
             "description": "Table prefix",
             "default": ""
         }
     )
 
     prefix_indexes: bool = field(
-        default=True,
-        metadata={
+        default = True,
+        metadata = {
             "description": "Whether to prefix indexes",
             "default": True
         }
     )
 
     search_path: str = field(
-        default="public",
-        metadata={
+        default = "public",
+        metadata = {
             "description": "PostgreSQL schema search_path",
             "default": "public"
         }
     )
 
     sslmode: str | PGSQLSSLMode = field(
-        default=PGSQLSSLMode.PREFER,
-        metadata={
+        default = PGSQLSSLMode.PREFER.value,
+        metadata = {
             "description": "Connection SSL mode",
-            "default": PGSQLSSLMode.PREFER
+            "default": PGSQLSSLMode.PREFER.value
         }
     )
 
@@ -132,24 +134,31 @@ class PGSQL:
                 - 'sslmode' is a non-empty string.
         """
 
+        # Validate `driver` attribute
         if not isinstance(self.driver, str) or not self.driver:
             raise OrionisIntegrityException(f"The 'driver' attribute must be a non-empty string. Received: {self.driver!r}")
 
+        # Validate `host` attribute
         if not isinstance(self.host, str) or not self.host.strip():
             raise OrionisIntegrityException(f"The 'host' attribute must be a non-empty string. Received: {self.host!r}")
 
-        if not isinstance(self.port, str) or not self.port.isdigit():
-            raise OrionisIntegrityException(f"The 'port' attribute must be a numeric string. Received: {self.port!r}")
+        # Validate `port` attribute
+        if not (isinstance(self.port, (str, int)) and str(self.port).isdigit()):
+            raise OrionisIntegrityException(f"The 'port' attribute must be a numeric string or integer. Received: {self.port!r}")
 
+        # Validate `database` attribute
         if not isinstance(self.database, str) or not self.database.strip():
             raise OrionisIntegrityException(f"The 'database' attribute must be a non-empty string. Received: {self.database!r}")
 
+        # Validate `username` attribute
         if not isinstance(self.username, str) or not self.username.strip():
             raise OrionisIntegrityException(f"The 'username' attribute must be a non-empty string. Received: {self.username!r}")
 
+        # Validate `password` attribute
         if not isinstance(self.password, str):
             raise OrionisIntegrityException(f"The 'password' attribute must be a string. Received: {self.password!r}")
 
+        # Validate `charset` attribute
         options_charset = PGSQLCharset._member_names_
         if isinstance(self.charset, str):
             _value = self.charset.upper().strip()
@@ -160,18 +169,23 @@ class PGSQL:
         else:
             self.charset = self.charset.value
 
+        # Validate `prefix` attribute
         if not isinstance(self.prefix, str):
             raise OrionisIntegrityException(f"The 'prefix' attribute must be a string. Received: {self.prefix!r}")
 
+        # Validate `prefix_indexes` attribute
         if not isinstance(self.prefix_indexes, bool):
             raise OrionisIntegrityException(f"The 'prefix_indexes' attribute must be boolean. Received: {self.prefix_indexes!r}")
 
+        # Validate `search_path` attribute
         if not isinstance(self.search_path, str) or not self.search_path.strip():
             raise OrionisIntegrityException(f"The 'search_path' attribute must be a non-empty string. Received: {self.search_path!r}")
 
+        # Validate `sslmode` attribute
         if not isinstance(self.sslmode, (str, PGSQLSSLMode)):
             raise OrionisIntegrityException(f"The 'sslmode' attribute must be a string or PGSQLSSLMode. Received: {self.sslmode!r}")
 
+        # Validate `sslmode` attribute
         options_sslmode = PGSQLSSLMode._member_names_
         if isinstance(self.sslmode, str):
             _value = self.sslmode.upper().strip()
@@ -181,33 +195,3 @@ class PGSQL:
                 self.sslmode = PGSQLSSLMode[_value].value
         else:
             self.sslmode = self.sslmode.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

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

@@ -1,4 +1,4 @@
-from dataclasses import asdict, dataclass, field, fields
+from dataclasses import dataclass, field
 from orionis.foundation.config.database.enums import (
     SQLiteForeignKey,
     SQLiteJournalMode,
@@ -6,9 +6,10 @@ from orionis.foundation.config.database.enums import (
 )
 from orionis.foundation.exceptions.integrity import OrionisIntegrityException
 from orionis.services.environment.env import Env
+from orionis.support.entities.base import BaseEntity
 
 @dataclass(unsafe_hash=True, kw_only=True)
-class SQLite:
+class SQLite(BaseEntity):
     """
     Data class to represent the SQLite database configuration.
 
@@ -33,72 +34,73 @@ class SQLite:
     """
 
     driver: str = field(
-        default='sqlite',
-        metadata={
+        default = 'sqlite',
+        metadata = {
             "description": "The database driver being used.",
             "example": "sqlite",
         },
     )
 
     url: str = field(
-        default_factory=lambda: Env.get('DB_URL', 'sqlite:///' + Env.get('DB_DATABASE', 'database/database.sqlite')),
-        metadata={
+        default = Env.get('DB_URL', 'sqlite:///' + Env.get('DB_DATABASE', 'database/database.sqlite')),
+        metadata = {
             "description": "The URL for connecting to the database.",
             "example": "sqlite:///database/database.sqlite",
         },
     )
 
     database: str = field(
-        default_factory=lambda: Env.get('DB_DATABASE', 'database.sqlite'),
-        metadata={
+        default = Env.get('DB_DATABASE', 'database.sqlite'),
+        metadata = {
             "description": "The path to the SQLite database file.",
             "example": "database.sqlite",
         },
     )
 
     prefix: str = field(
-        default_factory=lambda: Env.get('DB_PREFIX', ''),
-        metadata={
+        default = Env.get('DB_PREFIX', ''),
+        metadata = {
             "description": "Prefix for table names.",
             "example": "",
         },
     )
 
     foreign_key_constraints: bool | SQLiteForeignKey = field(
-        default_factory=lambda: Env.get('DB_FOREIGN_KEYS', SQLiteForeignKey.OFF),
-        metadata={
+        default = Env.get('DB_FOREIGN_KEYS', SQLiteForeignKey.OFF.value),
+        metadata = {
             "description": "Whether foreign key constraints are enabled.",
-            "example": 'OFF',
+            "example": SQLiteForeignKey.OFF.value
         },
     )
 
     busy_timeout: int = field(
-        default_factory=lambda: Env.get('DB_BUSY_TIMEOUT', 5000),
-        metadata={
+        default = Env.get('DB_BUSY_TIMEOUT', 5000),
+        metadata = {
             "description": "The timeout period (in milliseconds) before retrying a locked database.",
-            "example": 5000,
+            "example": 5000
         },
     )
 
     journal_mode: str | SQLiteJournalMode = field(
-        default_factory=lambda: Env.get('DB_JOURNAL_MODE', SQLiteJournalMode.DELETE),
-        metadata={
+        default = Env.get('DB_JOURNAL_MODE', SQLiteJournalMode.DELETE.value),
+        metadata = {
             "description": "The journal mode used for transactions.",
-            "example": "DELETE",
+            "example": SQLiteJournalMode.DELETE.value
         },
     )
 
     synchronous: str | SQLiteSynchronous = field(
-        default_factory=lambda: Env.get('DB_SYNCHRONOUS', SQLiteSynchronous.NORMAL),
-        metadata={
+        default = Env.get('DB_SYNCHRONOUS', SQLiteSynchronous.NORMAL.value),
+        metadata = {
             "description": "The synchronization level for the database.",
-            "example": "NORMAL",
+            "example": SQLiteSynchronous.NORMAL.value
         },
     )
 
     def __post_init__(self):
         """
         Post-initialization validation for SQLite database configuration fields.
+
         This method ensures that all configuration attributes are of the correct type and meet required constraints:
         - `driver`: Must be a non-empty string (e.g., 'sqlite').
         - `url`: Must be a non-empty string (e.g., 'sqlite:///database/database.sqlite').
@@ -108,6 +110,7 @@ class SQLite:
         - `busy_timeout`: If provided, must be a non-negative integer (milliseconds) or None.
         - `journal_mode`: If provided, must be a string or None (e.g., 'WAL', 'DELETE').
         - `synchronous`: If provided, must be a string or None (e.g., 'FULL', 'NORMAL', 'OFF').
+
         Raises:
             OrionisIntegrityException: If any attribute fails its validation check.
         """
@@ -169,34 +172,4 @@ class SQLite:
             else:
                 self.synchronous = SQLiteSynchronous[_value].value
         else:
-            self.synchronous = self.synchronous.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.synchronous = self.synchronous.value