orionis 0.253.0__py3-none-any.whl → 0.265.0__py3-none-any.whl

orionis/luminate/{config → foundation/config}/app/entities/app.py

@@ -1,9 +1,9 @@
-from dataclasses import dataclass, field
-from orionis.luminate.config.app.enums.ciphers import Cipher
-from orionis.luminate.config.app.enums.environments import Environments
-from orionis.luminate.config.exceptions.integrity_exception import OrionisIntegrityException
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.app.enums.ciphers import Cipher
+from orionis.luminate.foundation.config.app.enums.environments import Environments
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.luminate.services.environment.env import Env
-from orionis.luminate.services.workers.maximum_workers import MaximumWorkers
+from orionis.luminate.services.system.workers import Workers
 
 @dataclass(unsafe_hash=True, kw_only=True)
 class App:
@@ -31,16 +31,14 @@ class App:
         default_factory=lambda: Env.get('APP_NAME', 'Orionis Application'),
         metadata={
             "description": "The name of the application. Defaults to 'Orionis Application'.",
-            "required": True,
             "default": "Orionis Application"
         }
     )
 
-    env: Environments = field(
+    env: str | Environments = field(
         default_factory=lambda: Env.get('APP_ENV', Environments.DEVELOPMENT),
         metadata={
             "description": "The environment in which the application is running. Defaults to 'DEVELOPMENT'.",
-            "required": True,
             "default": "Environments.DEVELOPMENT"
         }
     )
@@ -49,7 +47,6 @@ class App:
         default_factory=lambda: Env.get('APP_DEBUG', True),
         metadata={
             "description": "Flag indicating whether debug mode is enabled. Defaults to False.",
-            "required": True,
             "default": True
         }
     )
@@ -58,7 +55,6 @@ class App:
         default_factory=lambda: Env.get('APP_URL', 'http://127.0.0.1'),
         metadata={
             "description": "The base URL of the application. Defaults to 'http://127.0.0.1'.",
-            "required": True,
             "default": "http://127.0.0.1"
         }
     )
@@ -67,17 +63,15 @@ class App:
         default_factory=lambda: Env.get('APP_PORT', 8000),
         metadata={
             "description": "The port on which the application will run. Defaults to 8000.",
-            "required": True,
             "default": 8000
         }
     )
 
     workers: int = field(
-        default_factory=lambda: Env.get('APP_WORKERS', MaximumWorkers().calculate()),
+        default_factory=lambda: Env.get('APP_WORKERS', Workers().calculate()),
         metadata={
             "description": "The number of worker processes to handle requests. Defaults to the maximum available workers.",
-            "required": True,
-            "default": "MaximumWorkers.calculate()"
+            "default": "Calculated by Workers()."
         }
     )
 
@@ -85,7 +79,6 @@ class App:
         default_factory=lambda: Env.get('APP_RELOAD', True),
         metadata={
             "description": "Flag indicating whether the application should reload on code changes. Defaults to True.",
-            "required": True,
             "default": True
         }
     )
@@ -94,7 +87,6 @@ class App:
         default_factory=lambda: Env.get('APP_TIMEZONE', 'UTC'),
         metadata={
             "description": "The timezone of the application. Defaults to 'UTC'.",
-            "required": True,
             "default": "UTC"
         }
     )
@@ -103,7 +95,6 @@ class App:
         default_factory=lambda: Env.get('APP_LOCALE', 'en'),
         metadata={
             "description": "The locale for the application. Defaults to 'en'.",
-            "required": True,
             "default": "en"
         }
     )
@@ -112,16 +103,14 @@ class App:
         default_factory=lambda: Env.get('APP_FALLBACK_LOCALE', 'en'),
         metadata={
             "description": "The fallback locale for the application. Defaults to 'en'.",
-            "required": True,
             "default": "en"
         }
     )
 
-    cipher: str = field(
+    cipher: str | Cipher = field(
         default_factory=lambda: Env.get('APP_CIPHER', Cipher.AES_256_CBC),
         metadata={
             "description": "The cipher used for encryption. Defaults to 'AES_256_CBC'.",
-            "required": True,
             "default": "Cipher.AES_256_CBC"
         }
     )
@@ -130,7 +119,6 @@ class App:
         default_factory=lambda: Env.get('APP_KEY'),
         metadata={
             "description": "The encryption key for the application. Defaults to None.",
-            "required": False,
             "default": None
         }
     )
