dapper-sqls 1.1.3__py3-none-any.whl → 1.2.1__py3-none-any.whl

dapper_sqls/models/result.py

@@ -1,27 +1,168 @@
 # coding: utf-8
+from typing import Generic, Any
+from .._types import SqlErrorType, SQL_ERROR_HTTP_CODES, T
+from .base import SensitiveFields
+import json
+from collections import defaultdict
 
 def result_dict(cursor, result):
-        return dict(
-                zip(
-                    [column[0] for column in cursor.description],
-                    result
-                )
-                )
+    return dict(
+            zip(
+                [column[0] for column in cursor.description],
+                result
+            )
+            )
 
-class Result(object):
+def classify_error(message: str) -> SqlErrorType:
+    msg = message.lower()
+
+    if "unique key constraint" in msg or "duplicate key" in msg:
+        return SqlErrorType.UNIQUE_VIOLATION
+    if "foreign key constraint" in msg:
+        return SqlErrorType.FOREIGN_KEY_VIOLATION
+    if "check constraint" in msg:
+        return SqlErrorType.CHECK_CONSTRAINT_VIOLATION
+    if "permission denied" in msg or "permission violation" in msg:
+        return SqlErrorType.PERMISSION_DENIED
+    if "syntax error" in msg:
+        return SqlErrorType.SYNTAX_ERROR
+    if "timeout" in msg:
+        return SqlErrorType.TIMEOUT
+    if any(kw in msg for kw in [
+        "could not connect", 
+        "connection failed", 
+        "server not found",
+        "network-related", 
+        "login failed", 
+        "connection timeout", 
+        "transport-level error", 
+        "communication link failure"
+    ]):
+        return SqlErrorType.CONNECTION_ERROR
     
-    class Fetchone(object):
-        def __init__(self, cursor, result, status_code = 200, message : str = ""):
+    return SqlErrorType.UNKNOWN
+
+class Error(object):
+    def __init__(self, exception: Exception = None):
+        self.message =  str(exception) if isinstance(exception, Exception) else ""
+        self.type = classify_error(self.message)
+
+class BaseResult(object):
+    def __init__(self, query : str | tuple):
+        if isinstance(query, tuple):
+            q_str, *params = query
+            stored_procedure = {
+                "query": q_str,
+                "params": [list(p) if isinstance(p, tuple) else p for p in params]
+            }
+            self._query = json.dumps(stored_procedure)
+        else:
+            self._query = query
+
+    @property
+    def query(self):
+        return self._query
+
+class Result(object):
+
+    class Count(BaseResult):
+        def __init__(self, query : str | tuple, result : int | str, status_code : int, error: Error):
+            super().__init__(query)
+            self._count = result
             self._status_code = status_code
-            self._message = message
-            if result:
+            self._success = bool(status_code == 200)
+            self._error = error
+
+        def model_dump(self):
+            if self.success:
+                return {'status_code': self.status_code, 'count': self.count}
+            else:
+                return {'status_code': self.status_code, 'message': self.error.message}
+            
+        @property
+        def count(self):
+            return self._count
+
+        @property
+        def status_code(self):
+            return self._status_code
+
+        @property
+        def success(self):
+            return self._success
+        
+        @property
+        def error(self):
+            return self._error
+    
+    class Fetchone(BaseResult):
+        def __init__(self, query : str | tuple, cursor, result, exception: Exception = None):
+            super().__init__(query)
+            self._error = Error(exception)
+            self._list = []
+            self._dict : dict[str, Any] = {}
+            if cursor != None:
+                self._status_code = 200
                 self._success = True
-                self._list = result
-                self._dict = dict(zip([column[0] for column in cursor.description], result))
+                if result:
+                    sensitive_fields = SensitiveFields.get()
+                    columns = [column[0] for column in cursor.description]
+                    raw_dict = dict(zip(columns, result))
+                    self._dict = {
+                        k: v for k, v in raw_dict.items()
+                        if k not in sensitive_fields
+                    }
+                    self._list = result
             else:
+                self._status_code = SQL_ERROR_HTTP_CODES.get(self._error.type, 500)
                 self._success = False
