dapper-sqls 0.9.7__py3-none-any.whl → 1.2.0__py3-none-any.whl

dapper_sqls/dapper/executors.py

@@ -1,12 +1,11 @@
-# -*- coding: latin -*-
+# coding: utf-8
 import pyodbc
 from time import sleep
 from datetime import datetime
 from typing import overload
 from abc import ABC, abstractmethod
-from ..models import ConnectionStringData, Result, UnavailableServiceException, BaseUpdate
+from ..models import ConnectionStringData, Result, UnavailableServiceException, BaseUpdate, SearchTable, JoinSearchTable
 from .._types import T, ExecType
-from ..config import Config
 from ..builders import QueryBuilder, StoredBuilder
 from ..utils import Utils
 
@@ -14,6 +13,7 @@ class BaseExecutor(ABC, object):
     def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int, sql_version : int | None, api_environment : bool):
         self._connectionStringData = connectionStringData
         self._cursor = None
+        self._connection_error : Exception = None
         self._connection = None
         self._wait_timeout = wait_timeout 
         self._attempts = attempts 
@@ -25,19 +25,19 @@ class BaseExecutor(ABC, object):
         for n in range(self._attempts):
             odbc_version = f'ODBC Driver {self._sql_version} for SQL Server' 
             if not self._sql_version:
-                all_driver_versions = Config.get_all_odbc_driver_versions()
-                if all_driver_versions:
-                    odbc_version = all_driver_versions[0]
-                else:
-                    raise RuntimeError("Nenhuma vers�o do driver ODBC for SQL Server foi encontrada.")
+                drivers = [d for d in pyodbc.drivers() if 'SQL Server' in d]
+                if not drivers:
+                    raise RuntimeError("Nenhum driver ODBC do SQL Server encontrado. Instale o ODBC Driver 17 ou 18.")
+                odbc_version = drivers[-1]
             try:
                 connection_string = f'DRIVER={{{odbc_version}}};SERVER={cs_data.server};DATABASE={cs_data.database};UID={cs_data.username};PWD={cs_data.password}'
                 self._connection = pyodbc.connect(connection_string)
                 self._cursor = self._connection.cursor()
 
             except Exception as e:
+                self._connection_error = e
                 print(e)
-                print(f'Erro na conex�o com a base de dados, nova tentativa em {self._wait_timeout}s')
+                print(f'Erro na conexção com a base de dados, nova tentativa em {self._wait_timeout}s')
                 sleep(self._wait_timeout)
 
         return self
@@ -81,7 +81,7 @@ class BaseExecutor(ABC, object):
         if isinstance(value, int):
             self._attempts = value
         else:
-            raise ValueError("O n�mero de tentativas deve ser um n�mero inteiro.")
+            raise ValueError("O número de tentativas deve ser um número inteiro.")
 
     @property
     def wait_timeout(self):
@@ -92,7 +92,7 @@ class BaseExecutor(ABC, object):
         if isinstance(value, int):
             self._wait_timeout = value
         else:
-            raise ValueError("O tempo de espera deve ser um n�mero inteiro.")
+            raise ValueError("O tempo de espera deve ser um número inteiro.")
 
     @abstractmethod
     def _exec_(self, connection, operation_sql, exec_type):
@@ -120,41 +120,79 @@ class Query(BaseExecutor):
     def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int, sql_version : int | None, api_environment : bool):
         super().__init__(connectionStringData, attempts, wait_timeout, sql_version, api_environment)
 
