maleo-foundation 0.3.71__tar.gz → 0.3.74__tar.gz

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.3.71
+Version: 0.3.74
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT
@@ -98,6 +98,8 @@ Requires-Dist: starlette>=0.46.2
 Requires-Dist: twine>=6.1.0
 Requires-Dist: typing-inspection>=0.4.0
 Requires-Dist: typing_extensions>=4.13.2
+Requires-Dist: ua-parser>=1.0.1
+Requires-Dist: ua-parser-builtins>=0.18.0.post1
 Requires-Dist: urllib3>=2.4.0
 Requires-Dist: uvicorn>=0.34.2
 Requires-Dist: virtualenv>=20.31.2

maleo_foundation-0.3.74/maleo_foundation/authentication.py

@@ -0,0 +1,36 @@
+from starlette.authentication import AuthCredentials, BaseUser
+from typing import Optional, Sequence
+from maleo_foundation.models.transfers.general.authentication import Token
+
+
+class Credentials(AuthCredentials):
+    def __init__(
+        self, token: Optional[Token] = None, scopes: Optional[Sequence[str]] = None
+    ) -> None:
+        self._token = token
+        super().__init__(scopes)
+
+    @property
+    def token(self) -> Optional[Token]:
+        return self._token
+
+
+class User(BaseUser):
+    def __init__(
+        self, authenticated: bool = False, username: str = "", email: str = ""
+    ) -> None:
+        self._authenticated = authenticated
+        self._username = username
+        self._email = email
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self._authenticated
+
+    @property
+    def display_name(self) -> str:
+        return self._username
+
+    @property
+    def identity(self) -> str:
+        return self._email

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/client/manager.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
+from typing import Optional
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.managers.client.base import ClientManager
-from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.logging import SimpleConfig
 from maleo_foundation.client.services.encryption import (
     MaleoFoundationAESEncryptionClientService,
@@ -23,11 +24,16 @@ from maleo_foundation.client.services import (
 
 class MaleoFoundationClientManager(ClientManager):
     def __init__(
-        self, log_config: SimpleConfig, service_key: BaseTypes.OptionalString = None
+        self,
+        log_config: SimpleConfig,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
     ) -> None:
         key = "maleo-foundation"
         name = "MaleoFoundation"
-        super().__init__(key, name, log_config, service_key)
+        super().__init__(
+            key, name, log_config, service_environment, service_key, service_environment
+        )
         self._initialize_services()
         self._logger.info("Client manager initialized successfully")
 

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/constants.py

@@ -1,9 +1,11 @@
 import re
+from fastapi.security import HTTPBearer
 from typing import List
 from uuid import UUID
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.types import BaseTypes
 
+TOKEN_SCHEME = HTTPBearer()
 EMAIL_REGEX: str = r"^[^\s@]+@[^\s@]+\.[^\s@]+$"
 TOKEN_COOKIE_KEY_NAME = "token"
 REFRESH_TOKEN_DURATION_DAYS: int = 7

maleo_foundation-0.3.74/maleo_foundation/controller_types.py

@@ -0,0 +1,25 @@
+from google.cloud.pubsub_v1.subscriber.message import Message
+from typing import Awaitable, Callable, Optional, Union
+from maleo_foundation.models.transfers.results.service.controllers.rest import (
+    BaseServiceRESTControllerResults,
+)
+
+
+class ControllerTypes:
+    # * REST controller types
+    SyncRESTController = Callable[..., BaseServiceRESTControllerResults]
+    OptionalSyncRESTController = Optional[
+        Callable[..., BaseServiceRESTControllerResults]
+    ]
+    AsyncRESTController = Callable[..., Awaitable[BaseServiceRESTControllerResults]]
+    OptionalAsyncRESTController = Optional[
+        Callable[..., Awaitable[BaseServiceRESTControllerResults]]
+    ]
+    RESTController = Union[SyncRESTController, AsyncRESTController]
+    OptionalRESTController = Optional[RESTController]
+
+    # * Message controller types
+    SyncMessageController = Callable[[str, Message], bool]
+    AsyncMessageController = Callable[[str, Message], Awaitable[bool]]
+    MessageController = Union[SyncMessageController, AsyncMessageController]
+    OptionalMessageController = Optional[MessageController]

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/enums.py

@@ -69,10 +69,12 @@ class BaseEnums:
 
     class ExceptionType(StrEnum):
         TIMEOUT = "timeout"
+        BAD = "bad"
         UNAUTHORIZED = "unauthorized"
         FORBIDDEN = "forbidden"
         NOT_FOUND = "not_found"
         VALIDATION = "validation"
+        RATE_LIMIT = "rate_limit"
         INTERNAL = "internal"
         UNAVAILABLE = "unavailable"
 
@@ -91,6 +93,7 @@ class BaseEnums:
         SERVICE = "service"
 
     class OperationLayer(StrEnum):
+        MIDDLEWARE = "middleware"
         ROUTER = "router"
         CONTROLLER = "controller"
         SERVICE = "service"
@@ -122,6 +125,7 @@ class BaseEnums:
         READ = "read"
         UPDATE = "update"
         DELETE = "delete"
+        OTHER = "other"
 
     class CreateType(StrEnum):
         CREATE = "create"
@@ -185,12 +189,14 @@ class BaseEnums:
         APPLICATION = "application"
         CACHE = "cache"
         CLIENT = "client"
+        CONTROLLER = "controller"
         DATABASE = "database"
         MIDDLEWARE = "middleware"
         REPOSITORY = "repository"
+        ROUTER = "router"
         SERVICE = "service"
 
-    class LoggerLevel(IntEnum):
+    class LogLevel(IntEnum):
         CRITICAL = logging.CRITICAL
         FATAL = logging.FATAL
         ERROR = logging.ERROR

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/client/base.py

@@ -1,8 +1,9 @@
 import httpx
+import os
 from contextlib import asynccontextmanager
 from pydantic import BaseModel, ConfigDict, Field
-from typing import AsyncGenerator, Generator
-from maleo_foundation.types import BaseTypes
+from typing import AsyncGenerator, Generator, Optional
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.utils.logging import ClientLogger, SimpleConfig
 
 
@@ -107,18 +108,43 @@ class ClientManager:
         key: str,
         name: str,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
     ) -> None:
         self._key = key
         self._name = name
         self._log_config = log_config
-        self._service_key = service_key
+
+        # Ensure environment exists
+        actual_service_environment = service_environment or os.getenv("ENVIRONMENT")
+        if actual_service_environment is None:
+            raise ValueError(
+                "ENVIRONMENT environment variable must be set if 'service_environment' is set to None"
+            )
+        else:
+            self._service_environment = BaseEnums.EnvironmentType(
+                actual_service_environment
+            )
+
+        # Ensure service_key exists
+        actual_service_key = service_key or os.getenv("SERVICE_KEY")
+        if actual_service_key is None:
+            raise ValueError(
+                "SERVICE_KEY environment variable must be set if 'service_key' is set to None"
+            )
+        else:
+            self._service_key = BaseEnums.Service(actual_service_key)
+
+        self._environment = environment
+
         self._initialize_logger()
-        self._logger.info("Initializing client manager")
+        self._logger.info(f"Initializing {self._name} client manager")
 
     def _initialize_logger(self) -> None:
         self._logger = ClientLogger(
             client_key=self._key,
+            environment=self._service_environment,
             service_key=self._service_key,
             **self._log_config.model_dump(),
         )
@@ -131,6 +157,12 @@ class ClientManager:
     def name(self) -> str:
         return self._name
 
+    @property
+    def environment(self) -> BaseEnums.EnvironmentType:
+        if self._environment is None:
+            raise ValueError("Environment has not been initialized.")
+        return self._environment
+
     @property
     def logger(self) -> ClientLogger:
         return self._logger

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/client/google/base.py

@@ -1,7 +1,7 @@
 from google.oauth2.service_account import Credentials
 from pathlib import Path
 from typing import Optional, Union
-from maleo_foundation.types import BaseTypes
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.managers.client.base import ClientManager
 from maleo_foundation.utils.loaders.credential.google import GoogleCredentialsLoader
 from maleo_foundation.utils.logging import SimpleConfig
@@ -13,11 +13,15 @@ class GoogleClientManager(ClientManager):
         key: str,
         name: str,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
     ) -> None:
