Encryptors 2.58__tar.gz → 2.59__tar.gz

{encryptors-2.58 → encryptors-2.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.58
+Version: 2.59
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

{encryptors-2.58 → encryptors-2.59}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 # ANDERSON REVISAR EL CACHE LOCAL DEL KEYVAULT PARA VALIDAR SI FUNCIONA
 setup(
     name="Encryptors", 
-    version="2.58",
+    version="2.59",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.58 → encryptors-2.59}/src/Encryptors.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.58
+Version: 2.59
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

{encryptors-2.58 → encryptors-2.59}/src/Encryptors.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/Osdental/Cli/__init__.py
 src/Osdental/Constants/Constant.py
 src/Osdental/Constants/Message.py
 src/Osdental/Constants/__init__.py
+src/Osdental/Context/__init__.py
 src/Osdental/Database/BaseRepository.py
 src/Osdental/Database/Connection.py
 src/Osdental/Database/__init__.py
@@ -32,21 +33,11 @@ src/Osdental/Enums/ErrorSource.py
 src/Osdental/Enums/FileType.py
 src/Osdental/Enums/GrahpqlOperation.py
 src/Osdental/Enums/Profile.py
+src/Osdental/Enums/ResultType.py
 src/Osdental/Enums/StatusCode.py
 src/Osdental/Enums/__init__.py
 src/Osdental/Exception/ControlledException.py
 src/Osdental/Exception/__init__.py
-src/Osdental/Graphql/__init__.py
-src/Osdental/Graphql/Extensions/AuditExtension.py
-src/Osdental/Graphql/Extensions/__init__.py
-src/Osdental/Graphql/Models/__init__.py
-src/Osdental/Graphql/_Exceptions/__init__.py
-src/Osdental/Graphql/_Helpers/_AuditHelper.py
-src/Osdental/Graphql/_Helpers/_ExtractAuthToken.py
-src/Osdental/Graphql/_Helpers/_TenantPolicy.py
-src/Osdental/Graphql/_Helpers/_TokenService.py
-src/Osdental/Graphql/_Helpers/__init__.py
-src/Osdental/Helpers/AuditDispatcher.py
 src/Osdental/Helpers/AuditHelper.py
 src/Osdental/Helpers/AzureClassifier.py
 src/Osdental/Helpers/GrpcConnection.py
@@ -56,7 +47,6 @@ src/Osdental/Helpers/ResponseDecryptor.py
 src/Osdental/Helpers/_AuthTokenProcessor.py
 src/Osdental/Helpers/__init__.py
 src/Osdental/Http/APIClient.py
-src/Osdental/Http/_Helpers.py
 src/Osdental/Http/__init__.py
 src/Osdental/Messaging/AzureServiceBus.py
 src/Osdental/Messaging/Kafka.py
@@ -64,16 +54,12 @@ src/Osdental/Messaging/RabbitMQ.py
 src/Osdental/Messaging/__init__.py
 src/Osdental/Models/ApiResponse.py
 src/Osdental/Models/AuditContext.py
+src/Osdental/Models/Graphql.py
 src/Osdental/Models/Notification.py
 src/Osdental/Models/Response.py
 src/Osdental/Models/Token.py
 src/Osdental/Models/TokenClaims.py
 src/Osdental/Models/__init__.py
-src/Osdental/Rest/__init__.py
-src/Osdental/Rest/Context/RequestContext.py
-src/Osdental/Rest/Context/__init__.py
-src/Osdental/Rest/Middlewares/RequestContextMiddleware.py
-src/Osdental/Rest/Middlewares/__init__.py
 src/Osdental/Secrets/AzureKeyVaultProvider.py
 src/Osdental/Secrets/__init__.py
 src/Osdental/Services/JwtAuthTokenService.py

encryptors-2.59/src/Osdental/Context/__init__.py

@@ -0,0 +1,5 @@
+from contextvars import ContextVar
+from typing import Optional
+from Osdental.Models.AuditContext import AuditContext
+
+_ctx: ContextVar[Optional[AuditContext]] = ContextVar('ctx', default=None)

{encryptors-2.58 → encryptors-2.59}/src/Osdental/Decorators/SecureResolver.py

@@ -3,7 +3,7 @@ from functools import wraps
 from typing import Callable
 from graphql import GraphQLResolveInfo
 from Osdental.Models.Response import Response
-from Osdental.Graphql.Models import BaseGraphQLContext
+from Osdental.Models.Graphql import BaseGraphQLContext
 from Osdental.Models.TokenClaims import UserTokenClaims
 from Osdental.Models.Token import AuthToken
 from Osdental.Enums.Profile import Profile
@@ -19,12 +19,11 @@ from Osdental.Models.AuditContext import AuditContext
 from Osdental.Helpers.AuditHelper import (
     _build_success_payload, _build_error_payload, _build_unexpected_payload
 )
-
+from Osdental.Context import _ctx
 
 logger = logging.getLogger(__name__)
 
 
-
 def resolver(public: bool = False, action=None):
 
     def decorator(func: Callable):
@@ -95,6 +94,8 @@ def resolver(public: bool = False, action=None):
                     decrypted_payload=decrypted_payload,
                 )
 
