safeshield 1.0.0__py3-none-any.whl

validator/database/manager.py

@@ -0,0 +1,162 @@
+import contextlib
+from typing import Dict, Any, List, Optional, Iterator
+import mysql.connector
+import psycopg2
+
+class DatabaseManager:
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.connection = None
+        self._connection_params = self._normalize_config()
+
+    def _normalize_config(self) -> Dict[str, Any]:
+        """Normalize different config formats from various frameworks"""
+        db_type = self.config.get('type', 'mysql').lower()
+        
+        # Handle SQLAlchemy-style URLs
+        if 'url' in self.config:
+            return self._parse_url(self.config['url'])
+        
+        return {
+            'type': db_type,
+            'host': self.config.get('host', 'localhost'),
+            'port': self.config.get('port', 3306 if db_type == 'mysql' else 5432),
+            'user': self.config.get('user') or self.config.get('username', 'root'),
+            'password': self.config.get('password', ''),
+            'database': self.config.get('database', ''),
+            'options': self.config.get('options', {})
+        }
+
+    def _parse_url(self, url: str) -> Dict[str, Any]:
+        """Parse SQLAlchemy-style database URLs"""
+        from urllib.parse import urlparse
+        parsed = urlparse(url)
+        return {
+            'type': parsed.scheme.split('+')[0],
+            'host': parsed.hostname,
+            'port': parsed.port,
+            'user': parsed.username,
+            'password': parsed.password,
+            'database': parsed.path[1:] if parsed.path else ''
+        }
+
+    @contextlib.contextmanager
+    def get_cursor(self) -> Iterator[Any]:
+        """Context manager for safe cursor handling"""
+        self.connect()
+        cursor = None
+        try:
+            cursor = self.connection.cursor(dictionary=True)
+            yield cursor
+        finally:
+            if cursor:
+                cursor.close()
+
+    def connect(self):
+        """Establish database connection with retry logic"""
+        if self.connection and self.connection.is_connected():
+            return
+
+        params = self._connection_params
+        try:
+            if params['type'] == 'mysql':
+                self.connection = mysql.connector.connect(
+                    host=params['host'],
+                    user=params['user'],
+                    password=params['password'],
+                    database=params['database'],
+                    port=params['port'],
+                    **params.get('options', {})
+                )
+            elif params['type'] == 'postgresql':
+                self.connection = psycopg2.connect(
+                    host=params['host'],
+                    user=params['user'],
+                    password=params['password'],
+                    dbname=params['database'],
+                    port=params['port'],
+                    **params.get('options', {})
+                )
+            elif params['type'] == 'sqlite':
+                import sqlite3
+                self.connection = sqlite3.connect(
+                    params['database'] or ':memory:',
+                    **params.get('options', {})
+                )
+        except Exception as e:
+            raise ConnectionError(f"Failed to connect to database: {str(e)}")
+
+    def disconnect(self):
+        """Safely disconnect with cleanup"""
+        if self.connection:
+            try:
+                if hasattr(self.connection, 'is_connected') and self.connection.is_connected():
+                    self.connection.close()
+                elif hasattr(self.connection, 'closed') and not self.connection.closed:
+                    self.connection.close()
+            except Exception:
+                pass
+            finally:
+                self.connection = None
+
+    def query(self, sql: str, params: tuple = ()) -> List[Dict[str, Any]]:
+        """Safe query execution with automatic reconnection"""
+        with self.get_cursor() as cursor:
+            cursor.execute(sql, params)
+            return cursor.fetchall()
+
+    def exists(self, table: str, column: str, value: Any) -> bool:
+        """Optimized exists check with parameterized query"""
+        sql = f"SELECT 1 FROM {table} WHERE {column} = %s LIMIT 1"
+        result = self.query(sql, (value,))
+        return bool(result)
+
+    def is_unique(self, table: str, column: str, value: Any, 
+                ignore_id: Optional[int] = None) -> bool:
+        """Advanced uniqueness check with ignore condition"""
+        where_clause = f"{column} = %s"
+        params = [value]
+        
+        if ignore_id is not None:
+            where_clause += " AND id != %s"
+            params.append(ignore_id)
+            
+        sql = f"""
+        SELECT NOT EXISTS (
+            SELECT 1 FROM {table} 
+            WHERE {where_clause}
+            LIMIT 1
+        ) AS is_unique
+        """
+        
+        result = self.query(sql, tuple(params))
+        return result[0]['is_unique']
+
+    def table_exists(self, table_name: str) -> bool:
+        """Check if table exists in database"""
+        try:
+            if self._connection_params['type'] == 'mysql':
+                sql = """
+                SELECT COUNT(*) AS count 
+                FROM information_schema.tables 
+                WHERE table_schema = %s AND table_name = %s
+                """
+                result = self.query(sql, (self._connection_params['database'], table_name))
+            elif self._connection_params['type'] == 'postgresql':
+                sql = """
+                SELECT COUNT(*) AS count 
+                FROM information_schema.tables 
+                WHERE table_schema = 'public' AND table_name = %s
+                """
+                result = self.query(sql, (table_name,))
+            else:  # SQLite
+                sql = """
+                SELECT COUNT(*) AS count 
+                FROM sqlite_master 
+                WHERE type='table' AND name=?
+                """
+                result = self.query(sql, (table_name,))
+                
+            return result[0]['count'] > 0
+        except Exception:
+            return False

