maleo-foundation 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

maleo_foundation/authentication.py

@@ -0,0 +1,37 @@
+from starlette.authentication import (
+    AuthCredentials,
+    BaseUser
+)
+from typing import Optional, Sequence
+
+class Credentials(AuthCredentials):
+    def __init__(
+        self,
+        token:Optional[str] = None,
+        scopes:Optional[Sequence[str]] = None
+    ) -> None:
+        self.token = token
+        super().__init__(scopes)
+
+class User(BaseUser):
+    def __init__(
+        self,
+        authenticated:bool = True,
+        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/enums.py

@@ -73,8 +73,11 @@ class BaseEnums:
                 BaseEnums.RESTControllerResponseType.FILE: responses.FileResponse,
             }.get(self, responses.Response)
 
+    class MiddlewareLoggerType(StrEnum):
+        BASE = "base"
+        AUTHENTICATION = "authentication"
+
     class ServiceLoggerType(StrEnum):
-        MIDDLEWARE = "middleware"
         DATABASE = "database"
         APPLICATION = "application"
 

maleo_foundation/managers/middleware.py

@@ -0,0 +1,107 @@
+from fastapi import FastAPI
+from pydantic import BaseModel, Field
+from typing import List, Optional, Sequence
+from maleo_foundation.middlewares.authentication import Backend, add_authentication_middleware
+from maleo_foundation.middlewares.base import add_base_middleware, RequestProcessor
+from maleo_foundation.middlewares.cors import add_cors_middleware
+from maleo_foundation.utils.logging import MiddlewareLogger
+
+_ALLOW_METHODS:List[str] = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+_ALLOW_HEADERS:List[str] = ["X-Organization", "X-User", "X-Signature"]
+_EXPOSE_HEADERS:List[str] = ["X-Request-Timestamp", "X-Response-Timestamp", "X-Process-Time", "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(False, description="Allowed credentials")
+
+class CORSMiddlewareConfigurations(BaseModel):
+    expose_headers:List[str] = Field(_EXPOSE_HEADERS, description="Exposed headers")
+
+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 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")
+
+class MiddlewareLoggers(BaseModel):
+    base:MiddlewareLogger = Field(..., description="Base middleware's logger")
+    authentication:MiddlewareLogger = Field(..., description="Authentication middleware's logger")
+
+    class Config:
+        arbitrary_types_allowed=True
+
+class MiddlewareManager:
+    def __init__(self, app:FastAPI, configurations:MiddlewareConfigurations):
+        self._app = app
+        self._configurations = configurations
+
+    def add_all(
+        self,
+        loggers:MiddlewareLoggers,
+        key:str,
+        authentication_backend:Optional[Backend] = None,
+        request_processor:Optional[RequestProcessor] = None
+    ):
+        self.add_cors(
+            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,
+            expose_headers=self._configurations.cors.expose_headers
+        )
+        self.add_base(
+            logger=loggers.base,
+            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,
+            ip_timeout=self._configurations.base.ip_timeout,
+            request_processor=request_processor
+        )
+        if authentication_backend is None:
+            self._authentication_backend = Backend(logger=loggers.authentication, key=key)
+        else:
+            self._authentication_backend = authentication_backend
+        self.add_authentication(backend=self._authentication_backend)
+
+    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,
+            expose_headers=self._configurations.cors.expose_headers
+        )
+
+    def add_base(self, logger:MiddlewareLogger, request_processor:Optional[RequestProcessor] = None):
+        add_base_middleware(
+            app=self._app,
+            logger=logger,
+            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,
+            ip_timeout=self._configurations.base.ip_timeout,
+            request_processor=request_processor
+        )
+
+    def add_authentication(self, logger:MiddlewareLogger, key:str, backend:Optional[Backend] = None):
+        if backend is None:
+            self._authentication_backend = Backend(logger=logger, key=key)
+        else:
+            self._authentication_backend = backend
+        add_authentication_middleware(app=self._app, backend=self._authentication_backend)

maleo_foundation/managers/service.py

@@ -1,10 +1,14 @@
 import json
 import os