+                _ctx.set(audit_ctx)
+
                 # ── 6. EJECUTAR RESOLVER ──────────────────
                 result = await func(obj, info, **kwargs)
 

encryptors-2.59/src/Osdental/Enums/ResultType.py

@@ -0,0 +1,5 @@
+from enum import StrEnum
+
+class ResultType(StrEnum):
+    RESPONSE = "Response"
+    ERROR = "Error"

{encryptors-2.58 → encryptors-2.59}/src/Osdental/Helpers/AuditHelper.py

@@ -1,11 +1,14 @@
 import json
+from typing import Optional, List, Dict, Any
 from fastapi import Request
-from typing import Optional, Dict, Any, Literal
+from httpx import HTTPStatusError, RequestError
 from Osdental.Models.AuditContext import AuditContext
 from Osdental.Models.Response import Response
+from Osdental.Models.ApiResponse import ApiResponse
 from Osdental.Exception.ControlledException import OSDException
 from Osdental.Enums.StatusCode import StatusCode
 from Osdental.Enums.AuditType import AuditType
+from Osdental.Enums.ResultType import ResultType
 
 def build_request_payload(
     request: Request, 
@@ -53,8 +56,8 @@ def build_request_payload(
     }
 
 def _build_final_payload(
-    type_: Literal["RESPONSE", "ERROR"],
-    status_code: int,
+    status_code: int | str,
+    type_: ResultType = ResultType.ERROR,
     result: Optional[Any] = None,
     error: Optional[Any] = None
 ) -> Dict[str, Any]:
@@ -73,25 +76,23 @@ def _build_final_payload(
     }
 
 def _build_success_payload(ctx: Optional[AuditContext], result: Response) -> Dict[str, Any]:
-    base = _base_payload(ctx, AuditType.INTERNAL)
+    base = _base_payload(ctx)
     return base | _build_final_payload(
-        type_="RESPONSE",
+        type_=ResultType.RESPONSE,
         status_code=result.status,
         result=result.data
     )
 
 def _build_error_payload(ctx: Optional[AuditContext], exc: OSDException) -> Dict[str, Any]:
-    base = _base_payload(ctx, AuditType.INTERNAL)
+    base = _base_payload(ctx)
     return base | _build_final_payload(
-        type_="ERROR",
         status_code=exc.audit_status_code,
         error=exc.error or exc.message
     )
 
 def _build_unexpected_payload(ctx: Optional[AuditContext], exc: Exception) -> Dict[str, Any]:
-    base = _base_payload(ctx, AuditType.INTERNAL)
+    base = _base_payload(ctx)
     return base | _build_final_payload(
-        type_="ERROR",
         status_code=StatusCode.INTERNAL_SERVER_ERROR,
         error=str(exc)
     )
@@ -115,4 +116,51 @@ def _base_payload(ctx: Optional[AuditContext], audit_type: AuditType = AuditType
         "httpMethod": ctx.http_method,
         "messageIn": json.dumps(ctx.variables) if ctx.variables else "*",
         "auditLog": audit_type,
-    }
+    }
+
+
+# ------------ FOR EXTERNAL APIS --------------------
+def _build_success_http_payload(ctx: Optional[AuditContext], result: ApiResponse) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.EXTERNAL)
+    return base | _build_final_payload(
+        type_=ResultType.RESPONSE,
+        status_code=result.status,
+        result=result.data
+    )
+
+def _build_error_http_payload(ctx: Optional[AuditContext], exc: HTTPStatusError) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.EXTERNAL)
+    return base | _build_final_payload(
+        status_code=exc.response.status_code,
+        error=exc.response.text
+    )
+
+def _build_error_http_request_payload(ctx: Optional[AuditContext], exc: RequestError) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.EXTERNAL)
+    return base | _build_final_payload(
+        status_code=503,
+        error=str(exc)
+    )
+
+def _build_unexpected_http_payload(ctx: Optional[AuditContext], exc: Exception) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.EXTERNAL)
+    return base | _build_final_payload(
+        status_code=StatusCode.INTERNAL_SERVER_ERROR,
+        error=str(exc)
+    )
+
+def _build_success_graphql_payload(ctx: Optional[AuditContext], result: Dict[str, Any]) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.EXTERNAL)
+    return base | _build_final_payload(
+        type_=ResultType.RESPONSE,
+        status_code=200,
+        result=result
+    )
+
+
+def _build_error_graphql_payload(ctx: Optional[AuditContext], errors: List[Dict[str, Any]]) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.EXTERNAL)
+    return base | _build_final_payload(
+        status_code=StatusCode.INTERNAL_SERVER_ERROR,
+        error=json.dumps(errors)
+    )

