safeshield 1.0.0__py3-none-any.whl

safeshield-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wunsun Tarniho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

safeshield-1.0.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: safeshield
+Version: 1.0.0
+Summary: Library for Help Validation Control
+Home-page: https://github.com/WunsunTarniho/py-guard
+Author: Wunsun Tarniho
+Author-email: wunsun58@gmail.com
+Project-URL: Bug Tracker, https://github.com/WunsunTarniho/py-guard/issues
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django==5.2
+Requires-Dist: Flask==3.1.1
+Requires-Dist: mysql-connector-repackaged==0.3.1
+Requires-Dist: odoo==1.0
+Requires-Dist: Pillow==11.2.1
+Requires-Dist: psycopg2==2.9.10
+Requires-Dist: python-dotenv==1.1.1
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: setuptools==63.2.0
+Requires-Dist: SQLAlchemy==2.0.41
+Requires-Dist: Werkzeug==3.1.3
+
+## License
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details

safeshield-1.0.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+validator/__init__.py,sha256=udxDzUicPfxBOAQvzsnl3pHur9VUppKbWMgg35hpiww,244
+validator/exceptions.py,sha256=y2v7CaXmeGFHWcnigtLl4U-sFta_jMiXkGKXWIIVglY,366
+validator/factory.py,sha256=9I_dIq22QxZxCqtCECp1T5K0GeyD_YuGc8xtw4eexMs,794
+validator/core/__init__.py,sha256=ZcqlXJSk03i_CVzmIN-nVe1UOyvwwO5jhbEj7f62Y_o,59
+validator/core/validator.py,sha256=00qVnbH-EJC5KALlaoUBLAfsszAFLcoSxfRbmy0amyk,12751
+validator/database/__init__.py,sha256=vpGhoYt32oiYyJVsoWZkRKBgDZp8bTKeW2jXKVoNKA8,135
+validator/database/detector.py,sha256=mPNZlOgwNBPNwL_XcKSmT6H5Bq370nMkqqMMOqkM9WY,9568
+validator/database/manager.py,sha256=Ezz4NUh22Hz2puh-NJggSGCaw3lAGyp3V88plMeBBVU,6232
+validator/rules/__init__.py,sha256=y1HsA25CIZoNmTDJp9CHspdybsNtrWEiX8w_NNANuGw,963
+validator/rules/array.py,sha256=tx8FCDqn-27Vs7tgtjeoCE9ceDMVrdBEb2-pq-lNLuo,2809
+validator/rules/base.py,sha256=UeUXJlNkBGxKhgNvcamJqoZKTh7HO5v-t0eAAks_MKM,2894
+validator/rules/basic.py,sha256=fMk0s5_IEQu27X1wndP_ocNyOZ1upXJCn7fR9YYbI74,1527
+validator/rules/comparison.py,sha256=9xb2mO5GiThR1iO8867ex2o7olQC2Bnew6MBdD2UtEo,9402
+validator/rules/conditional.py,sha256=8_O1etzCyCGeD8lmfhegJ1uzhkBSjTEVdufbZmkqgP4,12993
+validator/rules/date.py,sha256=18JIKTO5nzFtCnJEMXm4OUbneqTMB7HGPN6jUkxGU4Y,5278
+validator/rules/files.py,sha256=vu_TZFffDPzDojyTsFXSQ6MmQm3WU6ppFfz7-wuDy98,6550
+validator/rules/format.py,sha256=UeeIAkFn0CdzC5bS9tI78_lbPYRgcpaUujxdmyCSdzE,3744
+validator/rules/string.py,sha256=vYzu4ICKY9FCuGahmsQCoJLmnlBF7uNvVazFj9DQ438,3178
+validator/rules/type.py,sha256=Tu-EOBkTtxkcCe0ANXavurZC449n63iE_VXVzc3BIiM,1596
+validator/rules/utilities.py,sha256=AIm9JRGYf6cTCSkivg3gTj3U5DnXlCAJ5ej1yUSa1dU,9724
+validator/services/__init__.py,sha256=zzKTmqL7v4niFGWHJBfWLqgJ0iTaW_69OzYZN8uInzQ,210
+validator/services/rule_conflict.py,sha256=s1RJNUY5d0WtSMHkrKulBCgJ2BZL2GE0Eu5pdAoiIbM,4943
+validator/services/rule_error_handler.py,sha256=MGvvkP6hbZLpVXxC3xpzg15OmVdPlk7l0M2Srmy5VfM,1729
+validator/services/rule_preparer.py,sha256=jRcMNjqq2xyZjO64Pim8jWmja5DmTzf0V_uuHG0lJTg,5621
+safeshield-1.0.0.dist-info/LICENSE,sha256=qugtRyKckyaks6hd2xyxOFSOYM6au1N80pMXuMTPvC4,1090
+safeshield-1.0.0.dist-info/METADATA,sha256=UNfuutZuSxKkc4MTaVOIbVynevAieQqkm88GDyEIT2I,1223
+safeshield-1.0.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+safeshield-1.0.0.dist-info/top_level.txt,sha256=iUtV3dlHOIiMfLuY4pruY00lFni8JzOkQ3Nh1II19OE,10
+safeshield-1.0.0.dist-info/RECORD,,

