Encryptors 2.39__tar.gz → 2.40__tar.gz

{encryptors-2.39 → encryptors-2.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.39
+Version: 2.40
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai
@@ -59,26 +59,7 @@ Requires-Dist: gunicorn==23.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
-Dynamic: description
 Dynamic: description-content-type
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
-
-# osdental-library
-
-`osdental-library` is a versatile and easy-to-use library for handling common tasks related to **encryption**, **hashing**, and **JWT token management**. Ideal for projects that require a secure and efficient approach to handling sensitive data.
-
-## Features
-
-- Generation and validation of **hashes** using modern algorithms.
-- Encryption and decryption of data using secure keys.
-- Creation and verification of **JWT tokens** for authentication and authorization.
-- Implementations that are easy to integrate into any Python project.
-
-## Installation
-
-You can easily install `osdental-library` using `pip`:
-
-```bash
-pip install osdental-library

{encryptors-2.39 → encryptors-2.40}/setup.py

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

{encryptors-2.39 → encryptors-2.40}/src/Encryptors.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.39
+Version: 2.40
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai
@@ -59,26 +59,7 @@ Requires-Dist: gunicorn==23.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
-Dynamic: description
 Dynamic: description-content-type
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
-
-# osdental-library
-
-`osdental-library` is a versatile and easy-to-use library for handling common tasks related to **encryption**, **hashing**, and **JWT token management**. Ideal for projects that require a secure and efficient approach to handling sensitive data.
-
-## Features
-
-- Generation and validation of **hashes** using modern algorithms.
-- Encryption and decryption of data using secure keys.
-- Creation and verification of **JWT tokens** for authentication and authorization.
-- Implementations that are easy to integrate into any Python project.
-
-## Installation
-
-You can easily install `osdental-library` using `pip`:
-
-```bash
-pip install osdental-library

{encryptors-2.39 → encryptors-2.40}/src/Encryptors.egg-info/SOURCES.txt

@@ -12,6 +12,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/SqlDataNormalizer.py

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

@@ -0,0 +1,3 @@
+def public_resolver(resolver):
+    setattr(resolver, "_is_public", True)
+    return resolver

{encryptors-2.39 → encryptors-2.40}/src/Osdental/Decorators/SecureResolver.py

@@ -8,12 +8,13 @@ from Osdental.Shared.Enums.Profile import Profile
 from Osdental.Exception.ControlledException import OSDException, AccessDeniedException
 from Osdental.Encryptor.Aes import AES
 from Osdental.Graphql.Models import BaseGraphQLContext
+from Osdental.Shared.Logger import logger
 
 def secure_resolver(action = None):
     def decorator(func: Callable):
 
         signature = inspect.signature(func)
-        accepts_data = "data" in signature.parameters
+        params = signature.parameters
 
         @wraps(func)
         async def wrapper(obj: Any, context: BaseGraphQLContext, **kwargs: Dict[str, Any]):
@@ -26,10 +27,13 @@ def secure_resolver(action = None):
                     if Profile(token.abbreviation) not in action.allowed_roles:
                         raise AccessDeniedException(error="The user's profile is not allowed to perform this action.")
 
-                if accepts_data and payload:
+                if "token" in params:
+                    kwargs["token"] = token
+
+                if "data" in params:
                     kwargs["data"] = payload
 
-                result: Response = await func(obj, context, **kwargs)
+                result: Response = await func(obj, **kwargs)
 
                 context.audit_plain_response = copy.deepcopy(result)
 
@@ -39,6 +43,7 @@ def secure_resolver(action = None):
                 return result.send()
 
             except (Exception, OSDException) as e:
+                logger.exception(f"An error has occurred: {str(e)}")
                 result = Response(
                     status=getattr(e, "status_code", "DB_ERROR_UNEXPECTED"),
                     message=getattr(e, "message", "Could not process request."),

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

@@ -0,0 +1,190 @@
+import json
+from graphql.pyutils import is_awaitable
+from ariadne.types import Extension
+from Osdental.Shared.Logger import logger
+from Osdental.Encryptor.Aes import AES
+from Osdental.Graphql._Helpers._TenantPolicy import TenantPolicy
+from Osdental.Rest.Context.RequestContext import (
+    current_context,
+    RequestContext
+)
+from Osdental.Graphql.Models import BaseGraphQLContext
+from Osdental.Shared.Enums.Constant import Constant
+
+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
+        if not hasattr(context, "_cached_body"):
+            context._cached_body = 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
+
+        # 🔥 CLAVE
+        is_root = root is None
+
+        # 🔥 SOLO ROOT → TODO TU SISTEMA
+        if is_root:
+
+            # 🔹 identificar resolver público
+            resolver_fn = getattr(next_, "__wrapped__", 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
+                token_service = container.token_service
+
+                aes_auth = request.app.state.aes_auth
+                aes_user = request.app.state.aes_user
+
+                if not aes_auth or not aes_user:
+                    aes_auth = None
+                    aes_user = None
+
+                original_token = None
+                if not is_public and headers.get("authorization"):
+                    try:
+                        original_token = await token_service.authenticate(headers, aes_user)
+                    except Exception:
+                        original_token = None
+
+                context._original_token = original_token
+                context.token = original_token
+                context.aes_auth = aes_auth
+
+            # 🔐 VALIDACIÓN SOLO ROOT
+            original_token = getattr(context, "_original_token", None)
+
+            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 encrypted_payload is not None:
+                if isinstance(encrypted_payload, dict):
+                    decrypted_payload = encrypted_payload
+
+                elif isinstance(encrypted_payload, str):
+                    try:
+                        decrypted_payload = json.loads(encrypted_payload)
+                    except Exception:
+                        if context.aes_auth:
+                            try:
+                                decrypted_payload = AES.decrypt(context.aes_auth, encrypted_payload)
+                                try:
+                                    decrypted_payload = json.loads(decrypted_payload)
+                                except Exception:
+                                    pass
+                            except Exception:
+                                decrypted_payload = None
+
+            if decrypted_payload is not None:
+                context.decrypted_payload = decrypted_payload
+            
+            if not is_public:
+                token = TenantPolicy.resolve(
+                    token=context._original_token,
+                    headers=request.headers,
+                    decrypted_payload=decrypted_payload,
+                    operation_type=info.operation.operation.value
+                )
+                context.token = token
+
+            # 🔹 auditoría request
+            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
+
+            if not getattr(context, "audit_plain_response", None):
+                context.audit_plain_response = 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 "__schema" in query or "__type" in query:
+            return
+
+        final_result = context.audit_plain_response or self.result
+
+        if final_result is None:
+            return
+
+        dispatcher = context.request.app.state.audit_dispatcher
+
+        try:
+            dispatcher.dispatch(
+                request=self.request,
+                request_payload=self.request_payload,
+                result=final_result,
+                audit_type=Constant.MESSAGE_LOG_INTERNAL
+            )
+        except Exception as e:
+            logger(f"[AUDIT ERROR]: {str(e)}")

{encryptors-2.39 → encryptors-2.40}/src/Osdental/Storage/AzureBlobStorage.py

@@ -80,4 +80,8 @@ class AzureBlobStorage(IStorageService):
         return {
             "uploadUrl": url,
             "blobName": filename
-        }
+        }
+    
+    async def close(self):
+        await self._client.close()
+        await self._credential.close()

encryptors-2.39/README.md

@@ -1,17 +0,0 @@
-# osdental-library
-
-`osdental-library` is a versatile and easy-to-use library for handling common tasks related to **encryption**, **hashing**, and **JWT token management**. Ideal for projects that require a secure and efficient approach to handling sensitive data.
-
-## Features
-
-- Generation and validation of **hashes** using modern algorithms.
-- Encryption and decryption of data using secure keys.
-- Creation and verification of **JWT tokens** for authentication and authorization.
-- Implementations that are easy to integrate into any Python project.
-
-## Installation
-
-You can easily install `osdental-library` using `pip`:
-
-```bash
-pip install osdental-library

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

@@ -1,120 +0,0 @@
-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.Graphql.Models import BaseGraphQLContext
-from Osdental.Graphql._Exceptions import AESKeyNotFound
-from Osdental.Shared.Enums.Constant import Constant
-
-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
-
-    async def resolve(self, next_, root, info, **kwargs):
-
-        if not self.request_payload:
-            context: BaseGraphQLContext = info.context
-
-            request = context.request
-            self.request = request
-
-            body = await request.json()
-            headers = request.headers
-
-            container = context.container
-            token_service = container.token_service
-
-            aes_auth = request.app.state.aes_auth
-            aes_user = request.app.state.aes_user
-
-            if not aes_auth:
-                raise AESKeyNotFound("AES user key is missing.", "aes_auth")
-            
-            if not aes_user:
-                raise AESKeyNotFound("AES authorization key is missing.", "aes_user")
-
-            original_token = await token_service.authenticate(headers, aes_user)
-            
-            variables = body.get("variables") or {}
-            encrypted_payload = variables.get("data")
-
-            decrypted_payload = None
-
-            if encrypted_payload:
-                try:
-                    decrypted_payload = AES.decrypt(aes_auth, encrypted_payload)
-
-                    try:
-                        decrypted_payload = json.loads(decrypted_payload)
-                    except Exception:
-                        pass
-
-                except Exception:
-                    decrypted_payload = None
-
-            token = TenantPolicy.resolve(
-                token=original_token,
-                headers=request.headers,
-                decrypted_payload=decrypted_payload,
-                operation_type=info.operation.operation.value
-            )
-            
-            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
-            }
-
-            context.decrypted_payload = decrypted_payload
-            context.token = token
-            context.aes_auth = aes_auth
-
-        result = next_(root, info, **kwargs)
-
-        if is_awaitable(result):
-            result = await result
-
-        if root 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 "__schema" in query or "__type" in query: return
-    
-        if not hasattr(context, "audit_plain_response"): return
-
-        dispatcher = context.request.app.state.audit_dispatcher
-
-        dispatcher.dispatch(
-            request=self.request,
-            request_payload=self.request_payload,
-            result=context.audit_plain_response,
-            audit_type=Constant.MESSAGE_LOG_INTERNAL
-        )