{encryptors-2.58 → encryptors-2.59}/src/Osdental/Http/APIClient.py

@@ -3,12 +3,16 @@ from typing import Optional, Dict, Any
 import httpx
 from http import HTTPMethod
 from Osdental.Decorators.Retry import rest_retry
-from Osdental.Http._Helpers import (
-    audit_success, audit_http_error, audit_exception_error,
-    audit_unknown_error, audit_graphql_error
-)
+from Osdental.Models.ApiResponse import ApiResponse
+from Osdental.Services import IAuditEmitter
 from Osdental.Exception.ControlledException import HttpClientException
 from Osdental.Enums.StatusCode import StatusCode
+from Osdental.Context import _ctx
+from Osdental.Helpers.AuditHelper import (
+    _build_success_http_payload, _build_error_http_payload,
+    _build_error_http_request_payload, _build_unexpected_http_payload,
+    _build_success_graphql_payload, _build_error_graphql_payload
+)
 
 logger = logging.getLogger(__name__)
 
@@ -16,9 +20,12 @@ class APIClient:
 
     def __init__(
         self,
+        audit: Optional[IAuditEmitter] = None,
         timeout: Optional[httpx.Timeout] = None,
         limits: Optional[httpx.Limits] = None
     ):
+        self._audit = audit
+
         self._client = httpx.AsyncClient(
             follow_redirects=True,
             timeout=timeout or httpx.Timeout(10.0, read=20.0),
@@ -42,24 +49,37 @@ class APIClient:
                 **kwargs
             )
 
+            audit_ctx = _ctx.get()
+            
+            audit_ctx.headers = kwargs["headers"] or {}
+
             response.raise_for_status()
 
-            audit_success(response, method, url, kwargs)
+            api_res = ApiResponse(
+                status=response.status_code,
+                data=response.text
+            )
+
+            await self._audit_emit.emit(
+                _build_success_http_payload(audit_ctx, api_res)
+            )
 
             return response
 
         except httpx.HTTPStatusError as exc:
             