safeshield-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

safeshield-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+validator

validator/__init__.py

@@ -0,0 +1,7 @@
+
+from .core import Validator
+from .exceptions import ValidationException, RuleNotFoundException
+from .factory import RuleFactory
+
+__version__ = "1.0.0"
+__all__ = ['Validator', 'ValidationException', 'RuleNotFoundException', 'RuleFactory']

validator/core/__init__.py

@@ -0,0 +1,3 @@
+from .validator import Validator
+
+__all__ = ['Validator']

validator/core/validator.py

@@ -0,0 +1,299 @@
+from typing import Optional, Dict, Any, List, Tuple, Union
+from validator.exceptions import ValidationException, RuleNotFoundException
+from validator.factory import RuleFactory
+from validator.database import DatabaseManager, DatabaseAutoDetector
+from validator.rules import ValidationRule
+from validator.services.rule_conflict import RuleConflictChecker
+from validator.services.rule_error_handler import RuleErrorHandler
+from validator.services.rule_preparer import RulePreparer
+import warnings
+from collections.abc import Mapping
+
+class Validator:
+    """Main validation class with proper abstractions"""
+    PRIORITY_RULES = {
+        'bail', 'exclude_unless', 'exclude_if', 'exclude_with', 'exclude_without', 'required', 'required_if', 'required_unless',
+        'required_with', 'required_without'
+    }
+
+    def __init__(
+        self,
+        data: Optional[Dict[str, Any]] = None,
+        rules: Optional[Dict[str, Union[
+            str, 
+            List[Union[
+                str, 
+                ValidationRule, 
+                Tuple[str, Union[
+                    str, 
+                    Union[
+                        Tuple[str], 
+                        List[str]
+                    ], 
+                    Union[
+                        Tuple[str], 
+                        List[str]
+                    ]
+                ]]
+            ]],
+            Tuple[Union[
+                str, 
+                ValidationRule, 
+                Tuple[str, Union[
+                    str, 
+                    Union[
+                        Tuple[str], 
+                        List[str]
+                    ], 
+                    Union[
+                        Tuple[str], 
+                        List[str]
+                    ]
+                ]]
+            ]]
+        ]]] = None,
+        messages: Optional[Dict[str, str]] = None,
+        custom_attributes: Optional[Dict[str, str]] = None,
+        db_config: Optional[Dict[str, Any]] = None,
+        # rule_preparer: Optional[RulePreparer] = None,
+        # error_handler: Optional[RuleErrorHandler] = None
+    ):
+        self.data = data or {}
+        self._raw_rules = rules or {}
+        self._stop_on_first_failure = False
+        self._is_exclude = False
+        
+        # Initialize dependencies
+        self.rule_preparer = RulePreparer(RuleFactory())
+        self.error_handler = RuleErrorHandler(messages, custom_attributes)
+        
+        # Database configuration
+        self.db_config = db_config or DatabaseAutoDetector.detect()
+        if not self.db_config:
+            warnings.warn(
+                "No database config detected. exists/unique validations will be skipped!",
+                RuntimeWarning
+            )
+        self.db_manager = DatabaseManager(self.db_config) if self.db_config else None
+
+    def validate(self) -> bool:
+        """Validate the data against the rules"""
+        prepared_rules = self.rule_preparer.prepare(self._raw_rules)
+        self.error_handler.errors.clear()
+
+        validated = self._validate_rules(prepared_rules, priority_only=True)
+        
+        # First pass: priority rules
+        if self.error_handler.has_errors and self._stop_on_first_failure:
+            return False
+
+        # Second pass: remaining rules
+        self._validate_rules(prepared_rules, priority_only=False)
+        
+        if self.error_handler.has_errors:
+            return False
+        return True
+
+    def _validate_rules(self, prepared_rules: Dict[str, List[ValidationRule]], priority_only: bool):
+        validated = []
+        for field_pattern, rules in prepared_rules.items():
+            concrete_paths = self._resolve_wildcard_paths(field_pattern) if '*' in field_pattern else [field_pattern]
+            
+            for actual_path in concrete_paths:
+                self._current_actual_path = actual_path
+                raw_values = self._get_nested_value(actual_path)
+                field_exists = self._field_exists_in_data(actual_path)
+                
+                # Handle empty array case for wildcard
+                is_wildcard = '*' in field_pattern
+                is_empty_array = isinstance(raw_values, list) and len(raw_values) == 0
+                
+                # Special case: wildcard path with empty array
+                if is_wildcard and is_empty_array:
+                    values_to_validate = []
+                elif not is_wildcard and not is_empty_array:
+                    values_to_validate = [raw_values]
+                else:
+                    values_to_validate = [None] if not field_exists else (
+                        [raw_values] if not isinstance(raw_values, list) else raw_values
+                    )
+                    
+                for rule in rules:
+                    if priority_only == (rule.rule_name in self.PRIORITY_RULES) and not self._is_exclude:
+                        rule.set_field_exists(field_exists)
+                        
+                        # Skip validation for empty array with wildcard unless it's a required rule
+                        if is_wildcard and is_empty_array and rule.rule_name != 'required':
+                            continue
+                            
+                        for value in values_to_validate:
+                            validated.append(self._apply_rule(field_pattern, value, rule))
+                
+                delattr(self, '_current_actual_path')
+            self._is_exclude = False
+                
+        return all(valid for valid in validated)
+    
+    def _resolve_wildcard_paths(self, pattern: str) -> List[str]:
+        parts = pattern.split('.')
+        
+        def _resolve(data: Any, current_path: str, remaining_parts: List[str]) -> List[str]:
+            if not remaining_parts:
+                return [current_path] if current_path else []
+            
+            part = remaining_parts[0]
+            next_parts = remaining_parts[1:]
+            
+            if part == '*':
+                results = []
+                # Kasus khusus: wildcard di akhir path
+                if not next_parts:
+                    if isinstance(data, (list, tuple)):
+                        for i in range(len(data)):
+                            new_path = f"{current_path}.{i}" if current_path else str(i)
+                            results.append(new_path)
+                    elif isinstance(data, dict):
+                        for key in data.keys():
+                            new_path = f"{current_path}.{key}" if current_path else key
+                            results.append(new_path)
+                    else:
+                        # Jika bukan collection, kembalikan path saat ini
+                        if current_path:
+                            results.append(current_path)
+                    return results
+                
+                # Wildcard di tengah path (seperti sebelumnya)
+                if isinstance(data, (list, tuple)):
+                    for i, item in enumerate(data):
+                        new_path = f"{current_path}.{i}" if current_path else str(i)
+                        results.extend(_resolve(item, new_path, next_parts))
+                elif isinstance(data, dict):
+                    for key, value in data.items():
+                        new_path = f"{current_path}.{key}" if current_path else key
+                        results.extend(_resolve(value, new_path, next_parts))
+                return results
+            
+            # Handle regular path (sama seperti sebelumnya)
+            next_data = None
+            if isinstance(data, dict) and part in data:
+                next_data = data[part]
+            elif isinstance(data, (list, tuple)) and part.isdigit():
+                index = int(part)
+                if 0 <= index < len(data):
+                    next_data = data[index]
+            
+            if next_data is not None:
+                new_path = f"{current_path}.{part}" if current_path else part
+                return _resolve(next_data, new_path, next_parts)
+            
+            return []
+    
+        return _resolve(self.data, '', parts)
+    
+    def _field_exists_in_data(self, field_path: str) -> bool:
+        parts = field_path.split('.')
+        
+        def _check(data: Any, remaining_parts: List[str]) -> bool:
+            if not remaining_parts:
+                return True
+                
+            part = remaining_parts[0]
+            next_parts = remaining_parts[1:]
+            
+            if part == '*':
+                if isinstance(data, (list, tuple)):
+                    return any(_check(item, next_parts) for item in data)
+                elif isinstance(data, dict):
+                    return any(_check(value, next_parts) for value in data.values())
+                return False
+            
+            if isinstance(data, dict) and part in data:
+                return _check(data[part], next_parts)
+            elif isinstance(data, (list, tuple)) and part.isdigit():
+                index = int(part)
+                return 0 <= index < len(data) and _check(data[index], next_parts)
+            
+            return False
+        
+        return _check(self.data, parts)
+    
+    def _apply_rule(self, field: str, value: Any, rule: ValidationRule) -> bool:
+        try:
+            rule.set_validator(self)
+            
+            # Format field name untuk pesan error (otomatis tangkap path aktual)
+            display_field = getattr(self, '_current_actual_path', field)
+            
+            if not rule.validate(field, value, getattr(rule, 'params', [])):
+                msg = rule.message(display_field, getattr(rule, 'params', []))
+                self.error_handler.add_error(display_field, rule.rule_name, msg, value)
+                return False
+            else:
+                return True
+        except Exception as e:
+            display_field = getattr(self, '_current_actual_path', field)
+            self.error_handler.add_error(display_field, rule.rule_name, str(e), value)
+            return False
+
+    def _get_nested_value(self, path: str) -> Any:
+        parts = path.split('.')
+        
+        def _get(data: Any, remaining_parts: List[str]) -> Any:
+            if not remaining_parts:
+                return data
+                
+            part = remaining_parts[0]
+            next_parts = remaining_parts[1:]
+            
+            if part == '*':
+                if isinstance(data, (list, tuple)):
+                    return [_get(item, next_parts) for item in data]
+                elif isinstance(data, dict):
+                    return [_get(value, next_parts) for value in data.values()]
+                return None
+            
+            if isinstance(data, dict) and part in data:
+                return _get(data[part], next_parts)
+            elif isinstance(data, (list, tuple)) and part.isdigit():
+                index = int(part)
+                if 0 <= index < len(data):
+                    return _get(data[index], next_parts)
+            
+            return None
+        
+        result = _get(self.data, parts)
+        
+        # Flatten only one level for wildcard results
+        if isinstance(result, list):
+            flat_result = []
+            for item in result:
+                if isinstance(item, list):
+                    flat_result.extend(item)
+                elif item is not None:
+                    flat_result.append(item)
+            return flat_result if flat_result else None
+        
+        return result
+    
+    def add_rule(self, field: str, rules: Union[str, List[Union[str, ValidationRule]], ValidationRule]):
+        """Add new rules to a field"""
+        new_rules = self.rule_preparer._convert_to_rules(rules)
+        existing_rules = self.rule_preparer._convert_to_rules(self._raw_rules.get(field, []))
+        combined_rules = existing_rules + new_rules
+        
+        RuleConflictChecker.check_conflicts(combined_rules)
+        self._raw_rules[field] = self.rule_preparer._deduplicate_rules(combined_rules)
+
+    def set_stop_on_first_failure(self, value: bool) -> None:
+        """Set whether to stop validation after first failure"""
+        self._stop_on_first_failure = value
+
+    @property
+    def errors(self) -> Dict[str, List[str]]:
+        """Get current validation errors"""
+        return self.error_handler.errors
+
+    @property
+    def has_errors(self) -> bool:
+        """Check if there are any validation errors"""
+        return self.error_handler.has_errors

