Encryptors 2.77__tar.gz → 2.79__tar.gz

{encryptors-2.77 → encryptors-2.79}/PKG-INFO

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

{encryptors-2.77 → encryptors-2.79}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="Encryptors", 
-    version="2.77",
+    version="2.79",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.77 → encryptors-2.79}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.77 → encryptors-2.79}/src/Encryptors.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ src/Osdental/Database/BaseRepository.py
 src/Osdental/Database/Connection.py
 src/Osdental/Database/__init__.py
 src/Osdental/Decorators/Grpc.py
+src/Osdental/Decorators/PublicResolver.py
 src/Osdental/Decorators/Retry.py
 src/Osdental/Decorators/SecureResolver.py
 src/Osdental/Decorators/__init__.py

encryptors-2.79/src/Osdental/Decorators/PublicResolver.py

@@ -0,0 +1,139 @@
+import logging
+import asyncio
+from functools import wraps
+from typing import Callable
+from graphql import GraphQLResolveInfo
+from Osdental.Models.Response import Response
+from Osdental.Models.Graphql import BaseGraphQLContext
+from Osdental.Models.TokenClaims import AccessTokenClaims
+from Osdental.Exception.ControlledException import (
+    OSDException
+)
+from Osdental.Services import IAuthTokenService
+from Osdental.Helpers.AuthTokenProcessor import (
+    decrypt_and_parse_payload, get_current_user,
+    get_current_aes_key
+)
+from Osdental.Enums.StatusCode import StatusCode
+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 public_resolver():
+
+    def decorator(func: Callable):
+
+        @wraps(func)
+        async def wrapper(obj, info: GraphQLResolveInfo, **kwargs):
+            try:
+                context: BaseGraphQLContext = info.context
+                container = context.container
+                request = context.request
+                headers = request.headers
+                settings = container.settings
+
+                access_token = headers.get("Accesstoken")
+                claims: AccessTokenClaims | None = None
+                audit_ctx: AuditContext | None = None
+                operation_type = info.operation.operation.value
+
+                # ── 1. AUTENTICACIÓN ──────────────────────────────
+                token_service: IAuthTokenService = container.auth_token_service
+
+                claims = await token_service.validate_external_access_token(
+                    access_token
+                )
+                context.access_token = access_token
+                context.access_token_claims = claims
+
+                # ── 2. DECRYPT DEL PAYLOAD ────────────────────────
+                body = await request.json()
+                encrypted_payload = (
+                    kwargs.get("data")
+                    or body.get("variables", {}).get("data")
+                )
+                decrypted_payload = None
+
+                if encrypted_payload is not None:
+                    decrypted_payload = decrypt_and_parse_payload(
+                        aes_key_auth=claims.aes_key,
+                        encrypted_payload=encrypted_payload
+                    )
+
+                    kwargs["data"] = decrypted_payload
+
+
+                # ── 5. CONTEXTO DE AUDITORÍA ──────────────
+                # Lo construimos antes del resolver para que siempre exista
+                user = get_current_user(context)
+                key = get_current_aes_key(context)
+                audit_ctx = AuditContext.from_request(
+                    request=request,
+                    settings=settings,
+                    body=body,
+                    operation_type=operation_type,
+                    id_user=user,
+                    decrypted_key=key,
+                    decrypted_payload=decrypted_payload,
+                )
+
+                _ctx.set(audit_ctx)
+
+                # ── 6. EJECUTAR RESOLVER ──────────────────
+                result = await func(obj, info, **kwargs)
+
+                if not isinstance(result, Response):
+                    raise TypeError("Resolver must return a Response instance")
+
+                # ── 7. AUDITAR ÉXITO ──────────────────────
+                _ = asyncio.create_task(
+                    container.audit_emitter.emit(
+                        {
+                            "payload": _build_success_payload(audit_ctx, result),
+                            "is_auditable": settings.is_auditable,
+                        }
+                    )
+                )
+
+                return result
+
+            except OSDException as e:
+                logger.warning(f"Business error: {str(e)}")
+                if audit_ctx:
+                    _ = asyncio.create_task(
+                        container.audit_emitter.emit(
+                            {
+                                "payload": _build_error_payload(audit_ctx, e),
+                                "is_auditable": settings.is_auditable,
+                            }
+                        )
+                    )
+                return Response(
+                    status=e.status_code,
+                    message=e.message,
+                    error=e.error
+                )
+            except Exception as e:
+                logger.exception(f"Unexpected error: {str(e)}")
+                if audit_ctx:
+                    _ = asyncio.create_task(
+                        container.audit_emitter.emit(
+                            {
+                                "payload": _build_unexpected_payload(audit_ctx, e),
+                                "is_auditable": settings.is_auditable,
+                            }
+                        )
+                    )
+                return Response(
+                    status=StatusCode.INTERNAL_SERVER_ERROR,
+                    message="Could not process request.",
+                    error=str(e)
+                )
+
+        return wrapper
+    return decorator

{encryptors-2.77 → encryptors-2.79}/src/Osdental/Decorators/SecureResolver.py

@@ -6,7 +6,7 @@ from graphql import GraphQLResolveInfo
 from Osdental.Models.Response import Response
 from Osdental.Models.Graphql import BaseGraphQLContext
 from Osdental.Models.TokenClaims import (
-    UserTokenClaims, AccessTokenClaims
+    UserTokenClaims
 )
 from Osdental.Models.Token import AuthToken
 from Osdental.Enums.Profile import Profile
@@ -28,10 +28,9 @@ from Osdental.Context import _ctx
 logger = logging.getLogger(__name__)
 
 
