Encryptors 2.81.0__tar.gz → 2.81.2__tar.gz

{encryptors-2.81.0 → encryptors-2.81.2}/PKG-INFO

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

{encryptors-2.81.0 → encryptors-2.81.2}/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.81.0",
+    version="2.81.2",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.81.0 → encryptors-2.81.2}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.81.0 → encryptors-2.81.2}/src/Encryptors.egg-info/SOURCES.txt

@@ -20,7 +20,6 @@ src/Osdental/Decorators/Grpc.py
 src/Osdental/Decorators/PublicResolver.py
 src/Osdental/Decorators/Retry.py
 src/Osdental/Decorators/SecureResolver.py
-src/Osdental/Decorators/SqlDataNormalizer.py
 src/Osdental/Decorators/__init__.py
 src/Osdental/Encryptor/Aes.py
 src/Osdental/Encryptor/Argon2.py
@@ -31,44 +30,30 @@ src/Osdental/Encryptor/Sha512.py
 src/Osdental/Encryptor/__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/AzureClassifier.py
 src/Osdental/Helpers/GrpcConnection.py
-src/Osdental/Helpers/KeyVaultService.py
 src/Osdental/Helpers/Resilience.py
 src/Osdental/Helpers/ResponseDecryptor.py
-src/Osdental/Helpers/WebsocketClient.py
-src/Osdental/Helpers/_Ports.py
 src/Osdental/Helpers/__init__.py
-src/Osdental/Http/APIClient.py
-src/Osdental/Http/_Helpers.py
+src/Osdental/Helpers/extract_auth_token.py
+src/Osdental/Helpers/tenant_policy.py
+src/Osdental/Helpers/token_validation_service.py
+src/Osdental/Http/Constants.py
+src/Osdental/Http/Exceptions.py
+src/Osdental/Http/HttpxClient.py
+src/Osdental/Http/Messages.py
+src/Osdental/Http/Types.py
 src/Osdental/Http/__init__.py
 src/Osdental/Messaging/AzureServiceBus.py
 src/Osdental/Messaging/Kafka.py
 src/Osdental/Messaging/RabbitMQ.py
 src/Osdental/Messaging/__init__.py
-src/Osdental/Models/ApiResponse.py
-src/Osdental/Models/AuditConfig.py
-src/Osdental/Models/Notification.py
 src/Osdental/Models/Response.py
 src/Osdental/Models/Token.py
-src/Osdental/Models/_Audit.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/Models/base_graphql_context.py
+src/Osdental/Secrets/KeyVaultService.py
+src/Osdental/Secrets/__init__.py
 src/Osdental/Shared/Logger.py
 src/Osdental/Shared/__init__.py
 src/Osdental/Shared/Enums/Code.py

encryptors-2.81.2/src/Osdental/Decorators/SecureResolver.py

@@ -0,0 +1,119 @@
+import json
+from functools import wraps
+from typing import Callable
+from Osdental.Models.Response import Response
+from Osdental.Shared.Enums.Profile import Profile
+from Osdental.Exception.ControlledException import (
+    OSDException, AccessDeniedException, UnauthorizedException
+)
+from Osdental.Encryptor.Aes import AES
+from Osdental.Models.base_graphql_context import BaseGraphQLContext
+from Osdental.Helpers.tenant_policy import TenantPolicy
+from Osdental.Secrets import ISecretProvider
+from Osdental.Shared.Logger import logger
+
+def resolver(action=None):
+
+    def decorator(func: Callable):
+
+        @wraps(func)
+        async def wrapper(obj, info, **kwargs):
+            try:
+                context: BaseGraphQLContext = info.context
+                request = context.request
+                token_service = context.container.token_service
+
+                if action:
+                    if Profile(token.abbreviation) not in action.allowed_roles:
+                        raise AccessDeniedException(
+                            error="User not allowed to perform this action"
+                        )
+                    
+                # Get secrets
+                secret_service: ISecretProvider = context.container.secret_service
+                keys = await secret_service.get_many(
+                    ["AES-KEY-AUTH", "AES-KEY-USER", "AUTH-JWT-USER-KEY"]
+                )
+                #
+
+                encrypted_payload = kwargs.get("data")
+    
+                decrypted_payload = None
+
+                if 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
+
+                # token
+                try:
+                    original_token = await token_service.authenticate(
+                        request.headers,
+                        keys["AUTH-JWT-USER-KEY"],
+                        keys["AES-KEY-USER"],
+                    )
+                except Exception:
+                    original_token = None
+
+                token = TenantPolicy.resolve(
+                    token=original_token,
+                    headers=request.headers,
+                    decrypted_payload=decrypted_payload,
+                    operation_type=info.operation.operation.value
+                )
+
+                if not token:
+                    raise UnauthorizedException(
+                        error="Authorization required"
+                    )
+                # token
+
+                result = await func(obj, info, **kwargs)
+
+                if not isinstance(result, Response):
+                    raise TypeError("Resolver must return a Response instance")
+
+                return result
+
+            except OSDException as e:
+                logger.warning(f"Business error: {str(e)}")
+
+                return Response(
+                    status=e.status_code,
+                    message=e.message,
+                )
+
+            except Exception as e:
+                logger.exception(f"Unexpected error: {str(e)}")
+
+                return Response(
+                    status="DB_ERROR_UNEXPECTED",
+                    message="Could not process request.",
+                )
+
+        return wrapper
+
+    return decorator

