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

orionis/foundation/application.py

@@ -1,6 +1,8 @@
+import asyncio
 import time
 from pathlib import Path
 from typing import Any, List, Type
+from orionis.console.output.contracts.console import IConsole
 from orionis.container.container import Container
 from orionis.container.contracts.service_provider import IServiceProvider
 from orionis.foundation.config.app.entities.app import App
@@ -12,13 +14,14 @@ from orionis.foundation.config.filesystems.entitites.filesystems import Filesyst
 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.startup import Configuration
 from orionis.foundation.config.testing.entities.testing import Testing
 from orionis.foundation.contracts.application import IApplication
-from orionis.foundation.contracts.config import IConfig
-from orionis.foundation.exceptions import OrionisTypeError, OrionisRuntimeError
+from orionis.foundation.exceptions import OrionisTypeError, OrionisRuntimeError, OrionisValueError
 from orionis.foundation.providers.logger_provider import LoggerProvider
+from orionis.services.log.contracts.log_service import ILoggerService
 
 class Application(Container, IApplication):
     """
@@ -48,6 +51,20 @@ class Application(Container, IApplication):
         """
         return self.__booted
 
+    @property
+    def startAt(
+        self
+    ) -> int:
+        """
+        Get the timestamp when the application started.
+
+        Returns
+        -------
+        int
+            The start time in nanoseconds since epoch
+        """
+        return self.__startAt
+
     def __init__(
         self
     ) -> None:
@@ -57,31 +74,44 @@ class Application(Container, IApplication):
         Sets up initial state including empty providers list and booted flag.
         Uses singleton pattern to prevent multiple initializations.
         """
+
         # Initialize base container with application paths
         super().__init__()
 
         # Singleton pattern - prevent multiple initializations
         if not hasattr(self, '_Application__initialized'):
+
+            # Start time in nanoseconds
+            self.__startAt = time.time_ns()
+
+            # Propierty to store service providers.
             self.__providers: List[IServiceProvider, Any] = []
+
+            # Property to store configurators and paths
             self.__configurators : dict = {}
-            self.__config: dict = {}
+
+            # Property to indicate if the application has been booted
             self.__booted: bool = False
-            self.__startAt = time.time_ns()
+
+            # Property to store application configuration
+            # This will be initialized with default values or from configurators
+            self.__config: dict = {}
 
             # Flag to prevent re-initialization
             self.__initialized = True
 
-    # << Frameworks Kernel >>
+    # === Native Kernels and Providers for Orionis Framework ===
+    # Responsible for loading the native kernels and service providers of the Orionis framework.
+    # These kernels and providers are essential for the core functionality of the framework.
+    # Private methods are used to load these native components, ensuring they cannot be modified externally.
 
     def __loadFrameworksKernel(
         self
     ) -> None:
         """
         Load and register core framework kernels.
-
-        Instantiates and registers kernel components:
-        - TestKernel: Testing framework kernel
         """
+
         # Import core framework kernels
         from orionis.test.kernel import TestKernel, ITestKernel
 
@@ -94,8 +124,6 @@ class Application(Container, IApplication):
         for kernel_name, kernel_cls in core_kernels.items():
             self.instance(kernel_name, kernel_cls(self))
 
-    # << Service Providers >>
-
     def __loadFrameworkProviders(
         self
     ) -> None:
@@ -110,6 +138,7 @@ class Application(Container, IApplication):
         from orionis.foundation.providers.path_resolver_provider import PathResolverProvider
         from orionis.foundation.providers.progress_bar_provider import ProgressBarProvider
         from orionis.foundation.providers.workers_provider import WorkersProvider
+        from orionis.foundation.providers.testing_provider import TestingProvider
 
         # Core framework providers
         core_providers = [
@@ -118,56 +147,18 @@ class Application(Container, IApplication):
             PathResolverProvider,
             ProgressBarProvider,
             WorkersProvider,
-            LoggerProvider
+            LoggerProvider,
+            TestingProvider
         ]
 
         # Register each core provider
         for provider_cls in core_providers:
             self.addProvider(provider_cls)
 
-    def __registerProviders(
-        self
-    ) -> None:
-        """
-        Register all added service providers.
-
-        Calls the register method on each provider to bind services
-        into the container.
-        """
-
-        # Ensure providers list is empty before registration
-        initialized_providers = []
-
-        # Iterate over each provider and register it
-        for provider in self.__providers:
-
-            # Initialize the provider
-            class_provider: IServiceProvider = provider(self)
-
-            # Register the provider in the container
-            class_provider.register()
-
-            # Add the initialized provider to the list
-            initialized_providers.append(class_provider)
-
-        # Update the providers list with initialized providers
-        self.__providers = initialized_providers
-
-    def __bootProviders(
-        self
-    ) -> None:
-        """
-        Boot all registered service providers.
-
-        Calls the boot method on each provider to initialize services
-        after all providers have been registered.
-        """
-        # Iterate over each provider and boot it
-        for provider in self.__providers:
-
-            # Ensure provider is initialized before calling boot
-            if hasattr(provider, 'boot') and callable(getattr(provider, 'boot')):
-                provider.boot()
+    # === Service Provider Registration and Bootstrapping ===
+    # These private methods enable developers to register and boot custom service providers.
+    # Registration and booting are handled separately, ensuring a clear lifecycle for each provider.
+    # Both methods are invoked automatically during application initialization.
 
     def withProviders(
         self,
@@ -232,53 +223,85 @@ class Application(Container, IApplication):
         # Return self instance.
         return self
 
-    # << Configuration >>
-
-    def __loadConfig(
-        self,
+    def __registerProviders(
+        self
     ) -> None:
         """