-def resolver(public: bool = False, action=None):
+def resolver(action=None):
 
     def decorator(func: Callable):
-        func._is_public = public
 
         @wraps(func)
         async def wrapper(obj, info: GraphQLResolveInfo, **kwargs):
@@ -42,29 +41,19 @@ def resolver(public: bool = False, action=None):
                 headers = request.headers
                 settings = container.settings
 
-                access_token = headers.get("Accesstoken")
                 token: type[AuthToken] | None = None
-                aes_key = None
-                claims: UserTokenClaims | AccessTokenClaims | None = None
+                claims: UserTokenClaims | None = None
                 audit_ctx: AuditContext | None = None
                 operation_type = info.operation.operation.value
 
                 # ── 1. AUTENTICACIÓN ──────────────────────────────
                 token_service: IAuthTokenService = container.auth_token_service
-                if not public:
-                    user_token = extract_bearer_token(headers)                    
-                    claims = await token_service.validate_internal_access_token(
-                        user_token
-                    )
-                    aes_key = claims.aes_key_auth
-
-                elif public and access_token:
-                    claims = await token_service.validate_external_access_token(
-                        access_token
-                    )
-                    aes_key = claims.aes_key
-                    context.access_token = access_token
-                    context.access_token_claims = claims
+                user_token = extract_bearer_token(headers)
+                context.user_token = user_token
+                
+                claims = await token_service.validate_internal_access_token(
+                    user_token
+                )
 
                 # ── 2. DECRYPT DEL PAYLOAD ────────────────────────
                 body = await request.json()
@@ -76,26 +65,24 @@ def resolver(public: bool = False, action=None):
 
                 if encrypted_payload is not None:
                     decrypted_payload = decrypt_and_parse_payload(
-                        aes_key_auth=aes_key,
+                        aes_key_auth=claims.aes_key_auth,
                         encrypted_payload=encrypted_payload
                     )
 
                     kwargs["data"] = decrypted_payload
 
                 # ── 3. TENANT POLICY ──────────────────────────────
-                if not public:
-
-                    token = build_auth_token(
-                        claims=claims,
-                        headers=request.headers,
-                        decrypted_payload=decrypted_payload,
-                        operation_type=operation_type,
-                    )
-                    
-                    context.token = token
+                token = build_auth_token(
+                    claims=claims,
+                    headers=request.headers,
+                    decrypted_payload=decrypted_payload,
+                    operation_type=operation_type,
+                )
+                
+                context.token = token
 
                 # ── 4. CONTROL DE ACCESO POR ROL ─────────────────
-                if not public and action:
+                if action:
                     if Profile(token.abbreviation) not in action.allowed_roles:
                         raise AccessDeniedException(
                             status_code=StatusCode.BUSINESS_RULE_WARNING,
@@ -127,8 +114,10 @@ def resolver(public: bool = False, action=None):
                 # ── 7. AUDITAR ÉXITO ──────────────────────
                 _ = asyncio.create_task(
                     container.audit_emitter.emit(
-                        _build_success_payload(audit_ctx, result),
-                        settings.is_auditable,
+                        {
+                            "payload": _build_success_payload(audit_ctx, result),
+                            "is_auditable": settings.is_auditable,
+                        }
                     )
                 )
 
@@ -139,8 +128,10 @@ def resolver(public: bool = False, action=None):
                 if audit_ctx:
                     _ = asyncio.create_task(
                         container.audit_emitter.emit(
-                            _build_error_payload(audit_ctx, e),
-                            settings.is_auditable,
+                            {
+                                "payload": _build_error_payload(audit_ctx, e),
+                                "is_auditable": settings.is_auditable,
+                            }
                         )
                     )
                 return Response(
@@ -153,8 +144,10 @@ def resolver(public: bool = False, action=None):
                 if audit_ctx:
                     _ = asyncio.create_task(
                         container.audit_emitter.emit(
-                            _build_unexpected_payload(audit_ctx, e),
-                            settings.is_auditable,
+                            {
+                                "payload": _build_unexpected_payload(audit_ctx, e),
+                                "is_auditable": settings.is_auditable,
+                            }
                         )
                     )
                 return Response(

{encryptors-2.77 → encryptors-2.79}/src/Osdental/Helpers/AuditQueue.py

@@ -27,10 +27,13 @@ class AuditQueue:
 
     async def _consume(self):
         while True:
-            payload = await self._queue.get()
+            item = await self._queue.get()
 
             try:
-                await self._worker(payload)
+                await self._worker(
+                    item["payload"],
+                    item["is_auditable"],
+                )
 
             except Exception:
                 logger.exception("Error processing audit")

{encryptors-2.77 → encryptors-2.79}/src/Osdental/Helpers/AuthTokenProcessor.py

@@ -10,11 +10,11 @@ from Osdental.Enums.Profile import Profile
 from Osdental.Models.TokenClaims import UserTokenClaims
 from Osdental.Models.Graphql import BaseGraphQLContext
 
-def extract_bearer_token(headers: Headers) -> str:
+def extract_bearer_token(headers: Headers) -> str | None:
 
     authorization = headers.get("authorization")
     if not authorization or not authorization.startswith("Bearer "):
-        raise ValueError("Missing Bearer token")
+        return None
     
     return authorization.removeprefix("Bearer ").strip()
     

{encryptors-2.77 → encryptors-2.79}/src/Osdental/Models/Graphql.py

@@ -10,4 +10,5 @@ class BaseGraphQLContext:
     container: Any
     access_token: str | None = None
     access_token_claims: AccessTokenClaims | None = None
+    user_token: str | None = None
     token: AuthToken | None = None