{encryptors-2.81.0 → encryptors-2.81.2}/src/Osdental/Exception/ControlledException.py

@@ -8,7 +8,7 @@ class OSDException(Exception):
         self, 
         message: str = Message.UNEXPECTED_ERROR_MSG, 
         error: str = None, 
-        status_code: Any = Code.APP_ERROR_CODE
+        status_code: Any = Code.APP_ERROR_CODE,
     ):
         super().__init__(error)
         self.message = message
@@ -19,7 +19,9 @@ class OSDException(Exception):
     def __str__(self):
         error_detail = self.error if self.error else "None"
         return f"[{self.status_code}] {self.message} | {error_detail}"
-    
+
+
+
 class UnauthorizedException(OSDException):
     def __init__(
         self, 
@@ -155,11 +157,3 @@ class InvalidFormatException(OSDException):
     ):
         super().__init__(message=message, error=error, status_code=status_code)
 
-class HttpClientException(OSDException):
-    def __init__(
-        self, 
-        message: str = Message.UNEXPECTED_ERROR_MSG, 
-        error: str = None, 
-        status_code: str = Code.HTTP_ERROR_CODE
-    ):
-        super().__init__(message=message, error=error, status_code=status_code)

encryptors-2.81.0/src/Osdental/Graphql/_Helpers/_TokenService.py → encryptors-2.81.2/src/Osdental/Helpers/token_validation_service.py

@@ -2,19 +2,24 @@ from starlette.datastructures import Headers
 from Osdental.Encryptor.Aes import AES
 from Osdental.Encryptor.Jwt import JWT
 from Osdental.Models.Token import AuthToken
-from Osdental.Graphql._Helpers._ExtractAuthToken import ExtractAuthToken
+from Osdental.Helpers.extract_auth_token import ExtractAuthToken
 
-class TokenService:
+class TokenValidationService:
 
-    def __init__(self, jwt_user_key: str, auth_validator):
-        self.jwt_user_key = jwt_user_key
+    def __init__(self, auth_validator):
         self.auth_validator = auth_validator
 
-    async def authenticate(self, headers: Headers, aes_user: str) -> AuthToken:
+    async def authenticate(
+        self,
+        headers: Headers,
+        jwt_user_key: str,
+        aes_user: str
+    ) -> AuthToken:
+        
         encrypted_token = ExtractAuthToken.get_auth_token(headers)
 
         user_token = AES.decrypt(aes_user, encrypted_token)
-        payload = JWT.extract_payload(user_token, self.jwt_user_key)
+        payload = JWT.extract_payload(user_token, jwt_user_key)
 
         token = AuthToken(
             id_token=payload.get("idToken"),
@@ -33,11 +38,11 @@ class TokenService:
         )
 
         # Validate via RPC