-        Retrieve a configuration value by key.
+        Register all added service providers.
 
-        Returns
-        -------
-        None
-            Initializes the application configuration if not already set.
+        Calls the register method on each provider to bind services
+        into the container.
         """
 
-        # Try to load the configuration
-        try:
+        # Ensure providers list is empty before registration
+        initialized_providers = []
 
-            # Check if configuration is a dictionary
-            if not self.__config:
+        # Iterate over each provider and register it
+        for provider in self.__providers:
 
-                # Initialize with default configuration
-                if not self.__configurators:
-                    self.__config = Configuration().toDict()
+            # Initialize the provider
+            class_provider: IServiceProvider = provider(self)
+
+            # Register the provider in the container
+            # Check if register is a coroutine function
+            if asyncio.iscoroutinefunction(class_provider.register):
+                asyncio.run(class_provider.register())
+            else:
+                class_provider.register()
+
+            # Add the initialized provider to the list
+            initialized_providers.append(class_provider)
+
+        # Update the providers list with initialized providers
+        self.__providers = initialized_providers
+
+    def __bootProviders(
+        self
+    ) -> None:
+        """
+        Boot all registered service providers.
 
-                # If configurators are provided, use them to create the configuration
+        Calls the boot method on each provider to initialize services
+        after all providers have been registered.
+        """
+
+        # Iterate over each provider and boot it
+        for provider in self.__providers:
+
+            # Ensure provider is initialized before calling boot
+            if hasattr(provider, 'boot') and callable(getattr(provider, 'boot')):
+                # Check if boot is a coroutine function
+                if asyncio.iscoroutinefunction(provider.boot):
+                    asyncio.run(provider.boot())
                 else:
-                    self.__config = Configuration(**self.__configurators).toDict()
+                    provider.boot()
 
-        except Exception as e:
+        # Remove the __providers attribute to prevent memory leaks
+        if hasattr(self, '_Application__providers'):
+            del self.__providers
 
-            # Handle any exceptions during configuration loading
-            raise OrionisRuntimeError(f"Failed to load application configuration: {str(e)}")
+    # === Application Skeleton Configuration Methods ===
+    # The Orionis framework provides methods to configure each component of the application,
+    # enabling the creation of fully customized application skeletons.
+    # These configurator loading methods allow developers to tailor the architecture
+    # for complex and unique application requirements, supporting advanced customization
+    # of every subsystem as needed.
 
     def withConfigurators(
         self,
         *,
-        app: App|IConfig = None,
-        auth: Auth|IConfig = None,
-        cache : Cache|IConfig = None,
-        cors : Cors|IConfig = None,
-        database : Database|IConfig = None,
-        filesystems : Filesystems|IConfig = None,
-        logging : Logging|IConfig = None,
-        mail : Mail|IConfig = None,
-        queue : Queue|IConfig = None,
-        session : Session|IConfig = None,
-        testing : Testing|IConfig = None
+        app: App | dict = App(),
+        auth: Auth | dict = Auth(),
+        cache : Cache | dict = Cache(),
+        cors : Cors | dict = Cors(),
+        database : Database | dict = Database(),
+        filesystems : Filesystems | dict = Filesystems(),
+        logging : Logging | dict = Logging(),
+        mail : Mail | dict = Mail(),
+        path : Paths | dict = Paths(),
+        queue : Queue | dict = Queue(),
+        session : Session | dict = Session(),
+        testing : Testing | dict = Testing()
     ) -> 'Application':
         """
         Configure the application with various service configurators.