validator/exceptions.py

@@ -0,0 +1,10 @@
+from typing import Dict, List, Tuple, Optional
+
+class ValidationException(Exception):
+    def __init__(self, errors: dict):
+        self.errors = errors
+        super().__init__(self.errors)
+        
+class RuleNotFoundException(ValueError):
+    def __init__(self, rule_name: str):
+        super().__init__(f"Validation rule '{rule_name}' is not registered")

validator/factory.py

@@ -0,0 +1,26 @@
+# factory.py
+from typing import Type, Dict, List
+from .rules import all_rules
+from .rules.base import ValidationRule
+
+class RuleFactory:
+    _rules: Dict[str, Type[ValidationRule]] = all_rules
+    
+    @classmethod
+    def create_rule(cls, rule_name: str) -> ValidationRule:
+        try:
+            return cls._rules[rule_name]()
+        except KeyError:
+            raise ValueError(f"Unknown validation rule: {rule_name}")
+    
+    @classmethod
+    def register_rule(cls, name: str, rule_class: Type[ValidationRule]):
+        cls._rules[name] = rule_class
+        
+    @classmethod
+    def has_rule(cls, rule_name: str) -> bool:
+        return rule_name in cls._rules
+
+    @classmethod
+    def get_rule_names(cls) -> List[str]:
+        return list(cls._rules.keys())

validator/rules/__init__.py

@@ -0,0 +1,27 @@
+import inspect
+from .base import ValidationRule
+from ..utils.string import pascal_to_snake
+from . import array, basic, comparison, date, type, files, format, conditional, string, utilities
+
+def _collect_rules():
+    modules = [array, basic, comparison, date, type, files, format, conditional, string, utilities]
+    rules = {}
+    
+    for module in modules:
+        for name, obj in inspect.getmembers(module):
+            if (inspect.isclass(obj) and 
+                issubclass(obj, ValidationRule) and 
+                obj != ValidationRule):
+                rules[obj.rule_name] = obj
+    return rules
+
+all_rules = _collect_rules()
+
+for name, cls in all_rules.items():
+    globals()[cls.__name__.replace('Rule', '')] = cls  # Export class name
+    globals()[name] = cls  # Export rule name
+
+
+__all__ = ['ValidationRule'] + \
+        list(all_rules.keys()) + \
+        [cls.__name__.replace('Rule', '') for cls in all_rules.values()]

validator/rules/array.py

@@ -0,0 +1,77 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+class ArrayRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        
+        self._missing_keys = params
+        
+        if params:
+            params = self._parse_option_values(self.rule_name, params)
+            if not isinstance(value, dict):
+                return False
+
+            missing = [param for param in params if param not in value]
+            self._missing_keys = missing
+            return len(missing) == 0
+
+        return isinstance(value, (list, tuple, set))
+
+    def message(self, field: str, params: List[str]) -> str:
+        if params:
+            return f"The {field} must contain the keys: {', '.join(self._missing_keys)}."
+        return f"The {field} must be an array."
+
+class ContainsRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+            
+        search_value = params[0]
+        
+        # String contains substring
+        if isinstance(value, str):
+            return search_value in value
+            
+        # Array contains element
+        if isinstance(value, (list, tuple, set)):
+            return search_value in value
+            
+        # Dictionary contains key
+        if isinstance(value, dict):
+            return search_value in value.keys()
+            
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must contain {params[0]}"
+    
+class DistinctRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not isinstance(value, (list, tuple, set)):
+            return False
+            
+        return len(value) == len(set(value))
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must contain unique values"
+    
+class InArrayRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+            
+        return str(value) in params
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be one of: {', '.join(params)}"
+    
+class InArrayKeysRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or not isinstance(value, dict):
+            return False
+            
+        return any(key in value for key in params)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must contain at least one of these keys: {', '.join(params)}"

validator/rules/base.py