-        paylod = {
+        payload = {
             "idToken": token.id_token,
             "idUser": token.id_user
         }
-        is_valid = await self.auth_validator.validate_auth_token(paylod)
+        is_valid = await self.auth_validator.validate_auth_token(payload)
         if not int(is_valid):
             raise ValueError("You are not authorized to access this portal.")
 

encryptors-2.81.2/src/Osdental/Http/Constants.py

@@ -0,0 +1,5 @@
+
+HTTP_ERROR_CODE = "DB_HTTP_ERROR"
+HTTP_TIMEOUT = 408
+MAX_CONNECTIONS = 100
+MAX_KEEPALIVE_CONNECTIONS = 20

encryptors-2.81.2/src/Osdental/Http/Exceptions.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+from Osdental.Exception.ControlledException import OSDException
+from Osdental.Http.Constants import (
+    INTERNAL_SERVER_ERROR_MSG,
+    HTTP_ERROR_CODE,
+)
+
+class HttpClientException(OSDException):
+    """For failures in calls to external APIs."""
+
+    def __init__(
+        self,
+        message: str = INTERNAL_SERVER_ERROR_MSG,
+        error: str = None,
+        status_code: Any = HTTP_ERROR_CODE,
+        http_status_code: int | None = None,
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+        self.http_status_code = http_status_code
+
+
+    def __str__(self):
+        base = super().__str__()
+        return f"{base} | http={self.http_status_code} code={self.error_code}"

encryptors-2.81.0/src/Osdental/Http/APIClient.py → encryptors-2.81.2/src/Osdental/Http/HttpxClient.py

@@ -1,34 +1,35 @@
 import httpx
-from typing import Optional, Dict, Any
+from typing import Any
+
+from Osdental.Http import APIClient
 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.Http.Exceptions import HttpClientException
+from Osdental.Http.Types import HTTPMethod
+from Osdental.Http.Constants import (
+    HTTP_TIMEOUT,
+    MAX_CONNECTIONS,
+    MAX_KEEPALIVE_CONNECTIONS,
 )
-from Osdental.Exception.ControlledException import HttpClientException
 from Osdental.Shared.Logger import logger
 
-class APIClient:
+class HttpxClient(APIClient):
 
     def __init__(
         self,
-        timeout: Optional[httpx.Timeout] = None,
-        limits: Optional[httpx.Limits] = None
+        timeout: httpx.Timeout | None = None,
+        limits: httpx.Limits | None = None
     ):
         self._client = httpx.AsyncClient(
             follow_redirects=True,
             timeout=timeout or httpx.Timeout(10.0, read=20.0),
             limits=limits or httpx.Limits(
-                max_connections=100,
-                max_keepalive_connections=20
+                max_connections=MAX_CONNECTIONS,
+                max_keepalive_connections=MAX_KEEPALIVE_CONNECTIONS,
             )
         )
 
-    async def close(self):
-        await self._client.aclose()
-
     @rest_retry
-    async def _request(self, method: str, url: str, **kwargs) -> httpx.Response:
+    async def _request(self, method: HTTPMethod, url: str, **kwargs) -> httpx.Response:
 
         try:
 
@@ -40,35 +41,30 @@ class APIClient:
 
             response.raise_for_status()
 
-            audit_success(response, method, url, kwargs)
-
             return response
-
-        except httpx.HTTPStatusError as exc:
-            
-            audit_http_error(exc.response, method, url, kwargs)
-            raise HttpClientException(
-                status_code=exc.response.status_code,
-                error=exc.response.text
-            ) from exc
         
-        except httpx.RequestError as exc:
-
-            audit_exception_error(exc, method, url, kwargs)
+        except httpx.TimeoutException as e:
             raise HttpClientException(
-                status_code=0,
-                error=str(exc)
-            ) from exc
-        
+                error=str(e),
+                http_status_code=HTTP_TIMEOUT
+            )
+        except httpx.HTTPStatusError as e:
+            raise HttpClientException(
+                error=str(e),
+                http_status_code=e.response.status_code
+            )
+        except httpx.RequestError as e:
+            raise HttpClientException(
+                error=str(e),
+            )
         except Exception as exc:
-
-            audit_unknown_error(exc, method, url, kwargs)
-
+            logger.error(f"Unexpected error in APIClient: {exc}")
             raise
     
+
     async def request(
         self,
-        method: str,
+        method: HTTPMethod,
         url: str,
         **kwargs
     ) -> Any:
@@ -96,9 +92,9 @@ class APIClient:
         self,
         url: str,
         query: str,
-        variables: Dict[str, Any],
-        headers: Optional[Dict[str, str]] = None
-    ) -> Dict[str, Any]:
+        variables: dict[str, Any],
+        headers: dict[str, str] | None = None
+    ) -> dict[str, Any]:
 
         payload = {
             "query": query,
@@ -120,10 +116,13 @@ class APIClient:
                 f"GraphQL error: {data['errors']}"
             )
 
-            audit_graphql_error(data["errors"], url, payload)
             raise HttpClientException(
                 message="GraphQL execution failed",
                 error=str(data["errors"])
             )
 
-        return data["data"]
+        return data["data"]
+    
+
+    async def close(self):
+        await self._client.aclose()

encryptors-2.81.2/src/Osdental/Http/Messages.py

@@ -0,0 +1 @@
+INTERNAL_SERVER_ERROR_MSG = "Your request could not be processed. Please try again later."

encryptors-2.81.2/src/Osdental/Http/Types.py

@@ -0,0 +1,3 @@
+from typing import Literal
+
+HTTPMethod = Literal["GET", "POST", "PUT", "DELETE"]