@@ -139,7 +127,6 @@ class App:
         default_factory=lambda: Env.get('APP_MAINTENANCE', '/maintenance'),
         metadata={
             "description": "The maintenance configuration for the application. Defaults to '/maintenance'.",
-            "required": True,
             "default": "/maintenance"
         }
     )
@@ -151,18 +138,21 @@ class App:
         Ensures that all fields have the correct types and values, raising TypeError
         if any field is invalid. This helps catch configuration errors early.
         """
-        if not isinstance(self.name, str) or not self.name.strip():
-            raise OrionisIntegrityException("The 'name' attribute must be a non-empty string of type str.")
-
-        if not isinstance(self.env, Environments):
-            if isinstance(self.env, str):
-                value = str(self.env).strip().upper()
-                if value in Environments._member_names_:
-                    self.env = getattr(Environments, value)
-                else:
-                    raise OrionisIntegrityException(f"Invalid environment value: {self.env}. Must be one of {Environments._member_names_}.")
+
+        # Validate `name` attribute
+        if not isinstance(self.name, (str, Environments)) or not self.name.strip():
+            raise OrionisIntegrityException("The 'name' attribute must be a non-empty string or an Environments instance.")
+
+        # Validate `env` attribute
+        options_env = Environments._member_names_
+        if isinstance(self.env, str):
+            _value = str(self.env).strip().upper()
+            if _value in options_env:
+                self.env = Environments[_value].value
             else:
-                raise OrionisIntegrityException("The 'env' attribute must be of type Environments.")
+                raise OrionisIntegrityException(f"Invalid name value: {self.env}. Must be one of {str(options_env)}.")
+        elif isinstance(self.env, Environments):
+            self.env = self.env.value
 
         if not isinstance(self.debug, bool):
             raise OrionisIntegrityException("The 'debug' attribute must be a boolean.")
@@ -188,18 +178,29 @@ class App:
         if not isinstance(self.fallback_locale, str) or not self.fallback_locale.strip():
             raise OrionisIntegrityException("The 'fallback_locale' attribute must be a non-empty string.")
 
-        if not isinstance(self.cipher, Cipher):
-            if isinstance(self.cipher, str):
-                value = str(self.cipher).strip().upper()
-                if value in Cipher._member_names_:
-                    self.cipher = getattr(Cipher, value)
-                else:
-                    raise OrionisIntegrityException(f"Invalid cipher value: {self.cipher}. Must be one of {Cipher._member_names_}.")
+        options_cipher = Cipher._member_names_
+        if not isinstance(self.cipher, (Cipher, str)):
+            raise OrionisIntegrityException("The 'cipher' attribute must be a Cipher or a string.")
+
+        if isinstance(self.cipher, str):
+            _value = str(self.cipher).strip().upper().replace("-", "_")
+            if _value in options_cipher:
+                self.cipher = Cipher[_value].value
             else:
-                raise OrionisIntegrityException("The 'cipher' attribute must be of type Cipher.")
+                raise OrionisIntegrityException(f"Invalid cipher value: {self.cipher}. Must be one of {options_cipher}.")
+        elif isinstance(self.cipher, Cipher):
+            self.cipher = self.cipher.value
 
         if self.key is not None and not isinstance(self.key, str):
             raise OrionisIntegrityException("The 'key' attribute must be a string or None.")
 
-        if not isinstance(self.maintenance, str):
-            raise OrionisIntegrityException("The 'maintenance' attribute must be a string (A Route).")
+        if not isinstance(self.maintenance, str) or not self.name.strip() or not self.maintenance.startswith('/'):
+            raise OrionisIntegrityException("The 'maintenance' attribute must be a non-empty string representing a valid route (e.g., '/maintenance').")
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)

orionis/luminate/{config → foundation/config}/auth/entities/auth.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 
 @dataclass(unsafe_hash=True, kw_only=True)
 class Auth:
@@ -9,3 +9,11 @@ class Auth:
     Extend this class to implement authentication logic such as user credentials, token management, or session handling.
     """
     pass
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)