@@ -0,0 +1,84 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+from enum import Enum
+from ..utils.string import pascal_to_snake
+import inspect
+
+class ValidationRule(ABC):
+    """Abstract base class for all validation rules"""
+    
+    def __init__(self, *params: str):
+        self._validator: Optional['Validator'] = None
+        self._params: List[str] = list(params)
+        
+    def __init_subclass__(cls):
+        cls.rule_name = pascal_to_snake(cls.__name__)
+    
+    @property
+    def params(self) -> List[str]:
+        return self._params
+    
+    @params.setter
+    def params(self, value: List[str]) -> None:
+        self._params = value
+    
+    def set_validator(self, validator: 'Validator') -> None:
+        """Set the validator instance this rule belongs to."""
+        self._validator = validator
+        
+    def set_field_exists(self, exists: bool):
+        self._field_exists = exists
+    
+    @property
+    def validator(self) -> 'Validator':
+        """Get the validator instance."""
+        if self._validator is None:
+            raise RuntimeError("Validator not set for this rule!")
+        return self._validator
+    
+    @property
+    def field_exists(self):
+        return self._field_exists
+    
+    def get_field_value(self, field_name, default=''):
+        return str(self.validator.data.get(field_name, default))
+    
+    @staticmethod
+    def is_empty(value):
+        return value in (None, '', [], {})
+    
+    @abstractmethod
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        """Validate a field's value."""
+        pass
+    
+    @abstractmethod
+    def message(self, field: str) -> str:
+        """Generate an error message if validation fails."""
+        pass
+    
+    @property
+    @abstractmethod
+    def rule_name(self) -> str:
+        """Return the name of the rule for error messages."""
+        pass
+    
+    def _parse_option_values(self, field: str, params: List[str]) -> List[Any]:
+        """Parse parameters into allowed values, supporting both Enum class and literal values"""
+        if not params:
+            raise ValueError(
+                f"{self.rule_name} rule requires parameters. "
+                f"Use '({self.rule_name}, EnumClass)' or '{self.rule_name}:val1,val2'"
+            )
+            
+        enum_params = [param for param in params if inspect.isclass(param) and issubclass(param, Enum)]
+        params = [param for param in params if param not in enum_params]
+        
+        for enum_param in enum_params:
+            params.extend([e.value for e in enum_param])
+            
+        params = set([str(param) for param in params])
+            
+        param_str = ' ,'.join(params)
+        
+        return [v.strip() for v in param_str.split(',') if v.strip()]

validator/rules/basic.py

@@ -0,0 +1,41 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+# =============================================
+# BASIC VALIDATION RULES
+# =============================================
+
+class RequiredRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return not self.is_empty(value)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field is required."
+
+class NullableRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name may be null."
+
+class FilledRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return value not in ('', None)
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must have a value."
+
+class PresentRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return field in self.validator.data
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name field must be present."
+
+class SometimesRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        return True
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return ""

validator/rules/comparison.py