-        super().__init__(key, name, log_config, service_key)
+        super().__init__(
+            key, name, log_config, service_environment, service_key, environment
+        )
         if (credentials is not None and credentials_path is not None) or (
             credentials is None and credentials_path is None
         ):

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/client/google/secret.py

@@ -4,7 +4,7 @@ from google.cloud import secretmanager
 from google.oauth2.service_account import Credentials
 from pathlib import Path
 from typing import Optional, Union
-from maleo_foundation.types import BaseTypes
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.utils.logging import SimpleConfig
 from .base import GoogleClientManager
 
@@ -13,14 +13,23 @@ class GoogleSecretManager(GoogleClientManager):
     def __init__(
         self,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
     ) -> None:
         key = "google-secret-manager"
         name = "GoogleSecretManager"
         super().__init__(
-            key, name, log_config, service_key, credentials, credentials_path
+            key,
+            name,
+            log_config,
+            service_environment,
+            service_key,
+            environment,
+            credentials,
+            credentials_path,
         )
         self._client = secretmanager.SecretManagerServiceClient(
             credentials=self._credentials

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/client/google/storage.py

@@ -15,7 +15,9 @@ class GoogleCloudStorage(GoogleClientManager):
     def __init__(
         self,
         log_config: SimpleConfig,
-        service_key: BaseTypes.OptionalString = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
         bucket_name: BaseTypes.OptionalString = None,
@@ -24,7 +26,14 @@ class GoogleCloudStorage(GoogleClientManager):
         key = "google-cloud-storage"
         name = "GoogleCloudStorage"
         super().__init__(
-            key, name, log_config, service_key, credentials, credentials_path
+            key,
+            name,
+            log_config,
+            service_environment,
+            service_key,
+            environment,
+            credentials,
+            credentials_path,
         )
         self._client = Client(credentials=self._credentials)
         self._bucket_name = bucket_name or os.getenv("GCS_BUCKET_NAME")

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/client/google/subscription.py

@@ -5,36 +5,37 @@ from google.cloud.pubsub_v1.subscriber.futures import StreamingPullFuture
 from google.cloud.pubsub_v1.subscriber.message import Message
 from google.oauth2.service_account import Credentials
 from pathlib import Path
-from pydantic import BaseModel
-from typing import Awaitable, Callable, Dict, List, Optional, Union, cast
+from typing import Dict, List, Optional, Union, cast
+from maleo_foundation.controller_types import ControllerTypes
+from maleo_foundation.enums import BaseEnums
 from maleo_foundation.managers.client.google.base import GoogleClientManager
-
-SyncController = Callable[[str, Message], bool]
-AsyncController = Callable[[str, Message], Awaitable[bool]]
-Controller = Union[SyncController, AsyncController]
-OptionalController = Optional[Controller]
-
-
-class SubscriptionConfigurations(BaseModel):
-    subscription_name: str
-    max_messages: int = 10
-    ack_deadline: int = 10
-    controller: OptionalController = None
+from maleo_foundation.models.transfers.general.configurations.pubsub.subscription import (
+    ExtendedSubscriptionConfigurations,
+)
 
 
 class SubscriptionManager(GoogleClientManager):
     def __init__(
         self,
-        subscriptions: List[SubscriptionConfigurations],
+        subscriptions: List[ExtendedSubscriptionConfigurations],
         log_config,
-        service_key: Optional[str] = None,
+        service_environment: Optional[BaseEnums.EnvironmentType] = None,
+        service_key: Optional[BaseEnums.Service] = None,
+        environment: Optional[BaseEnums.EnvironmentType] = None,
         credentials: Optional[Credentials] = None,
         credentials_path: Optional[Union[Path, str]] = None,
     ):
         key = "google-subscription-manager"
         name = "GoogleSubscriptionManager"
         super().__init__(
-            key, name, log_config, service_key, credentials, credentials_path
+            key,
+            name,
+            log_config,
+            service_environment,
+            service_key,
+            environment,
+            credentials,
+            credentials_path,
         )
         self.subscriber = pubsub_v1.SubscriberClient(credentials=self._credentials)
         self.subscriptions = subscriptions
@@ -42,19 +43,28 @@ class SubscriptionManager(GoogleClientManager):
         self.loop: Optional[asyncio.AbstractEventLoop] = None
 
     async def _handle_async_controller(
-        self, controller: AsyncController, subscription_name: str, message: Message
+        self,
+        controller: ControllerTypes.AsyncMessageController,
+        subscription_name: str,
+        message: Message,
     ) -> None:
         success = await controller(subscription_name, message)
         message.ack() if success else message.nack()
 
     def _handle_sync_controller(
-        self, controller: SyncController, subscription_name: str, message: Message
+        self,
+        controller: ControllerTypes.SyncMessageController,
+        subscription_name: str,
+        message: Message,
     ) -> None:
         success = controller(subscription_name, message)
         message.ack() if success else message.nack()
 
     def _message_callback(
-        self, controller: OptionalController, subscription_name: str, message: Message
+        self,
+        controller: ControllerTypes.OptionalMessageController,
+        subscription_name: str,
+        message: Message,
     ):
         # If controller is not given, conduct default message processing
         if controller is None:
@@ -68,13 +78,17 @@ class SubscriptionManager(GoogleClientManager):
                 raise RuntimeError("Event loop not set in SubscriptionManager")
             asyncio.run_coroutine_threadsafe(
                 self._handle_async_controller(
-                    cast(AsyncController, controller), subscription_name, message
+                    cast(ControllerTypes.AsyncMessageController, controller),
+                    subscription_name,
+                    message,
                 ),
                 self.loop,
             )
         else:
             self._handle_sync_controller(
-                cast(SyncController, controller), subscription_name, message
+                cast(ControllerTypes.SyncMessageController, controller),
+                subscription_name,
+                message,
             )
 
     def _default_message_processing(
@@ -94,18 +108,18 @@ class SubscriptionManager(GoogleClientManager):
             message.nack()
 
     async def _start_subscription_listener(
-        self, config: SubscriptionConfigurations
+        self, config: ExtendedSubscriptionConfigurations
     ) -> None:
         if self.credentials.project_id is None:
             raise ValueError("Project ID must be set in credentials")
         subscription_path = self.subscriber.subscription_path(
-            self.credentials.project_id, config.subscription_name
+            self.credentials.project_id, config.id
         )
         flow_control = pubsub_v1.types.FlowControl(max_messages=config.max_messages)
         future = self.subscriber.subscribe(
             subscription_path,
             callback=lambda message: self._message_callback(
-                config.controller, config.subscription_name, message
+                config.controller, config.id, message
             ),
             flow_control=flow_control,
             await_callbacks_on_shutdown=True,
@@ -117,7 +131,7 @@ class SubscriptionManager(GoogleClientManager):
             if not isinstance(e, asyncio.CancelledError):
                 self._logger.error(
                     "Listener error for subscription '%s': %s",
-                    config.subscription_name,
+                    config.id,
                     e,
                     exc_info=True,
                 )

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/client/maleo.py

@@ -74,7 +74,9 @@ class MaleoClientManager(ClientManager):
             key,
             name,
             service_manager.log_config,
-            service_manager.configurations.service.key,
+            service_manager.settings.ENVIRONMENT,
+            service_manager.settings.SERVICE_KEY,
+            environment,
         )
         self._environment = environment
 
@@ -82,10 +84,6 @@ class MaleoClientManager(ClientManager):
     def service_manager(self) -> ServiceManager:
         return self._service_manager
 
-    @property
-    def environment(self) -> BaseEnums.EnvironmentType:
-        return self._environment
-
     def _initialize_controllers(self) -> None:
         # * Initialize managers
         http_controller_manager = ClientHTTPControllerManager(url=self._url)

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/credential.py

@@ -9,9 +9,13 @@ from maleo_foundation.utils.logging import SimpleConfig
 
 
 class CredentialManager:
-    def __init__(self, settings: Settings, log_config: SimpleConfig):
-        self.settings = settings
+    def __init__(
+        self,
+        log_config: SimpleConfig,
+        settings: Settings,
+    ):
         self.log_config = log_config
+        self.settings = settings
         self._initialize()
 
     def _load_google_credentials(self) -> None:

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/middleware.py

@@ -4,6 +4,7 @@ from maleo_foundation.models.schemas import BaseGeneralSchemas
 from maleo_foundation.models.transfers.general.configurations.middleware import (
     MiddlewareConfigurations,
 )
+from maleo_foundation.models.transfers.general.settings import Settings
 from maleo_foundation.middlewares.authentication import add_authentication_middleware
 from maleo_foundation.middlewares.base import add_base_middleware
 from maleo_foundation.middlewares.cors import add_cors_middleware
@@ -14,12 +15,14 @@ class MiddlewareManager:
     def __init__(
         self,
         app: FastAPI,
+        settings: Settings,
         configurations: MiddlewareConfigurations,
         keys: BaseGeneralSchemas.RSAKeys,
         logger: MiddlewareLogger,
         maleo_foundation: MaleoFoundationClientManager,
     ):
         self._app = app
+        self._settings = settings
         self._configurations = configurations
         self._keys = keys
         self._logger = logger
@@ -33,23 +36,20 @@ class MiddlewareManager:
     def add_cors(self) -> None:
         add_cors_middleware(
             app=self._app,
-            allow_origins=self._configurations.general.allow_origins,
-            allow_methods=self._configurations.general.allow_methods,
-            allow_headers=self._configurations.general.allow_headers,
-            allow_credentials=self._configurations.general.allow_credentials,
+            allow_origins=self._configurations.cors.allow_origins,
+            allow_methods=self._configurations.cors.allow_methods,
+            allow_headers=self._configurations.cors.allow_headers,
+            allow_credentials=self._configurations.cors.allow_credentials,
             expose_headers=self._configurations.cors.expose_headers,
         )
 
     def add_base(self):
         add_base_middleware(
             app=self._app,
+            settings=self._settings,
             keys=self._keys,
             logger=self._logger,
             maleo_foundation=self._maleo_foundation,
-            allow_origins=self._configurations.general.allow_origins,
-            allow_methods=self._configurations.general.allow_methods,
-            allow_headers=self._configurations.general.allow_headers,
-            allow_credentials=self._configurations.general.allow_credentials,
             limit=self._configurations.base.limit,
             window=self._configurations.base.window,
             cleanup_interval=self._configurations.base.cleanup_interval,

{maleo_foundation-0.3.71 → maleo_foundation-0.3.74}/maleo_foundation/managers/service.py

@@ -40,6 +40,7 @@ from maleo_foundation.utils.logging import (
     DatabaseLogger,
     MiddlewareLogger,
     RepositoryLogger,
+    RouterLogger,
     ServiceLogger,
 )
 from .credential import CredentialManager
@@ -51,20 +52,14 @@ class ServiceManager:
         self,
         db_metadata: MetaData,
         log_config: SimpleConfig,
-        settings: Optional[Settings] = None,
+        settings: Settings,
         additional_topics_configurations: Optional[
             AdditionalTopicsConfigurations
         ] = None,
     ):
         self._db_metadata = db_metadata  # * Declare DB Metadata
         self._log_config = log_config  # * Declare log config
-        self._settings = (
-            settings if settings is not None else Settings()  # type: ignore
-        )  # * Initialize settings
-
-        # * Disable google cloud logging if environment is local
-        if self._settings.ENVIRONMENT == "local":
-            self._log_config.google_cloud_logging = None
+        self._settings = settings  # * Initialize settings
 
         # * Initialize Credential Manager
         self._credential_manager = CredentialManager(
@@ -134,22 +129,39 @@ class ServiceManager:
 
     def _initialize_loggers(self) -> None:
         application = ApplicationLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         cache = CacheLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         database = DatabaseLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         middleware = MiddlewareLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         repository = RepositoryLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
+        )
+        router = RouterLogger(
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         service = ServiceLogger(
-            service_key=self.configurations.service.key, **self._log_config.model_dump()
+            environment=self.settings.ENVIRONMENT,
+            service_key=self.settings.SERVICE_KEY,
+            **self._log_config.model_dump(),
         )
         self._loggers = Loggers(
             application=application,
@@ -157,6 +169,7 @@ class ServiceManager:
             database=database,
             middleware=middleware,
             repository=repository,
+            router=router,
             service=service,
         )
 
@@ -166,8 +179,8 @@ class ServiceManager:
 
     async def _clear_cache(self) -> None:
         prefixes = [
-            self.configurations.service.key,
-            f"google-cloud-storage:{self.configurations.service.key}",
+            self.settings.SERVICE_KEY,
+            f"google-cloud-storage:{self.settings.SERVICE_KEY}",
         ]
         for prefix in prefixes:
             async for key in self._redis.scan_iter(f"{prefix}*"):
@@ -243,7 +256,9 @@ class ServiceManager:
 
     def _initialize_foundation(self) -> None:
         self._foundation = MaleoFoundationClientManager(
-            log_config=self._log_config, service_key=self._settings.SERVICE_KEY
+            log_config=self._log_config,
+            service_environment=self._settings.ENVIRONMENT,
+            service_key=self._settings.SERVICE_KEY,
         )
 
     @property
@@ -294,6 +309,7 @@ class ServiceManager:
         self._loggers.application.info("Configuring middlewares")
         self._middleware = MiddlewareManager(
             app=self._app,
+            settings=self._settings,
             configurations=self.configurations.middleware,
             keys=self._keys,
             logger=self._loggers.middleware,