orionis/luminate/foundation/config/cache/entities/cache.py

@@ -0,0 +1,74 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.cache.entities.stores import Stores
+from orionis.luminate.foundation.config.cache.enums.drivers import Drivers
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.services.environment.env import Env
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Cache:
+    """
+    Represents the cache configuration for the application.
+    Attributes:
+        default (Drivers | str): The default cache storage type. Can be a member of the Drivers enum or a string
+            (e.g., 'memory', 'file'). Defaults to the value of the 'CACHE_STORE' environment variable or Drivers.MEMORY.
+        stores (Stores): The configuration for available cache stores. Defaults to a Stores instance with a file store
+            at the path specified by the 'CACHE_PATH' environment variable or "storage/framework/cache/data".
+    Methods:
+        __post_init__():
+            - Validates that 'default' is either a Drivers enum member or a string.
+            - Converts 'default' from string to Drivers enum if necessary.
+            - Validates that 'stores' is an instance of Stores.
+    """
+
+    default: Drivers | str = field(
+        default_factory=lambda:Env.get("CACHE_STORE", Drivers.MEMORY),
+        metadata={
+            "description": "The default cache storage type. Can be a member of the Drivers enum or a string (e.g., 'memory', 'file').",
+            "default": "Drivers.MEMORY",
+        },
+    )
+
+    stores: Stores = field(
+        default_factory=Stores,
+        metadata={
+            "description": "The configuration for available cache stores. Defaults to a file store at the specified path.",
+            "default": "file=File(path='storage/framework/cache/data')",
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method for validating and normalizing cache configuration.
+        Ensures that:
+        - The `default` attribute is either an instance of `Drivers` or a string representing a valid driver name.
+        - If `default` is a string, it is converted to the corresponding `Drivers` enum member after validation.
+        - The `stores` attribute is an instance of `Stores`.
+        Raises:
+            OrionisIntegrityException: If `default` is not a valid driver or if `stores` is not an instance of `Stores`.
+        """
+
+        # Validate the 'default' attribute to ensure it is either a Drivers enum member or a string
+        if not isinstance(self.default, (Drivers, str)):
+            raise OrionisIntegrityException("The default cache store must be an instance of Drivers or a string.")
+
+        options_drivers = Drivers._member_names_
+        if isinstance(self.default, str):
+            _value = self.default.upper().strip()
+            if _value not in options_drivers:
+                raise OrionisIntegrityException(f"Invalid cache driver: {self.default}. Must be one of {str(options_drivers)}.")
+            else:
+                self.default = Drivers[_value].value
+        else:
+            self.default = self.default.value
+
+        # Validate the 'stores' attribute to ensure it is an instance of Stores
+        if not isinstance(self.stores, Stores):
+            raise OrionisIntegrityException("The stores must be an instance of Stores.")
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)

orionis/luminate/foundation/config/cache/entities/file.py

@@ -0,0 +1,46 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class File:
+    """
+    Represents the configuration entity for a file-based cache store.
+    Attributes:
+        path (str): The file system path where cache data will be stored. By default, this is set to
+            'storage/framework/cache/data' using a relative path resolver.
+    Methods:
+        __post_init__():
+            Validates the 'path' attribute after dataclass initialization. Raises an
+            OrionisIntegrityException if 'path' is empty or not a string, ensuring correct cache setup.
+    """
+
+    path: str = field(
+        default='storage/framework/cache/data',
+        metadata={
+            "description": "The configuration for available cache stores. Defaults to a file store at the specified path.",
+            "default": "storage/framework/cache/data"
+        },
+    )
+
+    def __post_init__(self):
+        """
+        Validates the 'path' attribute after dataclass initialization.
+
+        Raises:
+            OrionisIntegrityException: If 'path' is empty or not a string, indicating a misconfiguration
+            in the file cache setup.
+        """
+
+        # Validate the 'path' attribute to ensure it is not empty and is a string
+        if not self.path:
+            raise OrionisIntegrityException("File cache configuration error: 'path' cannot be empty. Please provide a valid file path.")
+        if not isinstance(self.path, str):
+            raise OrionisIntegrityException(f"File cache configuration error: 'path' must be a string, got {type(self.path).__name__}.")
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)

orionis/luminate/foundation/config/cache/entities/stores.py

@@ -0,0 +1,46 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.cache.entities.file import File
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Stores:
+    """
+    Represents a collection of cache storage backends for the application.
+    Attributes:
+        file (File): An instance of `File` representing file-based cache storage.
+            The default path is set to 'storage/framework/cache/data', resolved
+            relative to the application's root directory.
+    Methods:
+        __post_init__():
+            Ensures that the 'file' attribute is properly initialized as an instance of `File`.
+            Raises a TypeError if the type check fails.
+    """
+
+    file: File = field(
+        default_factory=File,
+        metadata={
+            "description": "An instance of `File` representing file-based cache storage.",
+            "default": "File(path='storage/framework/cache/data')",
+        },
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method to validate the 'file' attribute.
+
+        Ensures that the 'file' attribute is an instance of the File class.
+        Raises:
+            OrionisIntegrityException: If 'file' is not an instance of File, with a descriptive error message.
+        """
+        if not isinstance(self.file, File):
+            raise OrionisIntegrityException(
+                f"The 'file' attribute must be an instance of File, but got {type(self.file).__name__}."
+            )
+
+    def toDict(self) -> dict:
+        """
+        Convert the object to a dictionary representation.
+        Returns:
+            dict: A dictionary representation of the Dataclass object.
+        """
+        return asdict(self)

orionis/luminate/{contracts/config → foundation/config/contracts}/config.py

@@ -1,14 +1,4 @@
-from abc import ABC
-from dataclasses import dataclass
-
-@dataclass
-class EmptyData:
-    """
-    A placeholder dataclass that can be used as a default or empty configuration.
-    This class doesn't have any fields or data, but serves as a default value
-    for the 'config' attribute in classes implementing IConfig.
-    """
-    pass
+from abc import ABC, abstractmethod
 
 class IConfig(ABC):
     """
@@ -24,4 +14,10 @@ class IConfig(ABC):
         A dataclass instance representing the configuration.
     """
 
-    config = EmptyData()
+    @property
+    @abstractmethod
+    def config(self):
+        """
+        Should return a dataclass instance representing the configuration.
+        """
+        pass

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

@@ -0,0 +1,129 @@
+from dataclasses import dataclass, field, asdict
+from typing import List, Optional
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Cors:
+    """
+    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.
+        allow_methods (List[str]): List of allowed HTTP methods. Use ["*"] to allow all methods.
+        allow_headers (List[str]): List of allowed HTTP headers. Use ["*"] to allow all headers.
+        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.
+            Raises:
+                OrionisIntegrityException: If any attribute does not match the expected type.
+    """
+
+    allow_origins: List[str] = field(
+        default_factory=lambda: ["*"],
+        metadata={
+            "description": "List of allowed origins. Use [\"*\"] to allow all origins.",
+            "deafault": ["*"],
+        },
+    )
+
+    allow_origin_regex: Optional[str] = field(
+        default=None,
+        metadata={
+            "description": "Regular expression pattern to match allowed origins.",
+            "default": None,
+        },
+    )
+
+    allow_methods: List[str] = field(
+        default_factory=lambda: ["*"],
+        metadata={
+            "description": "List of allowed HTTP methods. Use [\"*\"] to allow all methods.",
+            "default": ["*"],
+        },
+    )
+
+    allow_headers: List[str] = field(
+        default_factory=lambda: ["*"],
+        metadata={
+            "description": "List of allowed HTTP headers. Use [\"*\"] to allow all headers.",
+            "default": ["*"],
+        },
+    )
+
+    expose_headers: List[str] = field(
+        default_factory=lambda:[],
+        metadata={
+            "description": "List of headers exposed to the browser.",
+            "default": [],
+        },
+    )
+
+    allow_credentials: bool = field(
+        default=False,
+        metadata={
+            "description": "Whether to allow credentials (cookies, authorization headers, etc.).",
+            "default": False,
+        },
+    )
+
+    max_age: Optional[int] = field(
+        default=600,
+        metadata={
+            "description": "Maximum time (in seconds) for preflight request caching.",
+            "default": 600,
+        },
+    )
+
+    def __post_init__(self):
+        """
+        Validates the types of CORS configuration attributes after initialization.
+
+        Raises:
+            OrionisIntegrityException: If any of the following conditions are not met:
+                - allow_origins is not a list of strings.
+                - allow_origin_regex is not a string or None.
+                - allow_methods is not a list of strings.
+                - allow_headers is not a list of strings.
+                - expose_headers is not a list of strings.
+                - allow_credentials is not a boolean.
+                - max_age is not an integer or None.
+        """
+        if not isinstance(self.allow_origins, list):
+            raise OrionisIntegrityException(
+                "Invalid type for 'allow_origins': expected a list of strings."
+            )
+        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."
+            )
+        if not isinstance(self.allow_methods, list):
+            raise OrionisIntegrityException(
+                "Invalid type for 'allow_methods': expected a list of strings."
+            )
+        if not isinstance(self.allow_headers, list):
+            raise OrionisIntegrityException(
+                "Invalid type for 'allow_headers': expected a list of strings."
+            )
+        if not isinstance(self.expose_headers, list):
+            raise OrionisIntegrityException(
+                "Invalid type for 'expose_headers': expected a list of strings."
+            )
+        if not isinstance(self.allow_credentials, bool):
+            raise OrionisIntegrityException(
+                "Invalid type for 'allow_credentials': expected a boolean."
+            )
+        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)

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