-                self._list = []
-                self._dict = {}
+        
+        def _organize_joined_tables(self, joins: list):
+            alias_to_table_name = {
+                join.model.TABLE_ALIAS: join.model.__class__.__name__ for join in joins
+            }
+
+            if not self._dict:
+                return
+
+            alias_data = defaultdict(dict)
+            keys_to_remove = []
+
+            for key, value in self._dict.items(): 
+                for alias_table, table_name in alias_to_table_name.items():
+                    if alias_table in key:
+                        column_name = key.replace(alias_table, '')
+                        alias_data[table_name][column_name] = value
+                        keys_to_remove.append(key)
+                        break
+
+            for key in keys_to_remove:
+                self._dict.pop(key)
+
+            if alias_data:
+                self._dict['joined_tables'] = dict(alias_data)
+
+            if self._list:
+                columns = [col for col in self._dict.keys() if col]
+                self._list = [self._dict[col] for col in columns]
+
+        def model_dump(self, *, include: set[str] = None):
+            if not self.success:
+                return {
+                    'status_code': self.status_code,
+                    'message': self.error.message
+                }
+
+            result_dict = self._dict.copy()
+
+            if include is not None:
+                include = set(include)
+                result_dict = {k: v for k, v in result_dict.items() if k in include  or k == 'joined_tables'}
+
+            return {
+                'status_code': self.status_code,
+                'data': result_dict
+            }
 
         @property
         def status_code(self):
@@ -40,24 +181,110 @@ class Result(object):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
 
+    class FetchoneModel(Generic[T]):
+        def __init__(self, model_instance: T, fetchone_result: 'Result.Fetchone'):
+            self._model = model_instance
+            self._fetchone = fetchone_result
 
-    class Fetchall:
+        @property
+        def query(self):
+            return self._fetchone.query
 
-        def __init__(self, cursor, result, status_code = 200, message : str = ""):
-            self._status_code = status_code
-            self._message = message
-            if result:
+        @property
+        def model(self) -> T:
+            return self._model
+
+        @property
+        def success(self):
+            return self._fetchone.success
+
+        @property
+        def dict(self):
+            return self._fetchone.dict
+
+        @property
+        def list(self):
+            return self._fetchone.list
+
+        @property
+        def status_code(self):
+            return self._fetchone.status_code
+
+        @property
+        def error(self):
+            return self._fetchone.error
+
+        def model_dump(self, *, include: set[str] = None):
+            return self._fetchone.model_dump(include=include)
+
+
+    class Fetchall(BaseResult):
+
+        def __init__(self, query : str | tuple, cursor, result, exception: Exception = None):
+            super().__init__(query)
+            self._error = Error(exception)
+            self._list_dict : list[dict[str, Any]] = []
+            if cursor != None:
+                self._status_code = 200
                 self._success = True
-                self._list_dict = []
-                for r in result:
-                    self._list_dict.append(dict(zip([column[0] for column in cursor.description], r)))
+                if result:
+                    sensitive_fields = SensitiveFields.get()
+                    columns = [column[0] for column in cursor.description]
+                    for r in result:
+                        raw_dict = dict(zip(columns, r))
+                        clean_dict = {
+                            k: v for k, v in raw_dict.items()
+                            if k not in sensitive_fields
+                        }
+                        self._list_dict.append(clean_dict)
             else:
+                self._status_code = SQL_ERROR_HTTP_CODES.get(self._error.type, 500)
                 self._success = False
-                self._list_dict = []
 
+        def _organize_joined_tables(self, joins: list):
+            alias_to_table_name = {
+                join.model.TABLE_ALIAS: join.model.__class__.__name__ for join in joins
+            }
+
+            for item in self._list_dict:
+                alias_data = defaultdict(dict)
+                keys_to_remove = []
+
+                for key, value in item.items(): 
+                    for alias_table, table_name in alias_to_table_name.items():
+                        if alias_table in key:
+                            column_name = key.replace(alias_table, '')
+                            alias_data[table_name][column_name] = value
+                            keys_to_remove.append(key)
+                            break
+
+                for key in keys_to_remove:
+                    del item[key]
+
+                if alias_data:
+                    item['joined_tables'] = dict(alias_data)
+
+        def model_dump(self, *, include: set[str] = None):
+            if not self.success:
+                return {
+                    'status_code': self.status_code,
+                    'message': self.error.message
+                }
+
+            data = self._list_dict
+
+            if include is not None:
+                include = set(include)
+                data = [{k: v for k, v in d.items() if k in include or k == 'joined_tables'} for d in data]
+
+            return {
+                'status_code': self.status_code,
+                'data': data
+            }
+        
         @property
         def status_code(self):
             return self._status_code