+import uvicorn
+from fastapi import FastAPI, APIRouter
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException
+from starlette.types import Lifespan, AppType
 from pydantic_settings import BaseSettings
 from pydantic import BaseModel, Field
 from sqlalchemy import MetaData
-from typing import Dict, List, Optional, Type
-from maleo_foundation.db.manager import DatabaseManagerV2
+from typing import Optional, Type
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
 from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
@@ -13,10 +17,13 @@ from maleo_foundation.managers.client.google.storage import GoogleCloudStorage
 from maleo_foundation.managers.client.http import HTTPClientManager
 from maleo_foundation.managers.client.maleo import MaleoClientManager
 from maleo_foundation.managers.db import DatabaseManager
+from maleo_foundation.managers.middleware import MiddlewareConfigurations, MiddlewareLoggers, MiddlewareManager
+from maleo_foundation.middlewares.base import RequestProcessor
 from maleo_foundation.services.token import BaseTokenService
 from maleo_foundation.types import BaseTypes
+from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.keyloader import load_key
-from maleo_foundation.utils.logging import GoogleCloudLogging, ServiceLogger, ClientLoggerManager
+from maleo_foundation.utils.logging import GoogleCloudLogging, ServiceLogger, MiddlewareLogger
 
 class LogConfig(BaseModel):
     logs_dir:str = Field(..., description="Logs directory")
@@ -68,10 +75,8 @@ class Credentials(BaseModel):
 class ServiceConfigurations(BaseModel):
     key:str = Field(..., description="Service's key")
     name:str = Field(..., description="Service's name")
-
-class MiddlewareConfigurations(BaseModel):
-    allowed_origins:List[str] = Field(default_factory=list, description="Allowed origins")
-    service_ips:List[str] = Field(default_factory=list, description="Other service's IPs")
+    host:str = Field(..., description="Service's host")
+    port:int = Field(..., description="Service's port")
 
 class DatabaseConfigurations(BaseModel):
     username:str = Field("postgres", description="Database user's username")
@@ -113,18 +118,15 @@ class Configurations(BaseModel):
     service:ServiceConfigurations = Field(..., description="Service's configurations")
     middleware:MiddlewareConfigurations = Field(..., description="Middleware's configurations")
     database:DatabaseConfigurations = Field(..., description="Database's configurations")
-    client:ClientConfigurations = Field(...)
+    client:ClientConfigurations = Field(..., description="Service's configurations")
 
     class Config:
         arbitrary_types_allowed=True
 
-ClientLoggerManagers = Dict[str, ClientLoggerManager]
-
 class Loggers(BaseModel):
     application:ServiceLogger = Field(..., description="Application logger")
     database:ServiceLogger = Field(..., description="Database logger")
-    middleware:ServiceLogger = Field(..., description="Middleware logger")
-    client:ClientLoggerManagers = Field(default_factory=dict, description="Client logger manager")
+    middleware:MiddlewareLoggers = Field(..., description="Middleware logger")
 
     class Config:
         arbitrary_types_allowed=True
@@ -185,7 +187,6 @@ class ServiceManager:
         base_dir:BaseTypes.OptionalString = None,
         settings:Optional[Settings] = None,
         google_cloud_logging:Optional[GoogleCloudLogging] = None,
-        client_logger_managers:ClientLoggerManagers = {},
         maleo_client_manager_classes:Optional[MaleoClientManagerClasses] = None
     ):
         self._db_metadata = db_metadata
@@ -217,7 +218,6 @@ class ServiceManager:
             google_cloud_logging=self._google_cloud_logging
         )
 
-        self._client_logger_managers = client_logger_managers
         self._initialize_loggers()
         self._load_credentials()
         self._parse_keys()
@@ -256,14 +256,14 @@ class ServiceManager:
         return self._configs
 
     def _initialize_loggers(self) -> None:
-        application = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.APPLICATION, google_cloud_logging=self._google_cloud_logging)
-        database = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.DATABASE, google_cloud_logging=self._google_cloud_logging)
-        middleware = ServiceLogger(logs_dir=self._logs_dir, type=BaseEnums.LoggerType.MIDDLEWARE, google_cloud_logging=self._google_cloud_logging)
-        client = self._client_logger_managers
-        for key, logger_manager in client.items():
-            application.info(f"Initializing logger manager for client '{key}'")
-            logger_manager.initialize(logs_dir=self._logs_dir ,client_key=key)
-        self._loggers = Loggers(application=application, database=database, middleware=middleware, client=client)
+        #* Service's loggers
+        application = ServiceLogger(type=BaseEnums.LoggerType.APPLICATION, service_key=self._configs.service.key, **self._log_config.model_dump())
+        database = ServiceLogger(type=BaseEnums.LoggerType.DATABASE, 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, **self._log_config.model_dump())
+        authentication = MiddlewareLogger(middleware_type=BaseEnums.MiddlewareLoggerType.AUTHENTICATION, service_key=self._configs.service.key, **self._log_config.model_dump())
+        middleware = MiddlewareLoggers(base=base, authentication=authentication)
+        self._loggers = Loggers(application=application, database=database, middleware=middleware)
 
     @property
     def loggers(self) -> Loggers:
@@ -321,14 +321,12 @@ class ServiceManager:
         self._http_client.initialize()
         #* Initialize maleo clients
         self._maleo_clients = MaleoClientManagers()
-        # if self._maleo_client_manager_classes.metadata is not None and issubclass(self._maleo_client_manager_classes.metadata, MaleoClientManager):
-        #     self._maleo_clients.metadata = self._maleo_client_manager_classes.metadata(**self._configs.client.maleo.metadata.model_dump(), **self._log_config.model_dump())
-        for field_name in self._maleo_client_manager_classes.__class__.__annotations__:
-            cls = getattr(self._maleo_client_manager_classes, field_name)
-            if cls is not None and issubclass(cls, MaleoClientManager):
-                cfg:MaleoClientConfiguration = getattr(self._configs.client.maleo, field_name)
-                client_instance = cls(**cfg.model_dump(), **self._log_config.model_dump())
-                setattr(self._maleo_clients, field_name, client_instance)
+        for client in self._maleo_client_manager_classes.__class__.__annotations__:
+            client_cls = getattr(self._maleo_client_manager_classes, client)
+            if client_cls is not None and issubclass(client_cls, MaleoClientManager):
+                cfg:MaleoClientConfiguration = getattr(self._configs.client.maleo, client)
+                client_instance = client_cls(**cfg.model_dump(), **self._log_config.model_dump())
+                setattr(self._maleo_clients, client, client_instance)
         self._clients = ClientManagers(google=self._google_clients, http=self._http_client, maleo=self._maleo_clients)
 
     @property
@@ -365,6 +363,28 @@ class ServiceManager:
             raise ValueError("Failed generating token")
         return result.data.token
 
+    def create_app(self, router:APIRouter, lifespan:Optional[Lifespan[AppType]] = None, request_processor:Optional[RequestProcessor] = None) -> FastAPI:
+        self._app = FastAPI(title=self._configs.service.name, lifespan=lifespan)
+
+        self._middleware = MiddlewareManager(app=self._app, configurations=self._configs.middleware)
+        self._middleware.add_all(loggers=self.loggers.middleware, key=self._keys.public, request_processor=request_processor)
+
+        #* Add exception handler(s)
+        self._app.add_exception_handler(RequestValidationError, BaseExceptions.validation_exception_handler)
+        self._app.add_exception_handler(HTTPException, BaseExceptions.http_exception_handler)
+
+        #* Include router
+        self._app.include_router(router)
+
+        return self._app
+
+    @property
+    def app(self) -> FastAPI:
+        return self._app
+
+    def run_app(self) -> None:
+        uvicorn.run(self._app, host=self._configs.service.host, port=self._configs.service.port, reload=True)
+
     async def dispose(self) -> None:
         self._loggers.application.info("Disposing service manager")
         if self._database is not None:
@@ -374,11 +394,14 @@ class ServiceManager:
             self._clients.google.storage.dispose()
             self._clients.google.secret.dispose()
             await self._clients.http.dispose()