@@ -316,64 +339,72 @@ class Application(Container, IApplication):
         """
 
         # Load app configurator
-        if app is not None and issubclass(app, IConfig):
-            app = app.config
-        self.loadConfigApp(app or App())
+        if not isinstance(app, (App, dict)):
+            raise OrionisTypeError(f"Expected App instance or dict, got {type(app).__name__}")
+        self.loadConfigApp(app)
 
         # Load auth configurator
-        if auth is not None and issubclass(auth, IConfig):
-            auth = auth.config
-        self.loadConfigAuth(auth or Auth())
+        if not isinstance(auth, (Auth, dict)):
+            raise OrionisTypeError(f"Expected Auth instance or dict, got {type(auth).__name__}")
+        self.loadConfigAuth(auth)
 
         # Load cache configurator
-        if cache is not None and issubclass(cache, IConfig):
-            cache = cache.config
-        self.loadConfigCache(cache or Cache())
+        if not isinstance(cache, (Cache, dict)):
+            raise OrionisTypeError(f"Expected Cache instance or dict, got {type(cache).__name__}")
+        self.loadConfigCache(cache)
 
         # Load cors configurator
-        if cors is not None and issubclass(cors, IConfig):
-            cors = cors.config
-        self.loadConfigCors(cors or Cors())
+        if not isinstance(cors, (Cors, dict)):
+            raise OrionisTypeError(f"Expected Cors instance or dict, got {type(cors).__name__}")
+        self.loadConfigCors(cors)
 
         # Load database configurator
-        if database is not None and issubclass(database, IConfig):
-            database = database.config
-        self.loadConfigDatabase(database or Database())
+        if not isinstance(database, (Database, dict)):
+            raise OrionisTypeError(f"Expected Database instance or dict, got {type(database).__name__}")
+        self.loadConfigDatabase(database)
 
         # Load filesystems configurator
-        if filesystems is not None and issubclass(filesystems, IConfig):
-            filesystems = filesystems.config
-        self.loadConfigFilesystems(filesystems or Filesystems())
+        if not isinstance(filesystems, (Filesystems, dict)):
+            raise OrionisTypeError(f"Expected Filesystems instance or dict, got {type(filesystems).__name__}")
+        self.loadConfigFilesystems(filesystems)
 
         # Load logging configurator
-        if logging is not None and issubclass(logging, IConfig):
-            logging = logging.config
-        self.loadConfigLogging(logging or Logging())
+        if not isinstance(logging, (Logging, dict)):
+            raise OrionisTypeError(f"Expected Logging instance or dict, got {type(logging).__name__}")
+        self.loadConfigLogging(logging)
 
         # Load mail configurator
-        if mail is not None and issubclass(mail, IConfig):
-            mail = mail.config
-        self.loadConfigMail(mail or Mail())
+        if not isinstance(mail, (Mail, dict)):
+            raise OrionisTypeError(f"Expected Mail instance or dict, got {type(mail).__name__}")
+        self.loadConfigMail(mail)
+
+        # Load paths configurator
+        if not isinstance(path, (Paths, dict)):
+            raise OrionisTypeError(f"Expected Paths instance or dict, got {type(path).__name__}")
+        self.loadPaths(path)
 
         # Load queue configurator
-        if queue is not None and issubclass(queue, IConfig):
-            queue = queue.config
-        self.loadConfigQueue(queue or Queue())
+        if not isinstance(queue, (Queue, dict)):
+            raise OrionisTypeError(f"Expected Queue instance or dict, got {type(queue).__name__}")
+        self.loadConfigQueue(queue)
 
         # Load session configurator
-        if session is not None and issubclass(session, IConfig):
-            session = session.config
-        self.loadConfigSession(session or Session())
+        if not isinstance(session, (Session, dict)):
+            raise OrionisTypeError(f"Expected Session instance or dict, got {type(session).__name__}")
+        self.loadConfigSession(session)
 
         # Load testing configurator
-        if testing is not None and issubclass(testing, IConfig):
-            testing = testing.config
-        self.loadConfigTesting(testing or Testing())
+        if not isinstance(testing, (Testing, dict)):
+            raise OrionisTypeError(f"Expected Testing instance or dict, got {type(testing).__name__}")
+        self.loadConfigTesting(testing)
 
         # Return self instance for method chaining
         return self
 
-    def configApp(self, **app_config) -> 'Application':
+    def setConfigApp(
+        self,
+        **app_config
+    ) -> 'Application':
         """
         Configure the application with various settings.
 
@@ -400,15 +431,15 @@ class Application(Container, IApplication):
 
     def loadConfigApp(
         self,
-        app: App
+        app: App | dict
     ) -> 'Application':
         """
         Load the application configuration from an App instance.
 
         Parameters
         ----------
-        config : App
-            The App instance containing application configuration
+        config : App | dict
+            The App instance or dictionary containing application configuration.
 
         Returns
         -------
@@ -416,9 +447,13 @@ class Application(Container, IApplication):
             The application instance for method chaining
         """
 
-        # Validate config type
-        if not isinstance(app, App):
-            raise OrionisTypeError(f"Expected App instance, got {type(app).__name__}")
+        # Validate app type
+        if not isinstance(app, (App, dict)):
+            raise OrionisTypeError(f"Expected App instance or dict, got {type(app).__name__}")
+
+        # If app is a dict, convert it to App instance
+        if isinstance(app, dict):
+            app = App(**app)
 
         # Store the configuration
         self.__configurators['app'] = app
@@ -426,7 +461,10 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configAuth(self, **auth_config) -> 'Application':
+    def setConfigAuth(
+        self,
+        **auth_config
+    ) -> 'Application':
         """
         Configure the authentication with various settings.
 
@@ -453,15 +491,15 @@ class Application(Container, IApplication):
 
     def loadConfigAuth(
         self,
-        auth: Auth
+        auth: Auth | dict
     ) -> 'Application':
         """
         Load the application authentication configuration from an Auth instance.
 
         Parameters
         ----------
