maleo-foundation 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

maleo_foundation/managers/service.py

@@ -1,16 +1,12 @@
 from fastapi import FastAPI, APIRouter
 from fastapi.exceptions import RequestValidationError
 from google.oauth2.service_account import Credentials
-from pathlib import Path
-from pydantic_settings import BaseSettings
-from pydantic import BaseModel, Field
 from redis.asyncio.client import Redis
 from redis.exceptions import RedisError
 from starlette.exceptions import HTTPException
 from starlette.types import Lifespan, AppType
 from sqlalchemy import MetaData
 from typing import Optional
-from uuid import UUID
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
@@ -18,126 +14,26 @@ from maleo_foundation.models.transfers.general.token \
     import MaleoFoundationTokenGeneralTransfers
 from maleo_foundation.models.transfers.parameters.token \
     import MaleoFoundationTokenParametersTransfers
-from maleo_foundation.managers.cache import CacheConfigurations, CacheManagers
-from maleo_foundation.managers.cache.redis import (
-    RedisCacheNamespaces,
-    RedisCacheConfigurations
+from maleo_foundation.models.transfers.general.configurations import (
+    Configurations,
+    Loggers
 )
-from maleo_foundation.managers.db import DatabaseConfigurations, DatabaseManager
-from maleo_foundation.managers.client.google.secret import GoogleSecretManager
+from maleo_foundation.models.transfers.general.credentials import MaleoCredentials
+from maleo_foundation.models.transfers.general.settings import Settings
+from maleo_foundation.managers.cache import CacheManagers
+from maleo_foundation.managers.db import DatabaseManager
 from maleo_foundation.managers.client.google.storage import GoogleCloudStorage
-from maleo_foundation.managers.middleware import (
-    MiddlewareConfigurations,
-    BaseMiddlewareConfigurations,
-    CORSMiddlewareConfigurations,
-    GeneralMiddlewareConfigurations,
-    MiddlewareLoggers,
-    MiddlewareManager
-)
+from maleo_foundation.managers.client.google.secret import GoogleSecretManager
+from maleo_foundation.managers.middleware import MiddlewareManager
 from maleo_foundation.types import BaseTypes
 from maleo_foundation.utils.exceptions import BaseExceptions
-from maleo_foundation.utils.loaders.yaml import YAMLLoader
 from maleo_foundation.utils.logging import (
     SimpleConfig,
     ServiceLogger,
     MiddlewareLogger
 )
-from maleo_foundation.utils.merger import deep_merge
-
-class Settings(BaseSettings):
-    ENVIRONMENT: BaseEnums.EnvironmentType = Field(..., description="Environment")
-    SERVICE_KEY: str = Field(..., description="Service's key")
-    GOOGLE_CREDENTIALS_PATH: str = Field("credentials/maleo-google-service-account.json", description="Internal credential's file path")
-    STATIC_CONFIGURATIONS_PATH: str = Field("configs/static.yaml", description="Maleo's static configurations path")
-    RUNTIME_CONFIGURATIONS_PATH: str = Field("configs/runtime.yaml", description="Service's runtime configurations path")
-
-class MaleoCredentials(BaseModel):
-    id: int = Field(..., description="ID")
-    uuid: UUID = Field(..., description="UUID")
-    username: str = Field(..., description="Username")
-    email: str = Field(..., description="Email")
-    password: str = Field(..., description="Password")
-
-class MiddlewareRuntimeConfigurations(BaseModel):
-    base: BaseMiddlewareConfigurations = Field(..., description="Base middleware's configurations")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class ServiceConfigurations(BaseModel):
-    key: str = Field(..., description="Service's key")
-    name: str = Field(..., description="Service's name")
-    host: str = Field(..., description="Service's host")
-    port: int = Field(..., description="Service's port")
-
-class RuntimeConfigurations(BaseModel):
-    service: ServiceConfigurations = Field(..., description="Service's configurations")
-    middleware: MiddlewareRuntimeConfigurations = Field(..., description="Middleware's runtime configurations")
-    database: str = Field(..., description="Database's name")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class MiddlewareStaticConfigurations(BaseModel):
-    general: GeneralMiddlewareConfigurations = Field(..., description="Middleware's general configurations")
-    cors: CORSMiddlewareConfigurations = Field(..., description="CORS middleware's configurations")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class MaleoClientConfiguration(BaseModel):
-    key: str = Field(..., description="Client's key")
-    name: str = Field(..., description="Client's name")
-    url: str = Field(..., description="Client's URL")
-
-class MaleoClientConfigurations(BaseModel):
-    telemetry: MaleoClientConfiguration = Field(..., description="MaleoTelemetry client's configuration")
-    metadata: MaleoClientConfiguration = Field(..., description="MaleoMetadata client's configuration")
-    identity: MaleoClientConfiguration = Field(..., description="MaleoIdentity client's configuration")
-    access: MaleoClientConfiguration = Field(..., description="MaleoAccess client's configuration")
-    workshop: MaleoClientConfiguration = Field(..., description="MaleoWorkshop client's configuration")
-    medix: MaleoClientConfiguration = Field(..., description="MaleoMedix client's configuration")
-    fhir: MaleoClientConfiguration = Field(..., description="MaleoFHIR client's configuration")
-    dicom: MaleoClientConfiguration = Field(..., description="MaleoDICOM client's configuration")
-    scribe: MaleoClientConfiguration = Field(..., description="MaleoScribe client's configuration")
-    cds: MaleoClientConfiguration = Field(..., description="MaleoCDS client's configuration")
-    imaging: MaleoClientConfiguration = Field(..., description="MaleoImaging client's configuration")
-    mcu: MaleoClientConfiguration = Field(..., description="MaleoMCU client's configuration")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class ClientConfigurations(BaseModel):
-    maleo: MaleoClientConfigurations = Field(..., description="Maleo client's configurations")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class StaticConfigurations(BaseModel):
-    middleware: MiddlewareStaticConfigurations = Field(..., description="Middleware's static configurations")
-    client: ClientConfigurations = Field(..., description="Client's configurations")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class Configurations(BaseModel):
-    service: ServiceConfigurations = Field(..., description="Service's configurations")
-    middleware: MiddlewareConfigurations = Field(..., description="Middleware's configurations")
-    cache: CacheConfigurations = Field(..., description="Cache's configurations")
-    database: DatabaseConfigurations = Field(..., description="Database's configurations")
-    client: ClientConfigurations = Field(..., description="Client's configurations")
-
-    class Config:
-        arbitrary_types_allowed=True
-
-class Loggers(BaseModel):
-    application: ServiceLogger = Field(..., description="Application logger")
-    repository: ServiceLogger = Field(..., description="Repository logger")
-    database: ServiceLogger = Field(..., description="Database logger")
-    middleware: MiddlewareLoggers = Field(..., description="Middleware logger")
-
-    class Config:
-        arbitrary_types_allowed=True
+from .credential import CredentialManager
+from .configuration import ConfigurationManager
 
 class ServiceManager:
     def __init__(
@@ -149,13 +45,22 @@ class ServiceManager:
         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() #* Initialize settings
+
         #* Disable google cloud logging if environment is local
         if self._settings.ENVIRONMENT == "local":
             self._log_config.google_cloud_logging = None
-        self._load_google_credentials()
-        self._initialize_secret_manager()
-        self._load_maleo_credentials()
-        self._load_configs()
+
+        #* Initialize Managers
+        self._credential_manager = CredentialManager(
+            settings=self._settings,
+            log_config=self._log_config
+        )
+
+        self._configuration_manager = ConfigurationManager(
+            settings=self._settings,
+            credential_manager=self._credential_manager
+        )
+
         self._load_keys()
         self._initialize_loggers()
         self._initialize_cache()
@@ -163,107 +68,34 @@ class ServiceManager:
         self._initialize_db()
         self._initialize_foundation()
 
-    @property
-    def log_config(self) -> SimpleConfig:
-        return self._log_config
-
     @property
     def settings(self) -> Settings:
         return self._settings
-
-    def _load_google_credentials(self) -> None:
-        self._google_credentials = Credentials.from_service_account_file(self._settings.GOOGLE_CREDENTIALS_PATH)
-
+    
     @property
-    def google_credentials(self) -> None:
-        return self._google_credentials
-
-    def _initialize_secret_manager(self) -> None:
-        self._secret_manager = GoogleSecretManager(
-            log_config=self._log_config,
-            service_key=self._settings.SERVICE_KEY,
-            credentials=self._google_credentials
-        )
-
+    def log_config(self) -> SimpleConfig:
+        return self._log_config
+    
+    @property
+    def google_credentials(self) -> Credentials:
+        return self._credential_manager.google_credentials
+    
     @property
     def secret_manager(self) -> GoogleSecretManager:
-        return self._secret_manager
-
-    def _load_maleo_credentials(self) -> None:
-        environment = (
-            BaseEnums.EnvironmentType.STAGING
-            if self._settings.ENVIRONMENT == BaseEnums.EnvironmentType.LOCAL
-            else self._settings.ENVIRONMENT
-        )
-        id = int(self._secret_manager.get(f"maleo-service-account-id-{environment}"))
-        uuid = self._secret_manager.get(f"maleo-service-account-uuid-{environment}")
-        email = self._secret_manager.get("maleo-service-account-email")
-        username = self._secret_manager.get("maleo-service-account-username")
-        password = self._secret_manager.get("maleo-service-account-password")
-        self._maleo_credentials = MaleoCredentials(
-            id=id,
-            uuid=UUID(uuid),
-            username=username,
-            email=email,
-            password=password
-        )
-
+        return self._credential_manager.secret_manager
+    
     @property
     def maleo_credentials(self) -> MaleoCredentials:
-        return self._maleo_credentials
-
-    def _load_configs(self) -> None:
-        #* Load static configurations
-        static_configurations_path = Path(self._settings.STATIC_CONFIGURATIONS_PATH)
-        if static_configurations_path.exists() and static_configurations_path.is_file():
-            static_configurations = YAMLLoader.load_from_path(self._settings.STATIC_CONFIGURATIONS_PATH)
-        else:
-            data = self._secret_manager.get(f"maleo-static-config-{self._settings.ENVIRONMENT}")
-            static_configurations = YAMLLoader.load_from_string(data)
-        static_configs = StaticConfigurations.model_validate(static_configurations)
-
-        #* Load runtime configurations
-        runtime_configurations_path = Path(self._settings.RUNTIME_CONFIGURATIONS_PATH)
-        if runtime_configurations_path.exists() and runtime_configurations_path.is_file():
-            runtime_configurations = YAMLLoader.load_from_path(self._settings.RUNTIME_CONFIGURATIONS_PATH)
-        else:
-            data = self._secret_manager.get(f"{self._settings.SERVICE_KEY}-runtime-config-{self._settings.ENVIRONMENT}")
-            runtime_configurations = YAMLLoader.load_from_string(data)
-        runtime_configs = RuntimeConfigurations.model_validate(runtime_configurations)
-
-        #* Load redis cache configurations
-        namespaces = RedisCacheNamespaces(base=self._settings.SERVICE_KEY)
-        host = self._secret_manager.get(name=f"maleo-redis-host-{self._settings.ENVIRONMENT}")
-        password = self._secret_manager.get(name=f"maleo-redis-password-{self._settings.ENVIRONMENT}")
-        redis = RedisCacheConfigurations(namespaces=namespaces, host=host, password=password)
-        cache = CacheConfigurations(redis=redis)
-
-        #* Load database configurations
-        password = self._secret_manager.get(name=f"maleo-db-password-{self._settings.ENVIRONMENT}")
-        host = self._secret_manager.get(name=f"maleo-db-host-{self._settings.ENVIRONMENT}")
-        database = DatabaseConfigurations(
-            password=password,
-            host=host,
-            database=runtime_configs.database
-        )
-
-        #* Load whole configurations
-        merged_configs = deep_merge(
-            static_configs.model_dump(),
-            runtime_configs.model_dump(exclude={"database"}),
-            {"cache": cache.model_dump()},
-            {"database": database.model_dump()}
-        )
-        self._configs = Configurations.model_validate(merged_configs)
-
+        return self._credential_manager.maleo_credentials
+    
     @property
     def configs(self) -> Configurations:
-        return self._configs
+        return self._configuration_manager.configs
 
     def _load_keys(self) -> None:
-        password = self._secret_manager.get(name="maleo-key-password")
-        private = self._secret_manager.get(name="maleo-private-key")
-        public = self._secret_manager.get(name="maleo-public-key")
+        password = self.secret_manager.get(name="maleo-key-password")
+        private = self.secret_manager.get(name="maleo-private-key")
+        public = self.secret_manager.get(name="maleo-public-key")
         self._keys = BaseGeneralSchemas.RSAKeys(
             password=password,
             private=private,
@@ -278,31 +110,24 @@ class ServiceManager:
         #* Service's loggers
         application = ServiceLogger(
             type=BaseEnums.LoggerType.APPLICATION,
-            service_key=self._configs.service.key,
+            service_key=self.configs.service.key,
             **self._log_config.model_dump()
         )
         database = ServiceLogger(
             type=BaseEnums.LoggerType.DATABASE,
-            service_key=self._configs.service.key,
+            service_key=self.configs.service.key,
             **self._log_config.model_dump()
         )
         repository = ServiceLogger(
             type=BaseEnums.LoggerType.REPOSITORY,
-            service_key=self._configs.service.key,
-            **self._log_config.model_dump()
-        )
-        #* Middleware's loggers
-        base = MiddlewareLogger(
-            middleware_type=BaseEnums.MiddlewareLoggerType.BASE,
-            service_key=self._configs.service.key,
+            service_key=self.configs.service.key,
             **self._log_config.model_dump()
         )
-        authentication = MiddlewareLogger(
-            middleware_type=BaseEnums.MiddlewareLoggerType.AUTHENTICATION,
-            service_key=self._configs.service.key,
+        #* Middleware's logger
+        middleware = MiddlewareLogger(
+            service_key=self.configs.service.key,
             **self._log_config.model_dump()
         )
-        middleware = MiddlewareLoggers(base=base, authentication=authentication)
         self._loggers = Loggers(
             application=application,
             repository=repository,
@@ -316,12 +141,12 @@ class ServiceManager:
 
     def _initialize_cache(self) -> None:
         self._redis = Redis(
-            host=self._configs.cache.redis.host,
-            port=self._configs.cache.redis.port,
-            db=self._configs.cache.redis.db,
-            password=self._configs.cache.redis.password,
-            decode_responses=self._configs.cache.redis.decode_responses,
-            health_check_interval=self._configs.cache.redis.health_check_interval
+            host=self.configs.cache.redis.host,
+            port=self.configs.cache.redis.port,
+            db=self.configs.cache.redis.db,
+            password=self.configs.cache.redis.password,
+            decode_responses=self.configs.cache.redis.decode_responses,
+            health_check_interval=self.configs.cache.redis.health_check_interval
         )
         self._cache = CacheManagers(redis=self._redis)
 
@@ -352,7 +177,7 @@ class ServiceManager:
             log_config=self._log_config,
             service_key=self._settings.SERVICE_KEY,
             bucket_name=f"maleo-suite-{environment}",
-            credentials=self._google_credentials,
+            credentials=self.google_credentials,
             redis=self._redis
         )
 
@@ -364,7 +189,7 @@ class ServiceManager:
         self._database = DatabaseManager(
             metadata=self._db_metadata,
             logger=self._loggers.database,
-            url=self._configs.database.url
+            url=self.configs.database.url
         )
 
     @property
@@ -385,12 +210,12 @@ class ServiceManager:
     def token(self) -> BaseTypes.OptionalString:
         payload = MaleoFoundationTokenGeneralTransfers.BaseEncodePayload(
             iss=None,
-            sub=str(self._maleo_credentials.id),
+            sub=str(self.maleo_credentials.id),
             sr="administrator",
-            u_i=self._maleo_credentials.id,
-            u_uu=self._maleo_credentials.uuid,
-            u_u=self._maleo_credentials.username,
-            u_e=self._maleo_credentials.email,
+            u_i=self.maleo_credentials.id,
+            u_uu=self.maleo_credentials.uuid,
+            u_u=self.maleo_credentials.username,
+            u_e=self.maleo_credentials.email,
             u_ut="service",
             exp_in=1
         )
@@ -408,9 +233,9 @@ class ServiceManager:
         lifespan: Optional[Lifespan[AppType]] = None
     ) -> FastAPI:
         self._loggers.application.info("Creating FastAPI application")
-        root_path = "" if self._settings.ENVIRONMENT == "local" else f"/{self._configs.service.key.removeprefix("maleo-")}"
+        root_path = "" if self._settings.ENVIRONMENT == "local" else f"/{self.configs.service.key.removeprefix("maleo-")}"
         self._app = FastAPI(
-            title=self._configs.service.name,
+            title=self.configs.service.name,
             lifespan=lifespan,
             root_path=root_path
         )
@@ -420,7 +245,7 @@ class ServiceManager:
         self._loggers.application.info("Configuring middlewares")
         self._middleware = MiddlewareManager(
             app=self._app,
-            configurations=self._configs.middleware,
+            configurations=self.configs.middleware,
             keys=self._keys,
             loggers=self._loggers.middleware,
             maleo_foundation=self._foundation

maleo_foundation/middlewares/authentication.py

@@ -16,12 +16,10 @@ class Backend(AuthenticationBackend):
     def __init__(
         self,
         keys: BaseGeneralSchemas.RSAKeys,
-        logger: MiddlewareLogger,
         maleo_foundation: MaleoFoundationClientManager
     ):
         super().__init__()
         self._keys = keys
-        self._logger = logger
         self._maleo_foundation = maleo_foundation
 
     async def authenticate(
@@ -100,7 +98,6 @@ class Backend(AuthenticationBackend):
 def add_authentication_middleware(
     app: FastAPI,
     keys: BaseGeneralSchemas.RSAKeys,
-    logger: MiddlewareLogger,
     maleo_foundation: MaleoFoundationClientManager
 ) -> None:
     """
@@ -110,9 +107,6 @@ def add_authentication_middleware(
         app: FastAPI
             The FastAPI application instance to which the middleware will be added.
 
-        logger: MiddlewareLogger
-            Authentication middleware logger to be used.
-
         key: str
             Public key to be used for token decoding.
 
@@ -130,6 +124,6 @@ def add_authentication_middleware(
     """
     app.add_middleware(
         AuthenticationMiddleware,
-        backend=Backend(keys, logger, maleo_foundation),
+        backend=Backend(keys, maleo_foundation),
         on_error=BaseExceptions.authentication_error_handler
     )

maleo_foundation/models/schemas/parameter.py

@@ -9,7 +9,7 @@ from maleo_foundation.extended_types import ExtendedTypes
 
 class BaseParameterSchemas:
     class IdentifierType(BaseModel):
-        identifier: BaseEnums.IdentifierTypes = Field(..., description="Data's identifier type")
+        identifier: BaseEnums.IdentifierType = Field(..., description="Data's identifier type")
 
     class IdentifierValue(BaseModel):
         value: BaseTypes.IdentifierValue = Field(..., description="Data's identifier value")

maleo_foundation/models/transfers/general/configurations/__init__.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel, Field
+from maleo_foundation.utils.logging import MiddlewareLogger, ServiceLogger
+from .cache import CacheConfigurations
+from .client import ClientConfigurations
+from .database import DatabaseConfigurations
+from .middleware import (
+    MiddlewareRuntimeConfigurations,
+    MiddlewareStaticConfigurations,
+    MiddlewareConfigurations
+)
+from .service import ServiceConfigurations
+
+class RuntimeConfigurations(BaseModel):
+    service: ServiceConfigurations = Field(..., description="Service's configurations")
+    middleware: MiddlewareRuntimeConfigurations = Field(..., description="Middleware's runtime configurations")
+    database: str = Field(..., description="Database's name")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class StaticConfigurations(BaseModel):
+    middleware: MiddlewareStaticConfigurations = Field(..., description="Middleware's static configurations")
+    client: ClientConfigurations = Field(..., description="Client's configurations")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class Configurations(BaseModel):
+    service: ServiceConfigurations = Field(..., description="Service's configurations")
+    middleware: MiddlewareConfigurations = Field(..., description="Middleware's configurations")
+    cache: CacheConfigurations = Field(..., description="Cache's configurations")
+    database: DatabaseConfigurations = Field(..., description="Database's configurations")
+    client: ClientConfigurations = Field(..., description="Client's configurations")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class Loggers(BaseModel):
+    application: ServiceLogger = Field(..., description="Application logger")
+    repository: ServiceLogger = Field(..., description="Repository logger")
+    database: ServiceLogger = Field(..., description="Database logger")
+    middleware: MiddlewareLogger = Field(..., description="Middleware logger")
+
+    class Config:
+        arbitrary_types_allowed=True

maleo_foundation/{managers → models/transfers/general/configurations}/cache/__init__.py

@@ -1,15 +1,8 @@
 from __future__ import annotations
 from pydantic import BaseModel, Field
-from redis.asyncio.client import Redis
 from .redis import RedisCacheConfigurations
 
 SKIP_CACHE_FUNC = lambda x: x is None
 
 class CacheConfigurations(BaseModel):
-    redis:RedisCacheConfigurations = Field(..., description="Redis cache's configurations")
-
-class CacheManagers(BaseModel):
-    redis:Redis = Field(..., description="Redis client")
-
-    class Config:
-        arbitrary_types_allowed=True
+    redis:RedisCacheConfigurations = Field(..., description="Redis cache's configurations")

maleo_foundation/models/transfers/general/configurations/client/__init__.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+from .maleo import MaleoClientsConfigurations
+
+class ClientConfigurations(BaseModel):
+    maleo: MaleoClientsConfigurations = Field(..., description="Maleo client's configurations")
+
+    class Config:
+        arbitrary_types_allowed=True

maleo_foundation/models/transfers/general/configurations/client/maleo.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel, Field
+
+class MaleoClientConfigurations(BaseModel):
+    key: str = Field(..., description="Client's key")
+    name: str = Field(..., description="Client's name")
+    url: str = Field(..., description="Client's URL")
+
+class MaleoClientsConfigurations(BaseModel):
+    telemetry: MaleoClientConfigurations = Field(..., description="MaleoTelemetry client's configuration")
+    metadata: MaleoClientConfigurations = Field(..., description="MaleoMetadata client's configuration")
+    identity: MaleoClientConfigurations = Field(..., description="MaleoIdentity client's configuration")
+    access: MaleoClientConfigurations = Field(..., description="MaleoAccess client's configuration")
+    workshop: MaleoClientConfigurations = Field(..., description="MaleoWorkshop client's configuration")
+    medix: MaleoClientConfigurations = Field(..., description="MaleoMedix client's configuration")
+    fhir: MaleoClientConfigurations = Field(..., description="MaleoFHIR client's configuration")
+    dicom: MaleoClientConfigurations = Field(..., description="MaleoDICOM client's configuration")
+    scribe: MaleoClientConfigurations = Field(..., description="MaleoScribe client's configuration")
+    cds: MaleoClientConfigurations = Field(..., description="MaleoCDS client's configuration")
+    imaging: MaleoClientConfigurations = Field(..., description="MaleoImaging client's configuration")
+    mcu: MaleoClientConfigurations = Field(..., description="MaleoMCU client's configuration")
+
+    class Config:
+        arbitrary_types_allowed=True

maleo_foundation/models/transfers/general/configurations/database.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+class DatabaseConfigurations(BaseModel):
+    username: str = Field("postgres", description="Database user's username")
+    password: str = Field(..., description="Database user's password")
+    host: str = Field(..., description="Database's host")
+    port: int = Field(5432, description="Database's port")
+    database: str = Field(..., description="Database")
+
+    @property
+    def url(self) -> str:
+        return f"postgresql://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"

maleo_foundation/models/transfers/general/configurations/middleware.py

@@ -0,0 +1,60 @@
+from pydantic import BaseModel, Field
+from typing import List
+from maleo_foundation.utils.logging import MiddlewareLogger
+
+_ALLOW_METHODS: List[str] = [
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS"
+]
+_ALLOW_HEADERS: List[str] = [
+    "Authorization",
+    "Content-Type",
+    "X-Request-Id",
+    "X-Requested-At",
+    "X-Signature"
+]
+_EXPOSE_HEADERS: List[str] = [
+    "X-New-Authorization",
+    "X-Process-Time",
+    "X-Request-Id",
+    "X-Requested-At",
+    "X-Responded-At",
+    "X-Signature"
+]
+
+class GeneralMiddlewareConfigurations(BaseModel):
+    allow_origins: List[str] = Field(default_factory=list, description="Allowed origins")
+    allow_methods: List[str] = Field(_ALLOW_METHODS, description="Allowed methods")
+    allow_headers: list[str] = Field(_ALLOW_HEADERS, description="Allowed headers")
+    allow_credentials: bool = Field(True, description="Allowed credentials")
+
+class CORSMiddlewareConfigurations(BaseModel):
+    expose_headers: List[str] = Field(_EXPOSE_HEADERS, description="Exposed headers")
+
+class MiddlewareStaticConfigurations(BaseModel):
+    general: GeneralMiddlewareConfigurations = Field(..., description="Middleware's general configurations")
+    cors: CORSMiddlewareConfigurations = Field(..., description="CORS middleware's configurations")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class BaseMiddlewareConfigurations(BaseModel):
+    limit: int = Field(10, description="Request limit (per 'window' seconds)")
+    window: int = Field(1, description="Request limit window (seconds)")
+    cleanup_interval: int = Field(60, description="Interval for middleware cleanup (seconds)")
+    ip_timeout: int = Field(300, description="Idle IP's timeout (seconds)")
+
+class MiddlewareRuntimeConfigurations(BaseModel):
+    base: BaseMiddlewareConfigurations = Field(..., description="Base middleware's configurations")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class MiddlewareConfigurations(BaseModel):
+    general: GeneralMiddlewareConfigurations = Field(..., description="Middleware's general configurations")
+    cors: CORSMiddlewareConfigurations = Field(..., description="CORS middleware's configurations")
+    base: BaseMiddlewareConfigurations = Field(..., description="Base middleware's configurations")

maleo_foundation/models/transfers/general/configurations/service.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel, Field
+
+class ServiceConfigurations(BaseModel):
+    key: str = Field(..., description="Service's key")
+    name: str = Field(..., description="Service's name")
+    host: str = Field(..., description="Service's host")
+    port: int = Field(..., description="Service's port")

maleo_foundation/models/transfers/general/credentials.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+from uuid import UUID
+
+class MaleoCredentials(BaseModel):
+    id: int = Field(..., description="ID")
+    uuid: UUID = Field(..., description="UUID")
+    username: str = Field(..., description="Username")
+    email: str = Field(..., description="Email")
+    password: str = Field(..., description="Password")