-            if self._clients.maleo.metadata is not None:
-                await self._clients.maleo.metadata.dispose()
+            for client in self._maleo_clients.__class__.__annotations__:
+                client_instance = getattr(self._maleo_clients, client)
+                if client_instance is not None and isinstance(client_instance, MaleoClientManager):
+                    await client_instance.dispose()
         self._loggers.application.info("Service manager disposed successfully")
         if self._loggers is not None:
             self._loggers.application.dispose()
             self._loggers.database.dispose()
-            self._loggers.middleware.dispose()
+            self._loggers.middleware.base.dispose()
+            self._loggers.middleware.authentication.dispose()
             self._loggers = None

maleo_foundation/middlewares/authentication.py

@@ -0,0 +1,62 @@
+from fastapi import FastAPI
+from starlette.authentication import AuthenticationBackend
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.requests import HTTPConnection
+from typing import Tuple
+from maleo_foundation.authentication import Credentials, User
+from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
+from maleo_foundation.services.token import BaseTokenService
+from maleo_foundation.utils.extractor import extract_client_ip
+from maleo_foundation.utils.logging import MiddlewareLogger
+
+class Backend(AuthenticationBackend):
+    def __init__(self, logger:MiddlewareLogger, key:str):
+        super().__init__()
+        self._logger = logger
+        self._key = key
+
+    async def authenticate(self, conn:HTTPConnection) -> Tuple[Credentials, User]:
+        client_ip = extract_client_ip(conn)
+        if "Authorization" not in conn.headers:
+            self._logger.info(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Header did not contain authorization")
+            return Credentials(), User(authenticated=False)
+
+        auth = conn.headers["Authorization"]
+        scheme, token = auth.split()
+        if scheme != 'Bearer':
+            self._logger.info(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Authorization scheme is not Bearer")
+            return Credentials(), User(authenticated=False)
+
+        decode_token_parameters = BaseTokenParametersTransfers.Decode(key=self._key, token=token)
+        decode_token_result = BaseTokenService.decode(parameters=decode_token_parameters)
+        if not decode_token_result.success:
+            self._logger.error(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Failed decoding authorization token")
+            return Credentials(token=token), User(authenticated=False)
+
+        self._logger.info(f"Authentication - Request | IP: {client_ip} | URL: {conn.url.path} - Result | Username: {decode_token_result.data.u_u} | Email: {decode_token_result.data.u_e}")
+        return Credentials(token=token), User(authenticated=True, username=decode_token_result.data.u_u, email=decode_token_result.data.u_e)
+
+def add_authentication_middleware(app:FastAPI, backend:Backend) -> None:
+    """
+    Adds Authentication middleware to the FastAPI application.
+
+    Args:
+        app: FastAPI
+            The FastAPI application instance to which the middleware will be added.
+
+        backend: Backend
+            The authentication middleware backend to be used.
+
+    Returns:
+        None: The function modifies the FastAPI app by adding Base middleware.
+
+    Note:
+        FastAPI applies middleware in reverse order of registration, so this middleware
+        will execute after any middleware added subsequently.
+
+    Example:
+    ```python
+    add_authentication_middleware(app=app, limit=10, window=1, cleanup_interval=60, ip_timeout=300)
+    ```
+    """
+    app.add_middleware(AuthenticationMiddleware, backend=backend)

maleo_foundation/middlewares/base.py

@@ -6,10 +6,11 @@ from collections import defaultdict
 from datetime import datetime, timedelta, timezone
 from fastapi import FastAPI, Request, Response, status
 from fastapi.responses import JSONResponse
-from logging import Logger
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from typing import Awaitable, Callable, Optional, Sequence
 from maleo_foundation.models.responses import BaseResponses
+from maleo_foundation.utils.extractor import extract_client_ip
+from maleo_foundation.utils.logging import MiddlewareLogger
 
 RequestProcessor = Callable[[Request], Awaitable[Optional[Response]]]
 ResponseProcessor = Callable[[Response], Awaitable[Response]]
@@ -18,7 +19,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
     def __init__(
         self,
         app,
-        logger:Logger,
+        logger:MiddlewareLogger,
         allow_origins:Sequence[str] = (),
         allow_methods:Sequence[str] = ("GET",),
         allow_headers:Sequence[str] = (),
@@ -178,7 +179,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
         self._cleanup_old_data() #* Run periodic cleanup
         request_timestamp = datetime.now(tz=timezone.utc) #* Record the request timestamp
         start_time = time.perf_counter() #* Record the start time
-        client_ip = self._extract_client_ip(request) #* Get request IP with improved extraction
+        client_ip = extract_client_ip(request) #* Get request IP with improved extraction
 
         try:
             #* 1. Rate limit check
@@ -225,7 +226,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
 
 def add_base_middleware(
     app:FastAPI,
-    logger:Logger,
+    logger:MiddlewareLogger,
     allow_origins:Sequence[str] = (),
     allow_methods:Sequence[str] = ("GET",),
     allow_headers:Sequence[str] = (),

maleo_foundation/utils/extractor.py

@@ -0,0 +1,18 @@
+from starlette.requests import HTTPConnection
+
+def extract_client_ip(conn:HTTPConnection) -> str:
+    """Extract client IP with more robust handling of proxies"""
+    #* Check for X-Forwarded-For header (common when behind proxy/load balancer)
+    x_forwarded_for = conn.headers.get("X-Forwarded-For")
+    if x_forwarded_for:
+        #* The client's IP is the first one in the list
+        ips = [ip.strip() for ip in x_forwarded_for.split(",")]
+        return ips[0]
+
+    #* Check for X-Real-IP header (used by some proxies)
+    x_real_ip = conn.headers.get("X-Real-IP")
+    if x_real_ip:
+        return x_real_ip
+
+    #* Fall back to direct client connection
+    return conn.client.host if conn.client else "unknown"

maleo_foundation/utils/logging.py

@@ -45,6 +45,7 @@ class BaseLogger(logging.Logger):
         logs_dir:str,
         type:BaseEnums.LoggerType,
         service_key:BaseTypes.OptionalString = None,
+        middleware_type:Optional[BaseEnums.MiddlewareLoggerType] = None,
         client_key:BaseTypes.OptionalString = None,
         level:BaseEnums.LoggerLevel = BaseEnums.LoggerLevel.INFO,
         google_cloud_logging:Optional[GoogleCloudLogging] = None
@@ -67,6 +68,11 @@ class BaseLogger(logging.Logger):
         if self._service_key is None:
             raise ValueError("SERVICE_KEY environment variable must be set if 'service_key' is set to None")
 
+        self._middleware_type = middleware_type #* Declare middleware type
+
+        if self._type == BaseEnums.LoggerType.MIDDLEWARE and self._middleware_type is None:
+            raise ValueError("'middleware_type' parameter must be provided if 'logger_type' is 'middleware'")
+
         self._client_key = client_key #* Declare client key
 
         #* Ensure client_key is valid if logger type is a client
@@ -75,7 +81,15 @@ class BaseLogger(logging.Logger):
 
         #* Define logger name
         if self._type == BaseEnums.LoggerType.CLIENT:
+            #* Ensure client_key is valid if logger type is client
+            if self._client_key is None:
+                raise ValueError("'client_key' parameter must be provided if 'logger_type' is 'client'")
             self._name = f"{self._service_key} - {self._type} - {self._client_key}"
+        elif self._type == BaseEnums.LoggerType.MIDDLEWARE:
+            #* Ensure middleware_type is valid if logger type is middleware
+            if self._middleware_type is None:
+                raise ValueError("'middleware_type' parameter must be provided if 'logger_type' is 'middleware'")
+            self._name = f"{self._service_key} - {self._type} - {self._middleware_type}"
         else:
             self._name = f"{self._service_key} - {self._type}"
 
@@ -102,7 +116,9 @@ class BaseLogger(logging.Logger):
             self.info("Cloud logging is not configured.")
 
         #* Define log directory
-        if self._type == BaseEnums.LoggerType.CLIENT:
+        if self._type == BaseEnums.LoggerType.MIDDLEWARE:
+            log_dir = f"{self._type}/{self._middleware_type}"
+        elif self._type == BaseEnums.LoggerType.CLIENT:
             log_dir = f"{self._type}/{self._client_key}"
         else:
             log_dir = f"{self._type}"
@@ -145,6 +161,25 @@ class BaseLogger(logging.Logger):
             handler.close()
         self.handlers.clear()
 
+class MiddlewareLogger(BaseLogger):
+    def __init__(
+        self,
+        logs_dir:str,
+        service_key:BaseTypes.OptionalString = None,
+        middleware_type = None,
+        level = BaseEnums.LoggerLevel.INFO,
+        google_cloud_logging = None
+    ):
+        super().__init__(
+            logs_dir=logs_dir,
+            type=BaseEnums.LoggerType.MIDDLEWARE,
+            service_key=service_key,
+            middleware_type=middleware_type,
+            client_key=None,
+            level=level,
+            google_cloud_logging=google_cloud_logging
+        )
+
 class ServiceLogger(BaseLogger):
     def __init__(
         self,
@@ -158,6 +193,7 @@ class ServiceLogger(BaseLogger):
             logs_dir=logs_dir,
             type=type,
             service_key=service_key,
+            middleware_type=None,
             client_key=None,
             level=level,
             google_cloud_logging=google_cloud_logging
@@ -176,6 +212,7 @@ class ClientLogger(BaseLogger):
             logs_dir=logs_dir,
             type=BaseEnums.LoggerType.CLIENT,
             service_key=service_key,
+            middleware_type=None,
             client_key=client_key,
             level=level,
             google_cloud_logging=google_cloud_logging

{maleo_foundation-0.1.18.dist-info → maleo_foundation-0.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.18
+Version: 0.1.20
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.1.18.dist-info → maleo_foundation-0.1.20.dist-info}/RECORD

@@ -1,6 +1,7 @@
 maleo_foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maleo_foundation/authentication.py,sha256=iwc9cGGi5srW3goPRyuZjoPvdyA3XPgYzIEbVl-IW78,842
 maleo_foundation/constants.py,sha256=aBmEfWlBqZxi0k-n6h2NM1YRLOjMnheEiLyQcjP-zCQ,1164
-maleo_foundation/enums.py,sha256=mhLidFNxo89ZlmfJptB7dNqX7Q_7H9jVS8tvUyp_jQg,2748
+maleo_foundation/enums.py,sha256=93fqLJvg0oZAXuJSFCf0-gsW8JmB6AkJvZzXLd47dIo,2820
 maleo_foundation/extended_types.py,sha256=pIKt-_9tby4rmune3fmWcCW_mohaNRh_1lywBmdc-L4,301
 maleo_foundation/types.py,sha256=aKXnIgEhYGSfFqNMGLc4qIKGkINBRpkOo9R9cb2CbwI,2414
 maleo_foundation/clients/__init__.py,sha256=W8vydJYeDEi6gdmOZSBFSSDsfZJtb8C05CHErZgsZ30,188
@@ -30,7 +31,8 @@ maleo_foundation/expanded_types/service.py,sha256=q8jpKdbCbLWwH1UPQavKpVE14rC5rv
 maleo_foundation/expanded_types/token.py,sha256=4fRTJw6W5MYq71NksNrWNi7qYHQ4_lQwfu9WxwrMipc,355
 maleo_foundation/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/db.py,sha256=Jf0w-9JOAG5X2quDxqqw6d2WUIX7MYGdlPGxWP0rxHs,4699
-maleo_foundation/managers/service.py,sha256=U-KCSl-101if1KOk7Mk1TlPQG2b7j0-gALJZYGNCADQ,18199
+maleo_foundation/managers/middleware.py,sha256=nEhNgvGpvzQ2CouU8dgNe4eBKtYHkihHSHA6yhxR_2k,5461
+maleo_foundation/managers/service.py,sha256=RSjaJDjrvzfTE2z0IYpzJMKYnl4BFaF7UEPl3uupH5k,19215
 maleo_foundation/managers/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/client/base.py,sha256=K8AFV2MTZrC1jbTqxkx7eedmxodJirNIjoRXGGcppy4,1022
 maleo_foundation/managers/client/http.py,sha256=dWFZlG1z4TERYBITReR5oSrlzvdhh2EtztVnsU8gCeA,2712
@@ -40,7 +42,8 @@ maleo_foundation/managers/client/google/base.py,sha256=1lrGoyGnYW5Xq05bVXbKqnsqq
 maleo_foundation/managers/client/google/secret.py,sha256=bWR_3Xl_wUFqj4M48w8ZE692U7PQKX9ap0ndDJviV80,3074
 maleo_foundation/managers/client/google/storage.py,sha256=041iSSaFubnZrP-pS8MiLVtOgeLQ591Iz64JekZ5K7o,2350
 maleo_foundation/middlewares/__init__.py,sha256=bqE2EIFC3rWcR2AwFPR0fk2kSFfeTRzgA24GbnuT5RA,3697
-maleo_foundation/middlewares/base.py,sha256=KcpODNs0DQXX8Cwc6T9dC6aiZIqxTLtuJjVAGWXPSKk,11633
+maleo_foundation/middlewares/authentication.py,sha256=acMYZES6OPan6U15s8Nr5C1DC43U2Yz0MY-cla1Zkk4,3072
+maleo_foundation/middlewares/base.py,sha256=3OaB5F57F3epKNieoAgarYM6PimoUdUl3DgpadtVuqs,11743
 maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG9iLY7Uc,2288
 maleo_foundation/models/__init__.py,sha256=AaKehO7c1HyKhoTGRmNHDddSeBXkW-_YNrpOGBu8Ms8,246
 maleo_foundation/models/responses.py,sha256=Ka9Peb1fVuQKaxyy11FVkUPtGtzyEm_9Xfe8Vla3ml0,4764
@@ -73,13 +76,14 @@ maleo_foundation/services/token.py,sha256=ZqRqOdGUnaSIam6-JHVdAW1UST-2EDtcVN0fpb
 maleo_foundation/utils/__init__.py,sha256=FavmL5XYGCm955EAKiWWcXYeU15p5rSzfcglpV2yI6c,387
 maleo_foundation/utils/controller.py,sha256=ECzPzpw36zBAjKcWcDbUAhIJGbc6UpeypdUUX6ipXBg,6396
 maleo_foundation/utils/exceptions.py,sha256=nk3rD57fDR-D7BQkU1JEKV-Mu7FGMpLSEsqxdDZdKjU,4532
+maleo_foundation/utils/extractor.py,sha256=BOYkEiEJZTixScd_mEiLt2svKZ4gXBgD2WDlU6giI3w,718
 maleo_foundation/utils/keyloader.py,sha256=g7LYypj7UolmSgHRGXMFgVaWr55UayMdtKXR5NmB7VM,2341
 maleo_foundation/utils/logger.py,sha256=uTvzzKnGjbxRVLHbiMDw2zKKWNaCwV35sxgjDStEwNQ,3569
-maleo_foundation/utils/logging.py,sha256=DuAaKQ1X7lB0y6udR-GF95BRKeluh0JoYN0K_jcNlZ0,7313
+maleo_foundation/utils/logging.py,sha256=MwvZmZSA8SIdfq-knEvpYIgqnSpHcyHrZY9TVHWVHJA,9023
 maleo_foundation/utils/query.py,sha256=ODQ3adOYQNj5E2cRW9ytbjBz56nEDcnfq8mQ6YZbCCM,4375
 maleo_foundation/utils/formatter/__init__.py,sha256=iKf5YCbEdg1qKnFHyKqqcQbqAqEeRUf8mhI3v3dQoj8,78
 maleo_foundation/utils/formatter/case.py,sha256=TmvvlfzGdC_omMTB5vAa40TZBxQ3hnr-SYeo0M52Rlg,1352
-maleo_foundation-0.1.18.dist-info/METADATA,sha256=hJ1VIOIKgdXHglxFOwiwS7lbQSuFtOfbwQxnJNjEusM,3190
-maleo_foundation-0.1.18.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-maleo_foundation-0.1.18.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.1.18.dist-info/RECORD,,
+maleo_foundation-0.1.20.dist-info/METADATA,sha256=mdOFrN9SO_ckBh80_c1scxXWrxxv6_d7YCT05VUY0QQ,3190
+maleo_foundation-0.1.20.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+maleo_foundation-0.1.20.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.1.20.dist-info/RECORD,,