-        auth : Auth
-            The Auth instance containing authentication configuration
+        auth : Auth | dict
+            The Auth instance or dictionary containing authentication configuration.
 
         Returns
         -------
@@ -470,8 +508,12 @@ class Application(Container, IApplication):
         """
 
         # Validate auth type
-        if not isinstance(auth, Auth):
-            raise OrionisTypeError(f"Expected Auth instance, got {type(auth).__name__}")
+        if not isinstance(auth, (Auth, dict)):
+            raise OrionisTypeError(f"Expected Auth instance or dict, got {type(auth).__name__}")
+
+        # If auth is a dict, convert it to Auth instance
+        if isinstance(auth, dict):
+            auth = Auth(**auth)
 
         # Store the configuration
         self.__configurators['auth'] = auth
@@ -479,7 +521,10 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configCache(self, **cache_config) -> 'Application':
+    def setConfigCache(
+        self,
+        **cache_config
+    ) -> 'Application':
         """
         Configure the cache with various settings.
 
@@ -506,15 +551,15 @@ class Application(Container, IApplication):
 
     def loadConfigCache(
         self,
-        cache: Cache
+        cache: Cache | dict
     ) -> 'Application':
         """
         Load the application cache configuration from a Cache instance.
 
         Parameters
         ----------
-        cache : Cache
-            The Cache instance containing cache configuration
+        cache : Cache | dict
+            The Cache instance or dictionary containing cache configuration.
 
         Returns
         -------
@@ -523,8 +568,12 @@ class Application(Container, IApplication):
         """
 
         # Validate cache type
-        if not isinstance(cache, Cache):
-            raise OrionisTypeError(f"Expected Cache instance, got {type(cache).__name__}")
+        if not isinstance(cache, (Cache, dict)):
+            raise OrionisTypeError(f"Expected Cache instance or dict, got {type(cache).__name__}")
+
+        # If cache is a dict, convert it to Cache instance
+        if isinstance(cache, dict):
+            cache = Cache(**cache)
 
         # Store the configuration
         self.__configurators['cache'] = cache
@@ -532,7 +581,10 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configCors(self, **cors_config) -> 'Application':
+    def setConfigCors(
+        self,
+        **cors_config
+    ) -> 'Application':
         """
         Configure the CORS with various settings.
 
@@ -559,15 +611,15 @@ class Application(Container, IApplication):
 
     def loadConfigCors(
         self,
-        cors: Cors
+        cors: Cors | dict
     ) -> 'Application':
         """
         Load the application CORS configuration from a Cors instance.
 
         Parameters
         ----------
-        cors : Cors
-            The Cors instance containing CORS configuration
+        cors : Cors | dict
+            The Cors instance or dictionary containing CORS configuration.
 
         Returns
         -------
@@ -576,8 +628,12 @@ class Application(Container, IApplication):
         """
 
         # Validate cors type
-        if not isinstance(cors, Cors):
-            raise OrionisTypeError(f"Expected Cors instance, got {type(cors).__name__}")
+        if not isinstance(cors, (Cors, dict)):
+            raise OrionisTypeError(f"Expected Cors instance or dict, got {type(cors).__name__}")
+
+        # If cors is a dict, convert it to Cors instance
+        if isinstance(cors, dict):
+            cors = Cors(**cors)
 
         # Store the configuration
         self.__configurators['cors'] = cors
@@ -585,7 +641,7 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configDatabase(
+    def setConfigDatabase(
         self,
         **database_config
     ) -> 'Application':
@@ -615,15 +671,15 @@ class Application(Container, IApplication):
 
     def loadConfigDatabase(
         self,
-        database: Database
+        database: Database | dict
     ) -> 'Application':
         """
         Load the application database configuration from a Database instance.
 
         Parameters
         ----------
-        database : Database
-            The Database instance containing database configuration
+        database : Database | dict
+            The Database instance or dictionary containing database configuration.
 
         Returns
         -------
@@ -632,8 +688,12 @@ class Application(Container, IApplication):
         """
 
         # Validate database type
-        if not isinstance(database, Database):
-            raise OrionisTypeError(f"Expected Database instance, got {type(database).__name__}")
+        if not isinstance(database, (Database, dict)):
+            raise OrionisTypeError(f"Expected Database instance or dict, got {type(database).__name__}")
+
+        # If database is a dict, convert it to Database instance
+        if isinstance(database, dict):
+            database = Database(**database)
 
         # Store the configuration
         self.__configurators['database'] = database
@@ -641,7 +701,7 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configFilesystems(
+    def setConfigFilesystems(
         self,
         **filesystems_config
     ) -> 'Application':
@@ -671,15 +731,15 @@ class Application(Container, IApplication):
 
     def loadConfigFilesystems(
         self,
-        filesystems: Filesystems
+        filesystems: Filesystems | dict
     ) -> 'Application':
         """
         Load the application filesystems configuration from a Filesystems instance.
 
         Parameters
         ----------
-        filesystems : Filesystems
-            The Filesystems instance containing filesystems configuration
+        filesystems : Filesystems | dict
+            The Filesystems instance or dictionary containing filesystems configuration.
 
         Returns
         -------