encryptors-2.81.2/src/Osdental/Http/__init__.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from Osdental.Http.Types import HTTPMethod
+
+class APIClient(ABC):
+
+    @abstractmethod
+    async def request(
+        self,
+        method: HTTPMethod,
+        url: str,
+        **kwargs
+    ) -> Any:
+        pass
+    
+    
+    @abstractmethod
+    async def execute(
+        self,
+        url: str,
+        query: str,
+        variables: dict[str, Any],
+        headers: dict[str, str] | None = None
+    ) -> dict[str, Any]:
+        pass
+    
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass

{encryptors-2.81.0 → encryptors-2.81.2}/src/Osdental/Messaging/AzureServiceBus.py

@@ -28,6 +28,12 @@ class SenderContext:
 
 class AzureServiceBus(IMessageBus):
 
+    """Azure Service Bus implementation of IMessageBus.
+
+    This implementation maintains one sender per queue and
+    automatically recreates senders when transient failures occur.
+    """
+
     def __init__(
         self,
         namespace: str,

encryptors-2.81.0/src/Osdental/Messaging/__init__.py → encryptors-2.81.2/src/Osdental/Messaging/Kafka.py

@@ -1,16 +1,15 @@
-from abc import ABC, abstractmethod
 from typing import Any
+from Osdental.Messaging import IMessageBus
 
-class IMessageBus(ABC):
+class KafkaQueue(IMessageBus):
 
-    @abstractmethod
     async def publish(
         self,
         queue: str,
         message: dict[str, Any] | str,
     ) -> None:
-        pass
-
-    @abstractmethod
+        print(f'[Kafka] Queuing message: {message}')
+    
+    
     async def close(self) -> None:
-        pass
+        print("Closing...")

encryptors-2.81.2/src/Osdental/Messaging/RabbitMQ.py

@@ -0,0 +1,15 @@
+from typing import Any
+from Osdental.Messaging import IMessageBus
+
+class RabbitMqQueue(IMessageBus):
+
+    async def publish(
+        self,
+        queue: str,
+        message: dict[str, Any] | str,
+    ) -> None:
+        print(f'[RabbitMQ] Queuing message: {message}')
+
+    
+    async def close(self) -> None:
+        print("Closing...")

encryptors-2.81.2/src/Osdental/Messaging/__init__.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class IMessageBus(ABC):
+
+    """Provides message publishing capabilities.
+
+    Implementations may publish messages using providers such as
+    Azure Service Bus, RabbitMQ, Kafka, or other messaging systems.
+    """
+
+    @abstractmethod
+    async def publish(
+        self,
+        queue: str,
+        message: dict[str, Any] | str,
+    ) -> None:
+        """Publishes a message to the specified queue.
+
+        Args:
+            queue:
+                Name of the destination queue.
+
+            message:
+                Message payload to publish. Implementations may support
+                plain strings, dictionaries, or other serializable types.
+        """
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Releases any resources held by the messaging provider.
+
+        Implementations should close network connections, authentication
+        credentials, and any other allocated resources.
+        """
+        pass

encryptors-2.81.0/src/Osdental/Models/ApiResponse.py → encryptors-2.81.2/src/Osdental/Models/Response.py

@@ -1,17 +1,13 @@
 from dataclasses import dataclass, field, asdict
-from typing import Any, Optional
+from typing import Any
 from Osdental.Shared.Enums.Code import Code
 from Osdental.Shared.Enums.Message import Message
 
 @dataclass
-class ApiResponse:
+class Response:
     status: Any = field(default=Code.PROCESS_SUCCESS_CODE)
     message: str = field(default=Message.PROCESS_SUCCESS_MSG)
-    data: Optional[Any] = None
-    error: Optional[str] = None
+    data: Any | None = None
 
-    def send(self):
-        api_response = asdict(self)
-
-        if api_response["error"] is None:
-            api_response.pop("error")
+    def send(self) -> dict[str, Any]:
+        return asdict(self)

encryptors-2.81.0/src/Osdental/Graphql/Models/__init__.py → encryptors-2.81.2/src/Osdental/Models/base_graphql_context.py

@@ -7,8 +7,5 @@ from Osdental.Models.Token import AuthToken
 class BaseGraphQLContext:
     request: Request
     container: Any
-    # valores agregados durante ejecución (AuditExtention)
     token: Optional[AuthToken] = None
-    decrypted_payload: Optional[dict] = None
-    aes_auth: Optional[str] = None
-    audit_plain_response: Optional[Any] = None
+    aes_auth: Optional[str] = None