@@ -0,0 +1,89 @@
+from dataclasses import asdict, dataclass, field
+from orionis.luminate.foundation.config.database.entities.mysql import MySQL
+from orionis.luminate.foundation.config.database.entities.oracle import Oracle
+from orionis.luminate.foundation.config.database.entities.pgsql import PGSQL
+from orionis.luminate.foundation.config.database.entities.sqlite import SQLite
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class Connections:
+    """
+    Data class to represent all database connections used by the application.
+
+    Attributes
+    ----------
+    sqlite : Sqlite
+        Configuration for the SQLite database connection.
+    mysql : MySQL
+        Configuration for the MySQL database connection.
+    pgsql : Pgsql
+        Configuration for the PostgreSQL database connection.
+    oracle : Oracle
+        Configuration for the Oracle database connection.
+    """
+    sqlite: SQLite = field(
+        default_factory=SQLite,
+        metadata={
+            "description": "SQLite database connection configuration",
+            "default": "SQLite()"
+        }
+    )
+
+    mysql: MySQL = field(
+        default_factory=MySQL,
+        metadata={
+            "description": "MySQL database connection configuration",
+            "default": "MySQL()"
+        }
+    )
+
+    pgsql: PGSQL = field(
+        default_factory=PGSQL,
+        metadata={
+            "description": "PostgreSQL database connection configuration",
+            "default": "PGSQL()"
+        }
+    )
+
+    oracle: Oracle = field(
+        default_factory=Oracle,
+        metadata={
+            "description": "Oracle database connection configuration",
+            "default": "Oracle()"
+        }
+    )
+
+    def __post_init__(self):
+        """
+        Post-initialization method to validate the types of database connection attributes.
+        Ensures that the attributes `sqlite`, `mysql`, `pgsql`, and `oracle` are instances of their respective classes.
+        Raises:
+            OrionisIntegrityException: If any attribute is not an instance of its expected class.
+        """
+        if not isinstance(self.sqlite, SQLite):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'sqlite': expected 'Sqlite', got '{type(self.sqlite).__name__}'."
+            )
+
+        if not isinstance(self.mysql, MySQL):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'mysql': expected 'Mysql', got '{type(self.mysql).__name__}'."
+            )
+
+        if not isinstance(self.pgsql, PGSQL):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'pgsql': expected 'Pgsql', got '{type(self.pgsql).__name__}'."
+            )
+
+        if not isinstance(self.oracle, Oracle):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'oracle': expected 'Oracle', 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)