@@ -688,8 +748,12 @@ class Application(Container, IApplication):
         """
 
         # Validate filesystems type
-        if not isinstance(filesystems, Filesystems):
-            raise OrionisTypeError(f"Expected Filesystems instance, got {type(filesystems).__name__}")
+        if not isinstance(filesystems, (Filesystems, dict)):
+            raise OrionisTypeError(f"Expected Filesystems instance or dict, got {type(filesystems).__name__}")
+
+        # If filesystems is a dict, convert it to Filesystems instance
+        if isinstance(filesystems, dict):
+            filesystems = Filesystems(**filesystems)
 
         # Store the configuration
         self.__configurators['filesystems'] = filesystems
@@ -697,7 +761,7 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configLogging(
+    def setConfigLogging(
         self,
         **logging_config
     ) -> 'Application':
@@ -727,15 +791,15 @@ class Application(Container, IApplication):
 
     def loadConfigLogging(
         self,
-        logging: Logging
+        logging: Logging | dict
     ) -> 'Application':
         """
         Load the application logging configuration from a Logging instance.
 
         Parameters
         ----------
-        logging : Logging
-            The Logging instance containing logging configuration
+        logging : Logging | dict
+            The Logging instance or dictionary containing logging configuration.
 
         Returns
         -------
@@ -744,8 +808,12 @@ class Application(Container, IApplication):
         """
 
         # Validate logging type
-        if not isinstance(logging, Logging):
-            raise OrionisTypeError(f"Expected Logging instance, got {type(logging).__name__}")
+        if not isinstance(logging, (Logging, dict)):
+            raise OrionisTypeError(f"Expected Logging instance or dict, got {type(logging).__name__}")
+
+        # If logging is a dict, convert it to Logging instance
+        if isinstance(logging, dict):
+            logging = Logging(**logging)
 
         # Store the configuration
         self.__configurators['logging'] = logging
@@ -753,7 +821,7 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configMail(
+    def setConfigMail(
         self,
         **mail_config
     ) -> 'Application':
@@ -783,15 +851,15 @@ class Application(Container, IApplication):
 
     def loadConfigMail(
         self,
-        mail: Mail
+        mail: Mail | dict
     ) -> 'Application':
         """
         Load the application mail configuration from a Mail instance.
 
         Parameters
         ----------
-        mail : Mail
-            The Mail instance containing mail configuration
+        mail : Mail | dict
+            The Mail instance or dictionary containing mail configuration.
 
         Returns
         -------