validator/database/__init__.py

@@ -0,0 +1,5 @@
+
+from .detector import DatabaseAutoDetector
+from .manager import DatabaseManager
+
+__all__ = ['DatabaseDetector', 'DatabaseManager']

validator/database/detector.py

@@ -0,0 +1,250 @@
+import os
+import inspect
+import warnings
+from typing import Dict, Any, Optional
+from urllib.parse import urlparse
+
+class DatabaseAutoDetector:
+    @classmethod
+    def detect(cls) -> Optional[Dict[str, Any]]:
+        """Main detection method that tries all available detectors"""
+        detectors = [
+            cls._detect_odoo,
+            cls._detect_django,
+            cls._detect_flask_env,
+            cls._detect_sqlalchemy,
+            cls._detect_env_vars
+        ]
+
+        for detector in detectors:
+            try:
+                config = detector()
+                if config:
+                    if cls._validate_config(config):
+                        return config
+            except Exception as e:
+                print(f"Warning: Detector {detector.__name__} failed: {str(e)}")
+                continue
+
+        print("No database configuration detected!")
+        return None
+
+    @classmethod
+    def _validate_config(cls, config: Dict[str, Any]) -> bool:
+        """Validate the detected configuration for all database types"""
+        required_keys = ['type', 'host', 'database']
+        
+        # Daftar tipe database yang membutuhkan username
+        requires_username = [
+            'postgresql', 'mysql', 'mariadb', 'mssql', 
+            'oracle', 'cockroachdb', 'redshift'
+        ]
+        
+        # SQLite adalah kasus khusus
+        if config.get('type') == 'sqlite':
+            return 'database' in config
+        
+        # Validasi untuk database lainnya
+        if not all(key in config for key in required_keys):
+            return False
+        
+        # Periksa username untuk database yang membutuhkannya
+        if config['type'] in requires_username and 'username' not in config:
+            return False
+            
+        return True
+    
+    @classmethod
+    def _detect_odoo(cls) -> Optional[Dict[str, Any]]:
+        """Detect Odoo database configuration"""
+        try:
+            from odoo.tools import config
+            return {
+                'type': 'postgresql',  # Odoo selalu menggunakan PostgreSQL
+                'host': config['db_host'] or 'localhost',
+                'port': str(config['db_port'] or 5432),
+                'username': config['db_user'] or 'odoo',
+                'password': config['db_password'] or '',
+                'database': config['db_name']
+            }
+        except ImportError:
+            try:
+                # Cara 2: Deteksi melalui environment variables Odoo
+                db_name = os.getenv('ODOO_DATABASE') or os.getenv('DB_NAME')
+                if db_name:
+                    return {
+                        'type': 'postgresql',
+                        'host': os.getenv('DB_HOST', 'localhost'),
+                        'port': os.getenv('DB_PORT', '5432'),
+                        'username': os.getenv('DB_USER', 'odoo'),
+                        'password': os.getenv('DB_PASSWORD', ''),
+                        'database': db_name
+                    }
+            except Exception:
+                pass
+        return None
+
+    @classmethod
+    def _detect_django(cls) -> Optional[Dict[str, Any]]:
+        try:
+            from django.conf import settings
+            db = settings.DATABASES['default']
+            engine = db['ENGINE'].split('.')[-1]
+            
+            engine_map = {
+                'postgresql': 'postgresql',
+                'mysql': 'mysql',
+                'sqlite3': 'sqlite'
+            }
+            
+            return {
+                'type': engine_map.get(engine, engine),
+                'host': db.get('HOST', 'localhost'),
+                'port': db.get('PORT', '5432' if engine == 'postgresql' else '3306'),
+                'username': db['USER'],
+                'password': db['PASSWORD'],
+                'database': db['NAME']
+            }
+        except ImportError:
+            return None
+        except Exception:  # Tangkap error spesifik Django
+            return None
+
+    @classmethod
+    def _detect_sqlalchemy(cls) -> Optional[Dict[str, Any]]:
+        try:
+            from sqlalchemy import create_engine
+            from sqlalchemy.engine.url import make_url
+            
+            # Cari engine SQLAlchemy di stack frame
+            for frame in inspect.stack():
+                for val in frame.frame.f_locals.values():
+                    if isinstance(val, type(create_engine('sqlite://'))):  # type: ignore
+                        url = make_url(str(val.url))
+                        return {
+                            'type': url.drivername.split('+')[0],
+                            'host': url.host or 'localhost',
+                            'port': str(url.port) if url.port else '5432' if 'postgres' in url.drivername else '3306',
+                            'username': url.username,
+                            'password': url.password or '',
+                            'database': url.database
+                        }
+            return None
+        except ImportError:
+            return None
+
+    @classmethod
+    def _detect_env_vars(cls) -> Optional[Dict[str, Any]]:
+        from dotenv import load_dotenv
+        load_dotenv()
+            
+        standard_vars = {
+            'DB_TYPE': os.getenv('DB_TYPE'),
+            'DB_HOST': os.getenv('DB_HOST'),
+            'DB_USER': os.getenv('DB_USER'),
+            'DB_PASSWORD': os.getenv('DB_PASSWORD'),
+            'DB_NAME': os.getenv('DB_NAME')
+        }
+        
+        if any(standard_vars.values()):
+            return {
+                'type': standard_vars['DB_TYPE'] or 'mysql',
+                'host': standard_vars['DB_HOST'] or 'localhost',
+                'username': standard_vars['DB_USER'] or 'root',
+                'password': standard_vars['DB_PASSWORD'] or '',
+                'database': standard_vars['DB_NAME'] or ''
+            }
+        return None
+    
+    @classmethod
+    def _detect_flask_env(cls) -> Optional[Dict[str, Any]]:
+        """Deteksi konfigurasi database dari Flask app"""
+        try:
+            from flask import current_app
+            if not current_app or not hasattr(current_app, 'config'):
+                return None
+
+            # Handle Flask-SQLAlchemy
+            if 'SQLALCHEMY_DATABASE_URI' in current_app.config:
+                uri = current_app.config['SQLALCHEMY_DATABASE_URI']
+                return cls._parse_sqlalchemy_uri(uri)
+            
+            # Handle Flask default database config
+            elif 'DATABASE_URL' in current_app.config:
+                uri = current_app.config['DATABASE_URL']
+                return cls._parse_sqlalchemy_uri(uri)
+            
+            # Handle Flask-MySQLdb
+            elif 'MYSQL_DATABASE_HOST' in current_app.config:
+                return {
+                    'type': 'mysql',
+                    'host': current_app.config.get('MYSQL_DATABASE_HOST', 'localhost'),
+                    'port': current_app.config.get('MYSQL_DATABASE_PORT', 3306),
+                    'username': current_app.config.get('MYSQL_DATABASE_USER', 'root'),
+                    'password': current_app.config.get('MYSQL_DATABASE_PASSWORD', ''),
+                    'database': current_app.config.get('MYSQL_DATABASE_DB', '')
+                }
+            return None
+        except (ImportError, RuntimeError):
+            return None
+
+    @classmethod
+    def _parse_sqlalchemy_uri(cls, uri: str) -> Dict[str, Any]:
+        """Parse SQLAlchemy URI format"""
+        from urllib.parse import urlparse
+        parsed = urlparse(uri)
+        
+        # Mapping database types
+        db_type_map = {
+            'postgres': 'postgresql',
+            'postgresql': 'postgresql',
+            'mysql': 'mysql',
+            'sqlite': 'sqlite',
+            'mssql': 'mssql'
+        }
+        
+        db_type = db_type_map.get(parsed.scheme.split('+')[0], parsed.scheme)
+        
+        config = {
+            'type': db_type,
+            'host': parsed.hostname or 'localhost',
+            'port': parsed.port or (5432 if db_type == 'postgresql' else 3306),
+            'username': parsed.username or '',
+            'password': parsed.password or '',
+            'database': parsed.path[1:] if parsed.path else ''
+        }
+        
+        # Handle SQLite special case
+        if db_type == 'sqlite':
+            config['database'] = parsed.path  # Full path termasuk leading slash
+            
+        return config
+    
+    @classmethod
+    def _parse_rails_env_vars(cls) -> Optional[Dict[str, Any]]:
+        """Parse Rails-style ENV variables"""
+        def get_env(key, default=None):
+            return os.getenv(key) or os.getenv(f'DATABASE_{key}', default)
+
+        adapter = get_env('ADAPTER')
+        if not adapter:
+            return None
+
+        # Mapping adapter Rails
+        adapter_map = {
+            'postgresql': 'postgresql',
+            'mysql2': 'mysql',
+            'sqlite3': 'sqlite'
+        }
+
+        db_type = adapter_map.get(adapter, adapter)
+
+        return {
+            'type': db_type,
+            'host': get_env('HOST', 'localhost'),
+            'port': int(get_env('PORT', 5432 if db_type == 'postgresql' else 3306)),
+            'username': get_env('USERNAME', 'root'),
+            'password': get_env('PASSWORD', ''),
+            'database': get_env('DATABASE', ''),
+            'timeout': int(get_env('TIMEOUT', '5000'))
+        }