+    @overload
+    def count(self, query : str) -> Result.Count:
+        pass
+
+    @overload
+    def count(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.Count:
+        pass
+
+    def count(self, *args, **kwargs) -> T | Result.Count:
+        args = Utils.args_query(*args, **kwargs)
+        if args.model:
+            args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
+
+        count_query = f"""
+        SELECT COUNT(*) AS Count FROM (
+            {args.query}
+        ) AS count_subquery
+        """
+
+        result : Result.Fetchone = self._exec_(self._connection, count_query, ExecType.fetchone)
+        if result.success:
+            return Result.Count(count_query, result.dict.get('Count', 0), result.status_code, result.error)
+        return Result.Count(count_query, 0, result.status_code, result.error)
+
     @overload
     def fetchone(self, query : str) -> Result.Fetchone:
         pass
 
     @overload
-    def fetchone(self, model : T, additional_sql : str = "") -> T:
+    def fetchone(self, model : T, additional_sql : str = "") -> Result.FetchoneModel[T]:
         pass
           
-    def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+    def fetchone(self, *args, **kwargs) -> Result.FetchoneModel[T] | Result.Fetchone:
         args = Utils.args_query(*args, **kwargs)
         if args.model:
             args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
 
         result = self._exec_(self._connection, args.query, ExecType.fetchone)
         if args.model:
-            return args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            model_instance = args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            return Result.FetchoneModel(model_instance, result)
         return result 
+    
+    def fetchone_with_joins(self, main_search: SearchTable, joins: list[JoinSearchTable] = [], additional_sql: str = "", select_top: int = None) -> Result.Fetchone:
+        query = QueryBuilder.select_with_joins(main_search, joins, additional_sql, select_top)
+        result = self._exec_(self._connection, query, ExecType.fetchone)
+        result._organize_joined_tables(joins)
+        return result
 
     @overload
     def fetchall(self, query : str) -> Result.Fetchall:
         pass
 
     @overload
-    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.FetchallModel[T]:
         pass
 
-    def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+    def fetchall(self, *args, **kwargs) -> Result.FetchallModel[T] | Result.Fetchall:
         args = Utils.args_query(*args, **kwargs)
         if args.model:
             args.query = QueryBuilder.select(args.model, args.additional_sql, args.select_top)
 
         result = self._exec_(self._connection, args.query, ExecType.fetchall)
         if args.model:
-            return [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            models = [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            return Result.FetchallModel(models, result)
         return result 
+    
+    def fetchall_with_joins(self, main_search: SearchTable, joins: list[JoinSearchTable] = [], additional_sql: str = "", select_top: int = None) -> Result.Fetchall:
+        query = QueryBuilder.select_with_joins(main_search, joins, additional_sql, select_top)
+        result = self._exec_(self._connection, query, ExecType.fetchall)
+        result._organize_joined_tables(joins)
+        return result
 
     def execute(self, query : str) -> Result.Send:
         return self._exec_(self._connection, query, ExecType.send)
@@ -174,21 +212,21 @@ class Query(BaseExecutor):
         query = QueryBuilder.insert(model, name_column_id)
         result : Result.Fetchone = self._exec_(self._connection, query, ExecType.fetchone)
         if result.success:
-            return Result.Insert(result.dict.get('Id', 0), result.status_code, result.message)
-        return Result.Insert(0, result.status_code, result.message)
+            return Result.Insert(query, result.dict.get('Id', 0), result.status_code, result.error)
+        return Result.Insert(query, 0, result.status_code, result.error)
         
-    def _exec_(self, connection, query_sql : str, exec_type : ExecType) -> Result.Send:
+    def _exec_(self, connection, query_sql : str, exec_type : ExecType):
 
         if not self._cursor:
             if self._api_environment:
                 raise UnavailableServiceException()
 
             if exec_type == ExecType.fetchone:
-                return Result.Fetchone(None, None, 503)
+                return Result.Fetchone(query_sql, None, None, self._connection_error)
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503)
+                return Result.Fetchall(query_sql, None, None, self._connection_error)
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503)
+                return Result.Send(query_sql, False, self._connection_error)
             
         try:
             # executar
@@ -196,23 +234,23 @@ class Query(BaseExecutor):
 
             # ober resultado se nessesario
             if exec_type == ExecType.fetchone:
-                result = Result.Fetchone(self._cursor, response.fetchone())
+                result = Result.Fetchone(query_sql, self._cursor, response.fetchone())
             elif exec_type == ExecType.fetchall:
-                result = Result.Fetchall(self._cursor, response.fetchall())
+                result = Result.Fetchall(query_sql, self._cursor, response.fetchall())
             elif exec_type == ExecType.send:
-                result = Result.Send(True)
+                result = Result.Send(query_sql, True)
 
             # fazer o commit 
             connection.commit()
 
         except Exception as ex:
             if exec_type == ExecType.fetchone:
-                return Result.Fetchone(None, None, 503, str(ex))
+                return Result.Fetchone(query_sql, None, None, ex)
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503, str(ex))
+                return Result.Fetchall(query_sql, None, None, ex)
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503, str(ex))
-
+                return Result.Send(query_sql, False, str(ex))
+        
         # retorna o resultado
         return result
 