@@ -800,8 +868,12 @@ class Application(Container, IApplication):
         """
 
         # Validate mail type
-        if not isinstance(mail, Mail):
-            raise OrionisTypeError(f"Expected Mail instance, got {type(mail).__name__}")
+        if not isinstance(mail, (Mail, dict)):
+            raise OrionisTypeError(f"Expected Mail instance or dict, got {type(mail).__name__}")
+
+        # If mail is a dict, convert it to Mail instance
+        if isinstance(mail, dict):
+            mail = Mail(**mail)
 
         # Store the configuration
         self.__configurators['mail'] = mail
@@ -809,7 +881,130 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configQueue(
+    def setPaths(
+        self,
+        *,
+        console_scheduler: str | Path = (Path.cwd() / 'app' / 'console' / 'kernel.py').resolve(),
+        console_commands: str | Path = (Path.cwd() / 'app' / 'console' / 'commands').resolve(),
+        http_controllers: str | Path = (Path.cwd() / 'app' / 'http' / 'controllers').resolve(),
+        http_middleware: str | Path = (Path.cwd() / 'app' / 'http' / 'middleware').resolve(),
+        http_requests: str | Path = (Path.cwd() / 'app' / 'http' / 'requests').resolve(),
+        models: str | Path = (Path.cwd() / 'app' / 'models').resolve(),
+        providers: str | Path = (Path.cwd() / 'app' / 'providers').resolve(),
+        events: str | Path = (Path.cwd() / 'app' / 'events').resolve(),
+        listeners: str | Path = (Path.cwd() / 'app' / 'listeners').resolve(),
+        notifications: str | Path = (Path.cwd() / 'app' / 'notifications').resolve(),
+        jobs: str | Path = (Path.cwd() / 'app' / 'jobs').resolve(),
+        policies: str | Path = (Path.cwd() / 'app' / 'policies').resolve(),
+        exceptions: str | Path = (Path.cwd() / 'app' / 'exceptions').resolve(),
+        services: str | Path = (Path.cwd() / 'app' / 'services').resolve(),
+        views: str | Path = (Path.cwd() / 'resources' / 'views').resolve(),
+        lang: str | Path = (Path.cwd() / 'resources' / 'lang').resolve(),
+        assets: str | Path = (Path.cwd() / 'resources' / 'assets').resolve(),
+        routes_web: str | Path = (Path.cwd() / 'routes' / 'web.py').resolve(),
+        routes_api: str | Path = (Path.cwd() / 'routes' / 'api.py').resolve(),
+        routes_console: str | Path = (Path.cwd() / 'routes' / 'console.py').resolve(),
+        routes_channels: str | Path = (Path.cwd() / 'routes' / 'channels.py').resolve(),
+        config: str | Path = (Path.cwd() / 'config').resolve(),
+        migrations: str | Path = (Path.cwd() / 'database' / 'migrations').resolve(),
+        seeders: str | Path = (Path.cwd() / 'database' / 'seeders').resolve(),
+        factories: str | Path = (Path.cwd() / 'database' / 'factories').resolve(),
+        storage_logs: str | Path = (Path.cwd() / 'storage' / 'logs').resolve(),
+        storage_framework: str | Path = (Path.cwd() / 'storage' / 'framework').resolve(),
+        storage_sessions: str | Path = (Path.cwd() / 'storage' / 'framework' / 'sessions').resolve(),
+        storage_cache: str | Path = (Path.cwd() / 'storage' / 'framework' / 'cache').resolve(),
+        storage_views: str | Path = (Path.cwd() / 'storage' / 'framework' / 'views').resolve(),
+        storage_testing: str | Path = (Path.cwd() / 'storage' / 'framework' / 'testing').resolve(),
+    ) -> 'Application':
+        """
+        Set various application paths.
+
+        Parameters
+        ----------
+        Each keyword argument sets a specific application path.
+
+        Returns
+        -------
+        Application
+            The application instance for method chaining
+        """
+
+        # Ensure 'paths' exists in configurators
+        self.__configurators['paths'] = {
+            'console_scheduler': str(console_scheduler),
+            'console_commands': str(console_commands),
+            'http_controllers': str(http_controllers),
+            'http_middleware': str(http_middleware),
+            'http_requests': str(http_requests),
+            'models': str(models),
+            'providers': str(providers),
+            'events': str(events),
+            'listeners': str(listeners),
+            'notifications': str(notifications),
+            'jobs': str(jobs),
+            'policies': str(policies),
+            'exceptions': str(exceptions),
+            'services': str(services),
+            'views': str(views),
+            'lang': str(lang),
+            'assets': str(assets),
+            'routes_web': str(routes_web),
+            'routes_api': str(routes_api),
+            'routes_console': str(routes_console),
+            'routes_channels': str(routes_channels),
+            'config': str(config),
+            'migrations': str(migrations),
+            'seeders': str(seeders),
+            'factories': str(factories),
+            'storage_logs': str(storage_logs),
+            'storage_framework': str(storage_framework),
+            'storage_sessions': str(storage_sessions),
+            'storage_cache': str(storage_cache),
+            'storage_views': str(storage_views),
+            'storage_testing': str(storage_testing),
+        }
+
+        # Return self instance for method chaining
+        return self
+
+    def loadPaths(
+        self,
+        paths: Paths | dict
+    ) -> 'Application':
+        """
+        Load the application paths configuration from a Paths instance or dictionary.
+
+        Parameters
+        ----------
+        paths : Paths | dict
+            The Paths instance or dictionary containing path configuration.
+
+        Returns
+        -------
+        Application
+            The application instance for method chaining
+
+        Raises
+        ------
+        OrionisTypeError
+            If paths is not an instance of Paths or dict.
+        """
+
+        # Validate paths type
+        if not isinstance(paths, (Paths, dict)):
+            raise OrionisTypeError(f"Expected Paths instance or dict, got {type(paths).__name__}")
+
+        # If paths is a dict, convert it to Paths instance
+        if isinstance(paths, dict):
+            paths = Paths(**paths)
+
+        # Store the configuration
+        self.__configurators['paths'] = paths
+
+        # Return the application instance for method chaining
+        return self
+
+    def setConfigQueue(
         self,
         **queue_config
     ) -> 'Application':
@@ -839,7 +1034,7 @@ class Application(Container, IApplication):
 
     def loadConfigQueue(
         self,
-        queue: Queue
+        queue: Queue | dict
     ) -> 'Application':
         """
         Load the application queue configuration from a Queue instance.
@@ -856,8 +1051,12 @@ class Application(Container, IApplication):
         """
 
         # Validate queue type
-        if not isinstance(queue, Queue):
-            raise OrionisTypeError(f"Expected Queue instance, got {type(queue).__name__}")
+        if not isinstance(queue, (Queue, dict)):
+            raise OrionisTypeError(f"Expected Queue instance or dict, got {type(queue).__name__}")
+
+        # If queue is a dict, convert it to Queue instance
+        if isinstance(queue, dict):
+            queue = Queue(**queue)
 
         # Store the configuration
         self.__configurators['queue'] = queue
@@ -865,7 +1064,7 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configSession(
+    def setConfigSession(
         self,
         **session_config
     ) -> 'Application':
@@ -895,15 +1094,15 @@ class Application(Container, IApplication):
 
     def loadConfigSession(
         self,
-        session: Session
+        session: Session | dict
     ) -> 'Application':
         """
         Load the application session configuration from a Session instance.
 
         Parameters
         ----------
-        session : Session
-            The Session instance containing session configuration
+        session : Session | dict
+            The Session instance or dictionary containing session configuration.
 
         Returns
         -------