@@ -0,0 +1,240 @@
+from .base import ValidationRule
+from typing import Any, Dict, List, Optional, Set, Union, Tuple, Type
+
+# =============================================
+# COMPARISON VALIDATION RULES
+# =============================================
+
+class MinRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+            
+        try:
+            min_val = float(params[0])
+        except ValueError:
+            return False
+            
+        if isinstance(value, (int, float)):
+            return value >= min_val
+        elif isinstance(value, str):
+            try:
+                return len(value) >= min_val
+            except ValueError:
+                return len(value) >= min_val
+        elif isinstance(value, (list, dict, set)):
+            return len(value) >= min_val
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be at least {params[0]}."
+
+class MaxRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or len(params) < 1:
+            return False
+            
+        try:
+            max_val = float(params[0])
+            
+            # Handle Werkzeug/Flask FileStorage
+            if hasattr(value, 'content_length'):  # Flask/Werkzeug
+                file_size = value.content_length
+                print(f"File size (content_length): {file_size}")
+                return file_size <= max_val
+                
+            # Handle generic file objects with size attribute
+            if hasattr(value, 'size'):
+                file_size = value.size
+                return file_size <= max_val
+                
+            # Handle file-like objects with seek/read
+            if hasattr(value, 'seek') and hasattr(value, 'read'):
+                try:
+                    current_pos = value.tell()
+                    value.seek(0, 2)  # Seek to end
+                    file_size = value.tell()
+                    value.seek(current_pos)  # Return to original position
+                    return file_size <= max_val
+                except (AttributeError, IOError):
+                    pass
+
+            # Numeric validation
+            if isinstance(value, (int, float)):
+                return value <= max_val
+                
+            # String/collection length validation
+            if isinstance(value, (str, list, dict, set, tuple)):
+                length = len(value)
+                return length <= max_val
+                
+            # String numeric validation
+            if isinstance(value, str):
+                try:
+                    num = float(value)
+                    return num <= max_val
+                except ValueError:
+                    length = len(value)
+                    return length <= max_val
+                    
+        except (ValueError, TypeError) as e:
+            return False
+            
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        value = self.get_field_value(field)
+        if value is None:
+            return f"The {field} must not exceed {params[0]}"
+            
+        # Check all possible file size attributes
+        file_attrs = ['content_length', 'size', 'fileno']
+        if any(hasattr(value, attr) for attr in file_attrs):
+            return f"File {field} must not exceed {params[0]} bytes"
+        return f"The {field} must not exceed {params[0]}"
+
+class BetweenRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) != 2:
+            return False
+            
+        try:
+            min_val = float(params[0])
+            max_val = float(params[1])
+            
+            # File size validation (untuk Werkzeug/FileStorage)
+            if hasattr(value, 'content_length'):  # Cek atribut Werkzeug
+                file_size = value.content_length
+                return min_val <= file_size <= max_val
+            elif hasattr(value, 'size'):  # Cek atribut umum
+                file_size = value.size
+                return min_val <= file_size <= max_val
+                
+            # Numeric validation
+            if isinstance(value, (int, float)):
+                return min_val <= value <= max_val
+                
+            # String/collection length validation
+            if isinstance(value, (str, list, dict, set, tuple)):
+                length = len(value)
+                return min_val <= length <= max_val
+                
+            # String numeric validation
+            if isinstance(value, str):
+                try:
+                    num = float(value)
+                    return min_val <= num <= max_val
+                except ValueError:
+                    length = len(value)
+                    return min_val <= length <= max_val
+                    
+        except (ValueError, TypeError) as e:
+            return False
+            
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        value = self.get_field_value(field)
+        if hasattr(value, 'content_length') or hasattr(value, 'size'):
+            return f"File {field} must be between {params[0]} and {params[1]} bytes"
+        return f"The {field} must be between {params[0]} and {params[1]}"
+
+class SizeRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or len(params) < 1:
+            return False
+            
+        try:
+            target_size = float(params[0])
+            
+            # 1. Handle file objects (Flask/Werkzeug/FastAPI)
+            if hasattr(value, 'content_length'):  # Flask/Werkzeug
+                return value.content_length == target_size
+            elif hasattr(value, 'size'):  # FastAPI or custom file objects
+                return value.size == target_size
+            elif hasattr(value, 'seek') and hasattr(value, 'tell'):  # File-like objects
+                current_pos = value.tell()
+                value.seek(0, 2)  # Seek to end
+                file_size = value.tell()
+                value.seek(current_pos)  # Return to original position
+                return file_size == target_size
+                
+            # 2. Handle numeric values
+            if isinstance(value, (int, float)):
+                return value == target_size
+                
+            # 3. Handle strings and collections
+            if isinstance(value, (str, list, dict, set, tuple)):
+                return len(value) == target_size
+                
+            # 4. Handle string representations of numbers
+            if isinstance(value, str):
+                try:
+                    return float(value) == target_size
+                except ValueError:
+                    return len(value) == target_size
+                    
+        except (ValueError, TypeError, AttributeError) as e:
+            return False
+            
+        return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        value = self.get_field_value(field)
+        if value is None:
+            return f"The {field} must be exactly {params[0]}"
+            
+        # Check for file attributes
+        file_attrs = ['content_length', 'size', 'fileno']
+        if any(hasattr(value, attr) for attr in file_attrs):
+            return f"File {field} must be exactly {params[0]} bytes"
+            
+        return f"The {field} must be exactly {params[0]}"
+    
+class DigitsRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params or not isinstance(value, str):
+            return False
+            
+        try:
+            digits = int(params[0])
+        except ValueError:
+            return False
+            
+        return value.isdigit() and len(value) == digits
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be {params[0]} digits."
+
+class DigitsBetweenRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if len(params) < 2 or not isinstance(value, str):
+            return False
+            
+        try:
+            min_digits = int(params[0])
+            max_digits = int(params[1])
+        except ValueError:
+            return False
+            
+        return value.isdigit() and min_digits <= len(value) <= max_digits
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be between {params[0]} and {params[1]} digits."
+
+class MultipleOfRule(ValidationRule):
+    def validate(self, field: str, value: Any, params: List[str]) -> bool:
+        if not params:
+            return False
+            
+        try:
+            divisor = float(params[0])
+            if divisor == 0:
+                return False
+            num = float(value)
+            return num % divisor == 0
+        except (ValueError, TypeError):
+            return False
+    
+    def message(self, field: str, params: List[str]) -> str:
+        return f"The :name must be a multiple of {params[0]}."