@@ -66,24 +293,60 @@ class Result(object):
         def list_dict(self):
             return self._list_dict
 
-        @property
-        def dict(self):
-            return self._dict
-
         @property
         def success(self):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
+        
+    class FetchallModel(Generic[T]):
+        def __init__(self, model_list: list[T], fetchall_result: 'Result.Fetchall'):
+            self._models = model_list
+            self._fetchall = fetchall_result
+
+        @property
+        def query(self):
+            return self._fetchall.query
+
+        @property
+        def models(self) -> list[T]:
+            return self._models
+
+        @property
+        def success(self):
+            return self._fetchall.success
+
+        @property
+        def list_dict(self):
+            return self._fetchall.list_dict
+
+        @property
+        def status_code(self):
+            return self._fetchall.status_code
+
+        @property
+        def error(self):
+            return self._fetchall.error
 
-    class Insert:
-        def __init__(self, result : int | str, status_code = 200, message : str = ""):
+        def model_dump(self, *, include: set[str] = None):
+            include = set(include)
+            return self._fetchall.model_dump(include=include)
+
+    class Insert(BaseResult):
+        def __init__(self, query : str | tuple, result : int | str, status_code : int, error: Error):
+            super().__init__(query)
             self._id = result
             self._status_code = status_code
-            self._success = bool(result)
-            self._message = message
+            self._success = bool(status_code == 200)
+            self._error = error
+
+        def model_dump(self):
+            if self.success:
+                return {'status_code': self.status_code, 'id': self.id}
+            else:
+                return {'status_code': self.status_code, 'message': self.error.message}
 
         @property
         def id(self):
@@ -98,15 +361,22 @@ class Result(object):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
 
-    class Send:
-        def __init__(self, result : bool, status_code = 200, message : str = ""):
-            self._status_code = status_code
+    class Send(BaseResult):
+        def __init__(self, query : str | tuple, result : bool, exception: Exception = None):
+            super().__init__(query)
+            self._error = Error(exception)
+            self._status_code = 200 if result else SQL_ERROR_HTTP_CODES.get(self._error.type, 500)
             self._success = result
-            self._message = message
 
+        def model_dump(self):
+            if self.success:
+                return {'status_code': self.status_code}
+            else:
+                return {'status_code': self.status_code, 'message': self.error.message}
+            
         @property
         def status_code(self):
             return self._status_code
@@ -116,8 +386,8 @@ class Result(object):
             return self._success
         
         @property
-        def message(self):
-            return self._message
+        def error(self):
+            return self._error
 
 
 

dapper_sqls/sqlite/__init__.py

@@ -2,6 +2,7 @@ from .local_database import BaseLocalDatabase
 from .async_local_database import BaseAsyncLocalDatabase
 from .installer import DataBaseInstall
 from .models import BaseTables
+from .decorators import safe_sqlite_operation, SqliteErrorType
 
 
 

dapper_sqls/sqlite/async_local_database.py

@@ -1,14 +1,15 @@
 # coding: utf-8
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
-from sqlalchemy import text
-from .models import BaseTables, Path, System, EnvVar
+from sqlalchemy import text, insert, delete, select, Connection
+from .models import BaseTables, Path, System, EnvVar, NotificationData
 from .utils import get_value
 
 class BaseAsyncLocalDatabase:
     
-     def __init__(self, app_name: str, path : str, is_new_database : bool):
+     def __init__(self, app_name: str, path : str, is_new_database : bool, insistent_tables : list[str]):
           self._app_name = app_name
           self.is_new_database = is_new_database