@@ -912,8 +1111,12 @@ class Application(Container, IApplication):
         """
 
         # Validate session type
-        if not isinstance(session, Session):
-            raise OrionisTypeError(f"Expected Session instance, got {type(session).__name__}")
+        if not isinstance(session, (Session, dict)):
+            raise OrionisTypeError(f"Expected Session instance or dict, got {type(session).__name__}")
+
+        # If session is a dict, convert it to Session instance
+        if isinstance(session, dict):
+            session = Session(**session)
 
         # Store the configuration
         self.__configurators['session'] = session
@@ -921,7 +1124,7 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    def configTesting(
+    def setConfigTesting(
         self,
         **testing_config
     ) -> 'Application':
@@ -951,15 +1154,15 @@ class Application(Container, IApplication):
 
     def loadConfigTesting(
         self,
-        testing: Testing
+        testing: Testing | dict
     ) -> 'Application':
         """
         Load the application testing configuration from a Testing instance.
 
         Parameters
         ----------
-        testing : Testing
-            The Testing instance containing testing configuration
+        testing : Testing | dict
+            The Testing instance or dictionary containing testing configuration.
 
         Returns
         -------
@@ -968,8 +1171,12 @@ class Application(Container, IApplication):
         """
 
         # Validate testing type
-        if not isinstance(testing, Testing):
-            raise OrionisTypeError(f"Expected Testing instance, got {type(testing).__name__}")
+        if not isinstance(testing, (Testing, dict)):
+            raise OrionisTypeError(f"Expected Testing instance or dict, got {type(testing).__name__}")
+
+        # If testing is a dict, convert it to Testing instance
+        if isinstance(testing, dict):
+            testing = Testing(**testing)
 
         # Store the configuration
         self.__configurators['testing'] = testing
@@ -977,68 +1184,83 @@ class Application(Container, IApplication):
         # Return the application instance for method chaining
         return self
 
-    # << Application Lifecycle >>
-
-    def create(
-        self
-    ) -> 'Application':
+    def __loadConfig(
+        self,
+    ) -> None:
         """
-        Bootstrap the application by loading providers and kernels.
+        Retrieve a configuration value by key.
 
         Returns
         -------
-        Application
-            The application instance for method chaining
+        None
+            Initializes the application configuration if not already set.
         """
-        # Check if already booted
-        if not self.__booted:
 
-            # Load configuration if not already set
-            self.__loadConfig()
+        # Try to load the configuration
+        try:
 
-            # Load framework providers and register them
-            self.__loadFrameworkProviders()
-            self.__registerProviders()
-            self.__bootProviders()
+            # Check if configuration is a dictionary
+            if not self.__config:
 
-            # Load core framework kernels
-            self.__loadFrameworksKernel()
+                # Initialize with default configuration
+                if not self.__configurators:
+                    self.__config = Configuration().toDict()
 
-            # Mark as booted
-            self.__booted = True
+                # Convert configurators to a dictionary
+                else:
+                    self.__config = Configuration(**self.__configurators).toDict()
 
-        return self
+                # Remove __configurators ofter loading configuration
+                if hasattr(self, '_Application__configurators'):
+                    del self.__configurators
+
+        except Exception as e:
+
+            # Handle any exceptions during configuration loading
+            raise OrionisRuntimeError(f"Failed to load application configuration: {str(e)}")
 
-    # << Configuration Access >>
+    # === Configuration Access Method ===
+    # The config() method provides access to application configuration settings.
+    # It supports dot notation for retrieving nested configuration values.
+    # You can obtain a specific configuration value by providing a key,
+    # or retrieve the entire configuration dictionary by omitting the key.
 
     def config(
         self,
-        key: str,
+        key: str = None,
         default: Any = None
     ) -> Any:
         """
-        Retrieve a configuration value by key.
-
-        Parameters
-        ----------
-        key : str
-            The configuration key to retrieve using dot notation (e.g. "app.name") (default is None)
-        default : Any, optional
-            Default value to return if key is not found
+        Retrieves a configuration value from the application settings using dot notation.
+        This method allows you to access nested configuration values by specifying a key in dot notation
+        (e.g., "database.host"). If no key is provided, the entire configuration dictionary is returned.
+        key : str, optional
+            The configuration key to retrieve, using dot notation for nested values (e.g., "app.name").
+            If None, returns the entire configuration dictionary. Default is None.
+            The value to return if the specified key does not exist in the configuration. Default is None.
+            The configuration value associated with the given key, the entire configuration dictionary if
+            key is None, or the default value if the key is not found.
 