@@ -229,6 +267,30 @@ class Stored(BaseExecutor):
     def __init__(self, connectionStringData : ConnectionStringData, attempts : int, wait_timeout : int,sql_version : int | None,  api_environment : bool):
         super().__init__(connectionStringData, attempts, wait_timeout, sql_version, api_environment)
 
+    @overload
+    def count(self, query : str) -> Result.Count:
+        pass
+
+    @overload
+    def count(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.Count:
+        pass
+
+    def count(self, *args, **kwargs) -> T | Result.Count:
+        args = Utils.args_query(*args, **kwargs)
+        if args.model:
+            args.query = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
+
+        count_query = f"""
+        SELECT COUNT(*) AS Count FROM (
+            {args.query}
+        ) AS count_subquery
+        """
+
+        result : Result.Fetchone = self._exec_(self._connection, count_query, ExecType.fetchone)
+        if result.success:
+            return Result.Count(count_query, result.dict.get('Count', 0), result.status_code, result.error)
+        return Result.Count(count_query, 0, result.status_code, result.error)
+
     @overload
     def fetchone(self, query : str, params : list | tuple) -> Result.Fetchone:
         pass
@@ -238,17 +300,18 @@ class Stored(BaseExecutor):
         pass
 
     @overload
-    def fetchone(self, model : T, additional_sql : str = "") -> T:
+    def fetchone(self, model : T, additional_sql : str = "") -> Result.FetchoneModel[T]:
         pass
           
-    def fetchone(self, *args, **kwargs) -> T | Result.Fetchone:
+    def fetchone(self, *args, **kwargs) -> Result.FetchoneModel[T] | Result.Fetchone:
         args = Utils.args_stored(*args, **kwargs)
         if args.model:
             args.query, args.params = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
 
         result = self._exec_(self._connection, (args.query, *args.params), ExecType.fetchone)
         if args.model:
-            return args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            model_instance = args.model.__class__(**result.dict) if result.success else args.model.__class__()
+            return Result.FetchoneModel(model_instance, result)
         return result 
 
     @overload
@@ -260,17 +323,18 @@ class Stored(BaseExecutor):
         pass
 
     @overload
-    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> list[T]:
+    def fetchall(self, model : T, additional_sql : str = "", select_top : int = None) -> Result.FetchallModel[T]:
         pass
 
-    def fetchall(self, *args, **kwargs) -> list[T] | Result.Fetchall:
+    def fetchall(self, *args, **kwargs) -> Result.FetchallModel[T] | Result.Fetchall:
         args = Utils.args_stored(*args, **kwargs)
         if args.model:
             args.query, args.params = StoredBuilder.select(args.model, args.additional_sql, args.select_top)
 
         result = self._exec_(self._connection, (args.query, *args.params), ExecType.fetchall)
         if args.model:
-            return [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            models = [args.model.__class__(**r) for r in result.list_dict] if result.success else []
+            return Result.FetchallModel(models, result)
         return result
 
     @overload
@@ -301,10 +365,11 @@ class Stored(BaseExecutor):
             name_column_id = next(iter(insert_data.keys())) 
 
         query, params = StoredBuilder.insert(model, name_column_id)
-        result = self._exec_(self._connection, (query,  *params), ExecType.fetchone)
+        stored_procedure = (query,  *params)
+        result = self._exec_(self._connection, stored_procedure, ExecType.fetchone)
         if result.success:
-            return Result.Insert(result.dict.get('Id', 0), result.status_code, result.message)
-        return Result.Insert(0, result.status_code, result.message)
+            return Result.Insert(stored_procedure, result.dict.get('Id', 0), result.status_code, result.error)
+        return Result.Insert(stored_procedure, 0, result.status_code, result.error)
 
     def _exec_(self, connection , stored_procedure : tuple, exec_type : ExecType):
  
@@ -313,29 +378,39 @@ class Stored(BaseExecutor):
                 raise UnavailableServiceException()
 
             if exec_type == ExecType.fetchone:
-                return Result.Fetchone(None, None, 503)
+                return Result.Fetchone(stored_procedure, None, None, self._connection_error)
+            elif exec_type == ExecType.fetchall:
+                return Result.Fetchall(stored_procedure, None, None, self._connection_error)
+            elif exec_type == ExecType.send:
+                return Result.Send(stored_procedure, False, self._connection_error)
+            
+        try:
+            # executar
+            response = self._cursor.execute(*stored_procedure)
+
+            # ober resultado se nessesario
+            if exec_type == ExecType.fetchone:
+                result = Result.Fetchone(stored_procedure, self._cursor, response.fetchone())
             elif exec_type == ExecType.fetchall:
-                return Result.Fetchall(None, None, 503)
+                result = Result.Fetchall(stored_procedure, self._cursor, response.fetchall())
             elif exec_type == ExecType.send:
-                return Result.Send(False, 503)
-
-        # executar
-        response = self._cursor.execute(*stored_procedure)
-      
-        # ober resultado se nessesario
-        if exec_type == ExecType.fetchone:
-            result = Result.Fetchone(self._cursor, response.fetchone())
-        elif exec_type == ExecType.fetchall:
-            result = Result.Fetchall(self._cursor, response.fetchall())
-        elif exec_type == ExecType.send:
-            result = Result.Send(True)
-
-        # fazer o commit 
-        connection.commit()
+                result = Result.Send(stored_procedure, True)
+
+            # fazer o commit 
+            connection.commit()
 
+        except Exception as ex:
+            if exec_type == ExecType.fetchone:
+                return Result.Fetchone(stored_procedure, None, None, ex)
+            elif exec_type == ExecType.fetchall:
+                return Result.Fetchall(stored_procedure, None, None, ex)
+            elif exec_type == ExecType.send:
+                return Result.Send(stored_procedure, False, ex)
+        
         # retorna o resultado
         return result
 
+       
 
 
 

dapper_sqls/decorators.py

@@ -1,10 +1,10 @@
-# -*- coding: latin -*-
+# coding: utf-8
 from functools import wraps
 import asyncio
 from time import perf_counter
 from typing import Callable
 
-def func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True):
+def func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True, default_value = None):
     """
     Synchronous function decorator for validation, error handling, and logging execution time.
     """