+          self.insistent_tables = insistent_tables
           self._engine: AsyncEngine = create_async_engine(f'sqlite+aiosqlite:///{path}')
 
      @property
@@ -18,6 +19,11 @@ class BaseAsyncLocalDatabase:
      @property
      def app_name(self):
           return self._app_name
+     
+     async def close(self):
+        await self._engine.dispose()  
+        self._engine.pool.dispose()  
+        self._engine = None
 
      async def init_db(self):
           async with self.engine.begin() as conn:
@@ -25,8 +31,15 @@ class BaseAsyncLocalDatabase:
                await conn.execute(BaseTables.system.insert().values(App=self.app_name, Tema='light'))
                await conn.commit()
 
-     async def select(self, table: str, where: str = None):
-          async with self.engine.connect() as conn:
+     async def select(self, table: str, where: str = None, conn : Connection = None):
+          if not conn:
+               async with self.engine.connect() as conn:
+                    query = f"SELECT * FROM {table} WHERE App = :app_name"
+                    if where:
+                         query += f" AND {where}"
+                    result = await conn.execute(text(query), {'app_name': self.app_name})
+                    return [row._mapping for row in result]
+          else:
                query = f"SELECT * FROM {table} WHERE App = :app_name"
                if where:
                     query += f" AND {where}"
@@ -102,3 +115,54 @@ class BaseAsyncLocalDatabase:
                     BaseTables.system.update().where(BaseTables.system.c.App == self.app_name).values(Tema=theme)
                )
 
+     async def insert_notification(self, data: NotificationData):
+          async with self.engine.begin() as conn:
+               ins = insert(BaseTables.notification).values(
+                    App=self.app_name,
+                    guid=data.guid,
+                    local=data.local,
+                    title=data.title,
+                    message=data.message,
+                    type=data.type,
+                    date=data.date
+               )
+               await conn.execute(ins)
+
+     async def delete_notification(self, guid: str):
+          async with self.engine.begin() as conn:
+               stmt = delete(BaseTables.notification).where(
+                    (BaseTables.notification.c.guid == guid) & (BaseTables.notification.c.App == self.app_name)
+               )
+               await conn.execute(stmt)
+
+     async def clear_notification(self):
+          async with self.engine.begin() as conn:
+               stmt = delete(BaseTables.notification).where(BaseTables.notification.c.App == self.app_name)
+               await conn.execute(stmt)
+
+     async def get_notifications(self):
+          async with self.engine.connect() as conn:
+               stmt = select(BaseTables.notification).where(BaseTables.notification.c.App == self.app_name)
+               result = await conn.execute(stmt)
+               notifications = result.fetchall()
+               return [NotificationData(**notification._mapping) for notification in notifications]
+
+     async def insert_notification(self, data : NotificationData):
+          async with self.engine.connect() as conn:
+               ins = insert(BaseTables.notification).values(App=self.app_name, guid=data.guid, local=data.local, title=data.title, message=data.message, type=data.type,date=data.date)
+               await conn.execute(ins)
+               await conn.commit()
+
+     async def delete_notification(self, guid : str):
+          async with self.engine.connect() as conn:
+               await conn.execute(delete(BaseTables.notification).where((BaseTables.notification.c.guid == guid) & (BaseTables.notification.c.App == self.app_name)))
+               await conn.commit()
+
+     async def clear_notification(self):
+          async with self.engine.connect() as conn:
+               await conn.execute(delete(BaseTables.notification).where(BaseTables.notification.c.App == self.app_name))
+               await conn.commit()
+
+     async def get_notifications(self):
+          notifications = await self.select('notification')
+          return [NotificationData(**notification) for notification in notifications]

dapper_sqls/sqlite/decorators.py