-            audit_http_error(exc.response, method, url, kwargs)
+            await self._audit_emit.emit(
+                _build_error_http_payload(audit_ctx, exc)
+            )
+
             raise HttpClientException(
                 status_code=StatusCode.BAD_GATEWAY,
                 error=exc.response.text,
-                raw_status_code=exc.response.status_code,
             ) from exc
         
         except httpx.RequestError as exc:
 
-            audit_exception_error(exc, method, url, kwargs)
+            _build_error_http_request_payload(audit_ctx, exc)
             raise HttpClientException(
                 status_code=StatusCode.GATEWAY_TIMEOUT,
                 error=str(exc),
@@ -67,7 +87,7 @@ class APIClient:
         
         except Exception as exc:
 
-            audit_unknown_error(exc, method, url, kwargs)
+            _build_unexpected_http_payload(audit_ctx, exc)
 
             raise
     
@@ -119,13 +139,20 @@ class APIClient:
 
         data = response.json()
 
-        if "errors" in data:
+        audit_ctx = _ctx.get()
+            
+        audit_ctx.headers = headers or {}
 
+        _build_success_graphql_payload(audit_ctx, data)
+
+        if "errors" in data:
+            
+            errors = data['errors']
             logger.error(
-                f"GraphQL error: {data['errors']}"
+                f"GraphQL error: {errors}"
             )
 
-            audit_graphql_error(data["errors"], url, payload)
+            _build_error_graphql_payload(audit_ctx, errors)
             raise HttpClientException(
                 message="GraphQL execution failed",
                 error=str(data["errors"])

encryptors-2.58/src/Osdental/Graphql/Extensions/AuditExtension.py

@@ -1,196 +0,0 @@
-import inspect
-import logging
-import json
-from graphql.pyutils import is_awaitable
-from ariadne.types import Extension
-from Osdental.Encryptor.Aes import AES
-from Osdental.Graphql._Helpers._TenantPolicy import TenantPolicy
-from Osdental.Rest.Context.RequestContext import (
-    current_context,
-    RequestContext
-)
-from Osdental.Models.Response import Response
-from Osdental.Graphql.Models import BaseGraphQLContext
-from Osdental.Constants.Constant import Constant
-
-logger = logging.getLogger(__name__)
-
-class AuditExtension(Extension):
-
-    def request_started(self, context):
-        request = context.request
-        self._ctx_token = current_context.set(
-            RequestContext(
-                request=request,
-                request_id=request.headers.get("x-request-id"),
-                user=None
-            )
-        )
-
-        self.errors = None
-        self.request_payload = None
-        self.result = None
-
-    def _should_skip(self, body) -> bool:
-        query = body.get("query", "") or ""
-        return "__schema" in query or "__type(" in query
-
-    async def resolve(self, next_, root, info, **kwargs):
-
-        context: BaseGraphQLContext = info.context
-        request = context.request
-
-        # cache body
-        context._cached_body = (
-            getattr(context, "_cached_body", None) or await request.json()
-        )
-        body = context._cached_body
-
-        # skip introspection
-        if self._should_skip(body):
-            result = next_(root, info, **kwargs)
-            if is_awaitable(result):
-                result = await result
-            return result
-
-        is_root = root is None
-
-        # SOLO ROOT
-        if is_root:
-
-            # identificar resolver público
-            resolver_fn = inspect.unwrap(next_)
-            is_public = getattr(resolver_fn, "_is_public", False)
-
-            # inicializar auth UNA SOLA VEZ
-            if not hasattr(context, "_auth_initialized"):
-                context._auth_initialized = True
-
-                headers = request.headers
-                container = context.container
-                
-                original_token = None
-                context.aes_auth = None
-                if not is_public and headers.get("authorization"):
-                    token_service = container.token_service
-                    aes_auth = request.app.state.aes_auth
-                    aes_user = request.app.state.aes_user
-
-                    try:
-                        original_token = await token_service.authenticate(headers, aes_user)
-                    except Exception:
-                        original_token = None
-
-                    context.aes_auth = aes_auth
-
-            # VALIDACIÓN SOLO ROOT
-            if not is_public and not original_token:
-                raise ValueError("Authorization required")
-
-            # payload
-            variables = body.get("variables") or {}
-
-            encrypted_payload = (
-                kwargs.get("data")
-                or variables.get("data")
-            )
-
-            decrypted_payload = None
-
-            if not is_public and encrypted_payload is not None:
-
-                if not isinstance(encrypted_payload, str):
-                    raise ValueError("Encrypted payload must be a string")
-
-                if not context.aes_auth:
-                    raise ValueError("Missing AES configuration")
-
-                try:
-                    decrypted = AES.decrypt(context.aes_auth, encrypted_payload)
-                except Exception:
-                    raise ValueError("Invalid encrypted payload")
-
-                if isinstance(decrypted, dict):
-                    decrypted_payload = decrypted
-
-                elif isinstance(decrypted, str):
-                    try:
-                        decrypted_payload = json.loads(decrypted)
-                    except Exception:
-                        raise ValueError("Decrypted payload is not valid JSON")
-
-                else:
-                    raise ValueError("Unsupported decrypted payload type")
-                        
-            if decrypted_payload is not None:
-                kwargs["data"] = decrypted_payload
-            
-            if not is_public:
-                token = TenantPolicy.resolve(
-                    token=original_token,
-                    headers=request.headers,
-                    decrypted_payload=decrypted_payload,
-                    operation_type=info.operation.operation.value
-                )
-                context.token = token
-
-            # auditoría request payload
-            if not self.request_payload:
-                token = context.token
-
-                self.request = request
-                self.request_payload = {
-                    "operation_type": info.operation.operation.value,
-                    "operation_name": body.get("operationName", "UnknownOperation"),
-                    "query": body.get("query"),
-                    "variables": decrypted_payload,
-                    "user": token.user_full_name if token else "Public"
-                }
-
-        # SIEMPRE ejecutar resolver (root + fields)
-        result = next_(root, info, **kwargs)
-
-        if is_awaitable(result):
-            result = await result
-
-        # SOLO ROOT captura resultado final
-        if is_root and self.result is None:
-            self.result = result
-
-        return result
-
-    def has_errors(self, errors, context):
-        self.errors = errors
-
-    def request_finished(self, context):
-
-        if not self.request_payload:
-            return
-
-        query = self.request_payload.get("query", "")
-
-        if self._should_skip({"query": query}):
-            return
-        
-        if self.result is None:
-            return
-
-        decrypted_key = context.aes_auth
-
-        if isinstance(self.result, Response):
-            decrypted_key = self.result.key or decrypted_key
-
-        dispatcher = context.request.app.state.audit_dispatcher
-
-        try:
-            dispatcher.dispatch(
-                request=self.request,
-                request_payload=self.request_payload,
-                result=self.result,
-                metadata={
-                    "decrypted_key": decrypted_key
-                },
-                audit_type=Constant.MESSAGE_LOG_INTERNAL
-            )
-        except Exception as e:
-            logger.warning(f"[AUDIT ERROR]: {str(e)}")

encryptors-2.58/src/Osdental/Graphql/_Exceptions/__init__.py

@@ -1,8 +0,0 @@
-from Osdental.Exception.ControlledException import OSDException
-
-class AESKeyNotFound(OSDException):
-    def __init__(
-        self, 
-        error: str = None
-    ):
-        super().__init__(error=error)

encryptors-2.58/src/Osdental/Graphql/_Helpers/_AuditHelper.py

@@ -1,67 +0,0 @@
-import json
-from typing import Dict, Literal, Any, Optional
-
-class AuditHelper:
-        
-    @staticmethod
-    def build_request_payload(
-        request, 
-        payload: Dict[str, Any], 
-        audit_type: str
-    ) -> Dict[str, Any]:
-
-        default_value = "*"
-
-        user_ip = request.headers.get("X-Forwarded-For")
-        if user_ip:
-            user_ip = user_ip.split(",")[0]
-        else:
-            user_ip = getattr(request.client, "host", "*")
-
-        SAFE_HEADERS = {
-            "user-agent",
-            "host",
-            "origin",
-            "referer",
-            "content-type"
-        }
-
-        headers = {k: v for k, v in request.headers.items() if k.lower() in SAFE_HEADERS}
-
-        return {
-            "idMessageLog": request.headers.get("Idmessagelog"),
-            "environment": payload.get("env"),
-            "header": json.dumps(headers),
-            "microServiceUrl": str(request.url),
-            "microServiceName": payload.get("ms_name"),
-            "microServiceVersion": payload.get("ms_version"),
-            "serviceName": payload.get("operation_name"),
-            "machineNameUser": request.headers.get("Machinenameuser", default_value),
-            "ipUser": user_ip or default_value,
-            "userName": payload.get("user"),
-            "localitation": default_value,
-            "httpMethod": request.method,
-            "messageIn": json.dumps(payload) if payload else default_value,
-            "auditLog": audit_type,
-        }
-    
-    @staticmethod
-    def build_final_payload(
-        _type: Literal["RESPONSE", "ERROR"],
-        status_code: int,
-        result: Optional[Any] = None,
-        error: Optional[Any] = None
-    ) -> Dict[str, Any]:
-
-        result = "*" if result is None else result
-        error = "*" if error is None else error
-
-        if isinstance(result, (dict, list)):
-            result = json.dumps(result)
-
-        return {
-            "type": _type,
-            "httpResponseCode": status_code,
-            "messageOut": result,
-            "errorProducer": error
-        }

encryptors-2.58/src/Osdental/Graphql/_Helpers/_ExtractAuthToken.py

@@ -1,11 +0,0 @@
-from starlette.datastructures import Headers
-
-class ExtractAuthToken:
-
-    @staticmethod
-    def get_auth_token(headers: Headers) -> str:
-        authorization = headers.get("authorization")
-        if not authorization or not authorization.startswith("Bearer "):
-            raise ValueError("Missing Bearer token")
-        
-        return authorization.split(" ")[1]

encryptors-2.58/src/Osdental/Graphql/_Helpers/_TenantPolicy.py

@@ -1,46 +0,0 @@
-from typing import Dict, Any
-from uuid import UUID
-from graphql import OperationType
-from starlette.datastructures import Headers
-from Osdental.Encryptor.Aes import AES
-from Osdental.Models.Token import AuthToken
-from Osdental.Enums.Profile import Profile
-
-class TenantPolicy:
-
-    @staticmethod
-    def resolve(
-        token: AuthToken, 
-        headers: Headers, 
-        decrypted_payload: Dict[str, Any], 
-        operation_type: str
-    ) -> AuthToken:
-
-        final_id = None
-        dynamic_client_id = headers.get("dynamicClientId", None)
-        external_enterprise_req = (
-            decrypted_payload.get("idExternalEnterprise")
-            if decrypted_payload else None
-        )
-
-        if external_enterprise_req:
-            final_id = external_enterprise_req
-
-
-        elif token.abbreviation.startswith(
-            (Profile.MARKETING, Profile.SUPER_ADMIN, Profile.ADMIN_OSD)
-        ) and dynamic_client_id:
-            decrypted_mk_id = AES.decrypt(token.aes_key_auth, dynamic_client_id)
-            final_id = decrypted_mk_id
-            token.mk_id_external_enterprise = decrypted_mk_id
-
-        elif (
-            token.abbreviation.startswith((Profile.SUPER_ADMIN, Profile.ADMIN_OSD)) 
-            and operation_type == OperationType.QUERY.value and not dynamic_client_id
-        ):
-            final_id = str(UUID(int=0))
-
-        if final_id:
-            token.id_external_enterprise = final_id
-
-        return token