@@ -25,6 +25,7 @@ def func_validation(callable_msg_error: Callable = None, use_raise: bool = False
                         raise
                     else:
                         print(f"Unhandled exception in '{func.__name__}': {error_message}")
+                return default_value
             finally:
                 if use_log:
                     stop = perf_counter()
@@ -33,7 +34,7 @@ def func_validation(callable_msg_error: Callable = None, use_raise: bool = False
         return wrapper
     return decorator
 
-def async_func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True):
+def async_func_validation(callable_msg_error: Callable = None, use_raise: bool = False, use_log: bool = True, default_value = None):
     """
     Asynchronous function decorator for validation, error handling, and logging execution time.
     """
@@ -54,6 +55,7 @@ def async_func_validation(callable_msg_error: Callable = None, use_raise: bool =
                         raise
                     else:
                         print(f"Unhandled exception in async function '{func.__name__}': {error_message}")
+                return default_value
             finally:
                 if use_log:
                     stop = perf_counter()

dapper_sqls/http/__init__.py

@@ -0,0 +1,4 @@
+from .aiohttp import AioHttp, HttpMethod, DataFetchHttp
+from .request import Request
+
+

dapper_sqls/http/aiohttp.py

@@ -0,0 +1,155 @@
+# coding: utf-8
+
+import asyncio
+from time import perf_counter
+import aiohttp
+from .models import HttpMethod, UnavailableService, DataFetchHttpResult, DataFetchHttp
+from typing import overload
+import re
+from urllib.parse import urlparse
+import jwt
+from datetime import datetime
+
+class AioHttp(object):
+
+    @staticmethod
+    def is_valid_jwt(token: str) -> bool:
+        """Verifica se uma string tem o formato de um JWT"""
+        parts = token.split(".")
+        if len(parts) != 3:
+            return False  # Deve ter exatamente 3 partes
+        
+        try:
+            # Apenas decodifica sem verificar a assinatura
+            jwt.decode(token, options={"verify_signature": False})
+            return True  # Decodificação sem erro -> é um JWT válido
+        except jwt.DecodeError:
+            return False  # Não é um JWT válido
+        except jwt.ExpiredSignatureError:
+            return True  # É um JWT, mas está expirado
+        except jwt.InvalidTokenError:
+            return False  # Token inválido
+        
+    def get_token_expiration(token: str) -> datetime | None:
+        """Obtém a data de expiração (exp) de um JWT sem precisar validar a assinatura."""
+        try:
+            decoded = jwt.decode(token, options={"verify_signature": False})  # Decodifica sem verificar
+            exp_timestamp = decoded.get("exp")  # Obtém o timestamp de expiração
+            if exp_timestamp:
+                return datetime.utcfromtimestamp(exp_timestamp)  # Converte para datetime
+        except jwt.DecodeError:
+            return None  # Token inválido
+
+        return None  # Token sem expiração definida
+
+    @staticmethod
+    def is_valid_url(url: str) -> bool:
+        parsed_url = urlparse(url)
+        
+        # Verifica se o esquema (scheme) é http ou https e se há um domínio válido
+        if parsed_url.scheme not in {"http", "https"} or not parsed_url.netloc:
+            return False
+        
+        # Regex para verificar um domínio válido
+        domain_pattern = re.compile(
+            r"^(?:[a-zA-Z0-9-]{1,63}\.)+[a-zA-Z]{2,63}$"
+        )
+        
+        return bool(domain_pattern.match(parsed_url.netloc))
+
+    def __init__(self, base_url = "http://127.0.0.1:8000/", raise_error = False):
+        self.base_url = base_url
+        self.headers = {'Content-Type': 'application/json'}
+        self.endpoint_test_connection = 'test-connection'
+        self.raise_error = raise_error
+
+    async def test_connection(self):
+        data = DataFetchHttp("test-connection", self.endpoint_test_connection, HttpMethod.GET )
+        try:
+            res = await self.fetch(data)
+            if res.success:
+                return True
+        except:
+            ...
+
+    @overload
+    async def fetch(self, data: DataFetchHttp, session: aiohttp.ClientSession) -> DataFetchHttpResult:
+        pass
+
+    @overload
+    async def fetch(self, data: DataFetchHttp) -> DataFetchHttpResult:
+        pass
+
+    @overload
+    async def fetch(self, endpoint : str, http_method : HttpMethod, data : dict = {}) -> DataFetchHttpResult:
+         pass
+
+    @overload
+    async def fetch(self, endpoint : str, http_method : HttpMethod) -> DataFetchHttpResult:
+         pass
+
+    async def fetch(self, *args) -> DataFetchHttpResult:
+        if type(args[0]) == str:
+            if len(args) == 3:
+                endpoint, http_method, data = args 
+            else:
+                endpoint, http_method = args
+                data = {}
+            data_fetch_http = DataFetchHttp("", endpoint, http_method, data)
+            async with aiohttp.ClientSession() as session:
+                return await self._do_fetch(data_fetch_http, session)
+        else:
+            data_fetch_http = args[0]
+            if len(args) == 1:
+                async with aiohttp.ClientSession() as session:
+                    return await self._do_fetch(data_fetch_http, session)
+            else:
+                session = args[1]
+                return await self._do_fetch(data_fetch_http, session)
+
+    async def _do_fetch(self, data_fetch_http: DataFetchHttp, session: aiohttp.ClientSession) -> DataFetchHttpResult:
+        url = f'{self.base_url}{data_fetch_http.endpoint}'
+
+        try:
+            method = session.get 
+            if data_fetch_http.http_method == HttpMethod.POST:
+                method = session.post
+            elif data_fetch_http.http_method == HttpMethod.PUT:
+                method = session.put
+            elif data_fetch_http.http_method == HttpMethod.DELETE:
+                method = session.delete
+
+            start = perf_counter()
+            async with method(url, headers=self.headers, json=data_fetch_http.data) as r:
+                content = await r.json() if r.headers.get("Content-Type") == "application/json" else {"text": await r.text()}
+
+            stop = perf_counter()
+            delay = round(stop - start, 3)
+            if r.status == 200:
+                return DataFetchHttpResult(name=data_fetch_http.name, success=True, content=content, status_code=r.status, delay=delay)
+            elif r.status == 503:
+                if self.raise_error:
+                    raise UnavailableService()
+                else:
+                    return DataFetchHttpResult(name=data_fetch_http.name, success=False, status_code=503, content={'error': 'Database unavailable'}, delay=delay)
+            return DataFetchHttpResult(name=data_fetch_http.name, success=False, content=content, status_code=r.status, delay=delay)
+        except aiohttp.ClientError as e:
+            stop = perf_counter()
+            delay = round(stop - start, 3)
+            return DataFetchHttpResult(
+                name=data_fetch_http.name,
+                success=False,
+                content={"error": str(e)}, 
+                status_code=0, 
+                delay=delay
+            )
+
+    async def fetch_all(self, list_data_fetch_http: list[DataFetchHttp]) -> dict[str, DataFetchHttpResult]:
+        async with aiohttp.ClientSession() as session:
+            tasks = [self.fetch(data, session) for data in list_data_fetch_http]
+            res = await asyncio.gather(*tasks)
+            return {t.name: t for t in res}
+
+
+
+

dapper_sqls/http/decorators.py

@@ -0,0 +1,123 @@
+# coding: utf-8
+from functools import wraps
+import asyncio
+from time import perf_counter
+from .models import UnavailableService, InternalServerError
+import http
+from collections.abc import Mapping
+from typing_extensions import Annotated, Doc
+from typing import Any, Dict, Optional
+
+class StarletteHTTPException(Exception):
+    def __init__(self, status_code: int, detail: str | None = None, headers: Mapping[str, str] | None = None) -> None:
+        if detail is None:
+            detail = http.HTTPStatus(status_code).phrase
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = headers
+
+    def __str__(self) -> str:
+        return f"{self.status_code}: {self.detail}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(status_code={self.status_code!r}, detail={self.detail!r})"
+
+class HTTPException(StarletteHTTPException):
+    """
+    An HTTP exception you can raise in your own code to show errors to the client.
+
+    This is for client errors, invalid authentication, invalid data, etc. Not for server
+    errors in your code.
+
+    Read more about it in the
+    [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/).
+
+    ## Example
+
+    ```python
+    from fastapi import FastAPI, HTTPException
+
+    app = FastAPI()
+
+    items = {"foo": "The Foo Wrestlers"}
+
+
+    @app.get("/items/{item_id}")
+    async def read_item(item_id: str):
+        if item_id not in items:
+            raise HTTPException(status_code=404, detail="Item not found")
+        return {"item": items[item_id]}
+    ```
+    """
+
+    def __init__(
+        self,
+        status_code: Annotated[
+            int,
+            Doc(
+                """
+                HTTP status code to send to the client.
+                """
+            ),
+        ],
+        detail: Annotated[
+            Any,
+            Doc(
+                """
+                Any data to be sent to the client in the `detail` key of the JSON
+                response.
+                """
+            ),
+        ] = None,
+        headers: Annotated[
+            Optional[Dict[str, str]],
+            Doc(
+                """
+                Any headers to send to the client in the response.
+                """
+            ),
+        ] = None,
+    ) -> None:
+        super().__init__(status_code=status_code, detail=detail, headers=headers)
+
+def _create_error(e : Exception):
+    error_message = str(e)
+    error_type = None
+    error_code = None
+    error_status_code = None
+
+    if hasattr(e , 'message'):
+        error_message = e.message
+    if hasattr(e, 'type'):
+        error_type = e.type
+    if hasattr(e, 'code'):
+        error_code = e.code
+    if hasattr(e, 'status_code'):
+        error_status_code = e.status_code
+
+    return InternalServerError(message=error_message, status_code=error_status_code, type=error_type, code=error_code)
+
+def func_router_validation(use_log = True):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            if use_log:
+                start = perf_counter()
+            try:
+                return await asyncio.create_task(func(*args, **kwargs))
+            except Exception as e:
+                error = _create_error(e)
+                if error.status_code == 503:
+                    raise HTTPException(status_code=503, detail=UnavailableService().model_dump())
+                
+                raise HTTPException(status_code=500, detail=error.model_dump())
+            finally:
+                if use_log:
+                    stop = perf_counter()
+                    execution_time = round(stop - start, 3)
+                    print(f"The function '{func.__name__}' executed in {execution_time} seconds.")
+
+        return wrapper
+
+    return decorator