-        Returns
-        -------
-        Any
-            The configuration value or the entire configuration if key is None
+        Raises
+        ------
+        OrionisRuntimeError
+            If the application has not been booted and configuration is not available.
+        OrionisValueError
+            If the provided key is not a string.
         """
 
         # Ensure the application is booted before accessing configuration
         if not self.__config:
-            raise RuntimeError("Application must be booted before accessing configuration. Call create() first.")
+            raise OrionisRuntimeError("Application configuration is not initialized. Please call create() before accessing configuration.")
 
-        # If key is None, raise an error to prevent ambiguity
+        # Return the entire configuration if key is None, except for paths
         if key is None:
-            raise ValueError("Key cannot be None. Use config() without arguments to get the entire configuration.")
+            del self.__config['paths']
+            return self.__config
+
+        # If key is None, raise an error to prevent ambiguity
+        if not isinstance(key, str):
+            raise OrionisValueError("Key must be a string. Use config() without arguments to retrieve the entire configuration.")
 
         # Split the key by dot notation
         parts = key.split('.')
@@ -1060,46 +1282,118 @@ class Application(Container, IApplication):
         # Return the final configuration value
         return config_value
 
-    # << Path Configuration Access >>
+    # === Path Configuration Access Method ===
+    # The path() method provides access to application path configurations.
+    # It allows you to retrieve specific path configurations using dot notation.
+    # If no key is provided, it returns the entire 'paths' configuration dictionary.
 
     def path(
         self,
-        key: str,
-        default: str = None
-    ) -> Path:
+        key: str = None,
+        default: Any = None
+    ) -> Any:
         """
-        Retrieve a path configuration value by key.
-
+        Retrieve a path configuration value from the application's configuration.
         Parameters
         ----------
-        key : str
-            The path key to retrieve using dot notation (e.g. "paths.storage")
-        default : str, optional
-            Default value to return if key is not found
-
+        key : str, optional
+            Dot-notated key specifying the path configuration to retrieve.
+            If None, returns the entire 'paths' configuration dictionary.
+        default : Any, optional
+            Value to return if the specified key is not found. Defaults to None.
         Returns
         -------
-        Path
-            The path value as a Path object or None if not found
+        Any
+            The configuration value corresponding to the given key, the entire 'paths'
+            dictionary if key is None, or the default value if the key is not found.
+        Raises
+        ------
+        OrionisRuntimeError
+            If the application configuration is not initialized (not booted).
+        OrionisValueError
+            If the provided key is not a string.
+        Notes
+        -----
+        - The method traverses the 'paths' configuration using dot notation for nested keys.
+        - If any part of the key is not found, the default value is returned.
         """
 
         # Ensure the application is booted before accessing configuration
-        if not self.__booted:
-            raise RuntimeError("Application must be booted before accessing configuration. Call create() first.")
+        if not self.__config:
+            raise OrionisRuntimeError("Application configuration is not initialized. Please call create() before accessing path configuration.")
 
-        # If key is None, raise an error to prevent ambiguity
+        # Return the entire configuration if key is None, except for paths
         if key is None:
-            raise ValueError("Key cannot be None. Use path() without arguments to get the entire configuration.")
+            return self.__config['path']
+
+        # If key is None, raise an error to prevent ambiguity
+        if not isinstance(key, str):
+            raise OrionisValueError("Key must be a string. Use path() without arguments to get the entire paths configuration.")
+
+        # Split the key by dot notation
+        parts = key.split('.')
+
+        # Start with the full config
+        config_value = self.__config['path']
+
+        # Traverse the config dictionary based on the key parts
+        for part in parts:
+
+            # If part is not in config_value, return default
+            if isinstance(config_value, dict) and part in config_value:
+                config_value = config_value[part]
 
-        # Get the configuration value for the given key
-        original_paths = self.config('paths')
+            # If part is not found, return default value
+            else:
+                return default
+
+        # Return the final configuration value
+        return config_value
+
+    # === Application Creation Method ===
+    # The create() method is responsible for bootstrapping the application.
+    # It loads the necessary providers and kernels, ensuring that the application
+    # is ready for use. This method should be called once to initialize the application.
+
+    def create(
+        self
+    ) -> 'Application':
+        """
+        Bootstrap the application by loading providers and kernels.
+
+        Returns
+        -------
+        Application
+            The application instance for method chaining
+        """
+        # Check if already booted
+        if not self.__booted:
 
-        # If original_paths is not a dictionary, return the default value as Path
-        if not isinstance(original_paths, dict):
-            return Path(default) if default is not None else None
+            # Load configuration if not already set
+            self.__loadConfig()
 
-        # Get the path value from the dictionary
-        path_value = original_paths.get(key, default)
+            # Load framework providers and register them
+            self.__loadFrameworkProviders()
+            self.__registerProviders()
+            self.__bootProviders()
 
-        # Return as Path object if value exists, otherwise return None
-        return Path(path_value) if path_value is not None else None
+            # Load core framework kernels
+            self.__loadFrameworksKernel()
+
+            # Retrieve logger and console instances from the container
+            logger: ILoggerService = self.make('core.orionis.logger')
+
+            # Calculate elapsed time in milliseconds since application start
+            elapsed_ms = (time.time_ns() - self.startAt) // 1_000_000
+
+            # Compose the boot message
+            boot_message = f"Orionis Framework has been successfully booted. Startup time: {elapsed_ms} ms. Started at: {self.startAt} ns"
+
+            # Log message to the logger
+            logger.info(boot_message)
+
+            # Mark as booted
+            self.__booted = True
+
+        # Return the application instance for method chaining
+        return self