@@ -0,0 +1,69 @@
+# coding: utf-8
+from functools import wraps
+from dataclasses import dataclass
+from typing import Any, Callable, TypeVar
+from enum import Enum
+
+T = TypeVar("T")
+
+# Tipos de erro padronizados
+class SqliteErrorType(Enum):
+    UNIQUE_VIOLATION = "Unique violation"
+    FOREIGN_KEY_VIOLATION = "Foreign key violation"
+    CHECK_CONSTRAINT_VIOLATION = "Check constraint violation"
+    PERMISSION_DENIED = "Permission denied"
+    SYNTAX_ERROR = "Syntax error"
+    TIMEOUT = "Timeout"
+    CONNECTION_ERROR = "Connection error"
+    UNKNOWN = "Unknown"
+
+# Classificador específico para SQLite
+def classify_sqlite_error(message: str) -> SqliteErrorType:
+    msg = message.lower()
+
+    if "unique constraint failed" in msg:
+        return SqliteErrorType.UNIQUE_VIOLATION
+    if "foreign key constraint failed" in msg:
+        return SqliteErrorType.FOREIGN_KEY_VIOLATION
+    if "check constraint failed" in msg:
+        return SqliteErrorType.CHECK_CONSTRAINT_VIOLATION
+    if "permission denied" in msg:
+        return SqliteErrorType.PERMISSION_DENIED
+    if "syntax error" in msg or ("near" in msg and "syntax error" in msg):
+        return SqliteErrorType.SYNTAX_ERROR
+    if "database is locked" in msg or "timeout" in msg:
+        return SqliteErrorType.TIMEOUT
+    if any(kw in msg for kw in [
+        "unable to open database file",
+        "disk i/o error",
+        "not a database",
+        "file is encrypted",
+        "file is not a database"
+    ]):
+        return SqliteErrorType.CONNECTION_ERROR
+
+    return SqliteErrorType.UNKNOWN
+
+# Classe Error
+class Error:
+    def __init__(self, exception: Exception = None):
+        self.message = str(exception) if isinstance(exception, Exception) else ""
+        self.type = classify_sqlite_error(self.message) if self.message.strip() else None
+
+# Classe de retorno do decorador
+@dataclass
+class OperationResult:
+    success: bool
+    error: Error | None
+    result: Any = None
+
+# Decorador
+def safe_sqlite_operation(func: Callable[..., T]) -> Callable[..., OperationResult]:
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> OperationResult:
+        try:
+            result = func(*args, **kwargs)
+            return OperationResult(success=True, error=None, result=result)
+        except Exception as e:
+            return OperationResult(success=False, error=Error(e), result=None)
+    return wrapper

dapper_sqls/sqlite/installer.py

@@ -21,6 +21,7 @@ class DataBaseInstall(object):
           self.tables = tables if tables else BaseTables
           self._engine : Engine = None
           self.new_database = not path.isfile(self._path_database)
+          self.insistent_tables = []
           if not path.isfile(self._path_database):
                if not path.exists(path.join(path_local_database,database_folder_name)):
                     makedirs(path.join(path_local_database,database_folder_name))
@@ -29,10 +30,12 @@ class DataBaseInstall(object):
                     conn.execute(text("PRAGMA encoding = 'UTF-8'"))
                     conn.commit()
 
+               
                with self.engine.connect() as conn:
                     self.tables.meta_data.create_all(self.engine)
-                    ins = insert(self.tables.system).values(App=app_name, Tema='light')
-                    conn.execute(ins)
+                    if hasattr(self.tables, 'system'):
+                         ins = insert(self.tables.system).values(App=app_name, Tema='light')
+                         conn.execute(ins)
                     conn.commit()
           else:
                if not self.are_tables_existing(self.engine):
@@ -47,7 +50,7 @@ class DataBaseInstall(object):
                          ...
 
      def instance(self, obj : T) -> T:
-          return obj(self._app_name, self._path_database, self.new_database)
+          return obj(self._app_name, self._path_database, self.new_database, self.insistent_tables)
 
      @property
      def engine(self):
@@ -74,7 +77,8 @@ class DataBaseInstall(object):
           inspector = inspect(engine)
           existing_tables = inspector.get_table_names()
           required_tables = self.tables.meta_data.tables.keys()
-          return all(table in existing_tables for table in required_tables)
+          self.insistent_tables = [table for table in required_tables if table not in existing_tables]
+          return not bool(self.insistent_tables)
 
      def synchronize_columns(self, engine):
           inspector = inspect(engine)