Encryptors 2.58__tar.gz → 2.60__tar.gz

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

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

{encryptors-2.58 → encryptors-2.60}/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.60",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

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

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

{encryptors-2.58 → encryptors-2.60}/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,22 +33,13 @@ 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/AuditQueue.py
 src/Osdental/Helpers/AzureClassifier.py
 src/Osdental/Helpers/GrpcConnection.py
 src/Osdental/Helpers/JwtTokenHelper.py
@@ -56,7 +48,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 +55,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.60/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.60}/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.60/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.60}/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.60/src/Osdental/Helpers/AuditQueue.py

@@ -0,0 +1,45 @@
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AuditQueue:
+
+    def __init__(
+        self,
+        worker,
+        maxsize: int = 1000,
+        workers: int = 5
+    ):
+        self._worker = worker
+        self._queue = asyncio.Queue(maxsize=maxsize)
+        self._workers = workers
+        self._tasks: list[asyncio.Task] = []
+
+    async def emit(self, payload):
+        await self._queue.put(payload)
+
+    def start(self):
+        for _ in range(self._workers):
+            task = asyncio.create_task(self._consume())
+            self._tasks.append(task)
+
+    async def _consume(self):
+        while True:
+            payload = await self._queue.get()
+
+            try:
+                await self._worker(payload)
+
+            except Exception:
+                logger.exception("Error processing audit")
+
+            finally:
+                self._queue.task_done()
+
+    async def stop(self):
+        await self._queue.join()
+
+        for task in self._tasks:
+            task.cancel()

{encryptors-2.58 → encryptors-2.60}/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_emit: Optional[IAuditEmitter] = None,
         timeout: Optional[httpx.Timeout] = None,
         limits: Optional[httpx.Limits] = None
     ):
+        self._audit_emit = audit_emit
+
         self._client = httpx.AsyncClient(
             follow_redirects=True,
             timeout=timeout or httpx.Timeout(10.0, read=20.0),
@@ -34,6 +41,9 @@ class APIClient:
     @rest_retry
     async def _request(self, method: HTTPMethod, url: str, **kwargs) -> httpx.Response:
 
+        audit_ctx = _ctx.get()            
+        audit_ctx.headers = kwargs.get("headers") or {}
+
         try:
 
             response = await self._client.request(
@@ -44,22 +54,31 @@ class APIClient:
 
             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 +86,7 @@ class APIClient:
         
         except Exception as exc:
 
-            audit_unknown_error(exc, method, url, kwargs)
+            _build_unexpected_http_payload(audit_ctx, exc)
 
             raise
     
@@ -105,6 +124,9 @@ class APIClient:
         headers: Optional[Dict[str, str]] = None
     ) -> Dict[str, Any]:
 
+        audit_ctx = _ctx.get()           
+        audit_ctx.headers = headers or {}
+
         payload = {
             "query": query,
             "variables": variables
@@ -119,13 +141,16 @@ class APIClient:
 
         data = response.json()
 
-        if "errors" in data:
+        _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 → encryptors-2.60}/src/Osdental/Services/ServiceBusAuditEmitter.py

@@ -8,10 +8,14 @@ class ServiceBusAuditEmitter:
     def __init__(self, messaging: IMessageQueue, storage: IStorageService):
         self._messaging = messaging
         self._storage = storage
+        
 
-    async def emit(self, payload: Dict[str, Any]) -> None:
+    async def process(self, payload: Dict[str, Any]) -> None:
         message_log_id = payload.get("idMessageLog")
         data = json.dumps(payload)
         blob_name = f"audits/{message_log_id}.text"
-        await self._storage.upload(blob_name, data)
+        url = await self._storage.upload(blob_name, data)
+        if not url:
+            return
+        
         await self._messaging.send_message(blob_name)

{encryptors-2.58 → encryptors-2.60}/src/Osdental/Services/__init__.py

@@ -49,5 +49,5 @@ class IAuthTokenService(ABC):
 
 
 class IAuditEmitter(Protocol):
-    async def emit(self, payload: Dict[str, Any]) -> None:
+    async def process(self, payload: Dict[str, Any]) -> None:
         ...

{encryptors-2.58 → encryptors-2.60}/src/Osdental/Storage/__init__.py

@@ -6,13 +6,13 @@ from azure.storage.blob import BlobSasPermissions
 class IStorageService(ABC): 
 
     @abstractmethod
-    async def upload(self, blob_name: str, data: bytes | str) -> str | bool:
+    async def upload(self, blob_name: str, data: bytes | str) -> str:
         """ Upload a file to blob storage """
         pass
 
 
     @abstractmethod
-    async def download(self, blob_name: str) -> bytes | None:
+    async def download(self, blob_name: str) -> bytes:
         """ Download a file from blob storage """
         pass
     

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)