Merge pull request #7 from LexianDEV/copilot/fix-b2ef1dad-ec82-42a2-9d48-7a4afb775120

Replace .env file with bundled JSON configuration system

Author: Lexian-droid

.env.example

@@ -5,7 +5,8 @@ This Python template includes a Laravel-inspired configuration system that allow
 ## Features
 
 - **Multiple Config Files**: Organize your configuration into separate Python files (e.g., `app.py`)
-- **Environment Overrides**: Use `.env` file or environment variables to override config values
+- **JSON Configuration**: Use `config.json` file for non-sensitive settings that get bundled into the application
+- **Environment Overrides**: Use environment variables to override config values
 - **Dot Notation Access**: Access nested configuration using dot notation (e.g., `app.name`, `app.logging.level`)
 - **Runtime Changes**: Modify configuration values at runtime for testing or dynamic behavior
 - **Helper Functions**: Easy-to-use helper functions for common config operations
@@ -30,22 +31,44 @@ if helpers.has_config('app.name'):
 all_app_config = helpers.get_all_config('app')
 ```
 
+### JSON Configuration Overrides
+
+JSON configuration takes precedence over config files but environment variables still override everything. The `config.json` file is bundled into the application when built and contains non-sensitive settings:
+
+- `app.name` → `APP_NAME` in JSON
+- `app.response_number` → `APP_RESPONSE_NUMBER` in JSON  
+- `app.logging.level` → `APP_LOGGING_LEVEL` in JSON
+
+Example `config.json` file:
+```json
+{
+  "APP_NAME": "My Custom App",
+  "APP_ENV": "development", 
+  "APP_DEBUG": true,
+  "APP_RESPONSE_NUMBER": 100,
+  "APP_MESSAGE": "Hello from the environment!",
+  "APP_LOGGING_LEVEL": "DEBUG"
+}
+```
+
 ### Environment Variable Overrides
 
-Environment variables take precedence over config files. Use uppercase and underscores:
+Environment variables take highest precedence over both JSON config and config files. Use uppercase and underscores:
 
 - `app.name` → `APP_NAME`
 - `app.response_number` → `APP_RESPONSE_NUMBER`
 - `app.logging.level` → `APP_LOGGING_LEVEL`
 
-Example `.env` file:
+Example environment variables:
 ```bash
-APP_NAME=My Custom App
-APP_DEBUG=true
-APP_RESPONSE_NUMBER=100
-APP_MESSAGE=Hello from the environment!
+export APP_NAME="My Custom App"
+export APP_DEBUG=true
+export APP_RESPONSE_NUMBER=100
+export APP_MESSAGE="Hello from the environment!"
 ```
 
+**Note:** The bundled `config.json` file provides application defaults and is automatically extracted and cleaned up when the application runs. Environment variables can still be used to override any setting at runtime.
+
 ### Runtime Configuration Changes
 
 ```python
@@ -94,7 +117,7 @@ cache = {
 from config_manager import ConfigManager
 
 # Create a custom config manager
-config = ConfigManager(config_dir="custom_config", env_file="custom.env")
+config = ConfigManager(config_dir="custom_config", json_file="custom_config.json")
 
 # Use the manager directly
 value = config.get('custom.setting', 'default')
@@ -112,10 +135,13 @@ value = helpers.env('app.name')  # Falls back to config if no env var
 ## Best Practices
 
 1. **Organize by Feature**: Create separate config files for different aspects (database, mail, cache, etc.)
-2. **Use Environment Variables**: For sensitive data and environment-specific settings
-3. **Provide Defaults**: Always provide sensible default values
-4. **Document Settings**: Add comments to explain complex configuration options
-5. **Validate Config**: Add validation for critical configuration values in your application startup
+2. **Use JSON for Non-Sensitive Defaults**: Store application defaults in `config.json` that get bundled with the application
+3. **Use Environment Variables**: For sensitive data and environment-specific settings
+4. **Provide Defaults**: Always provide sensible default values
+5. **Document Settings**: Add comments to explain complex configuration options
+6. **Validate Config**: Add validation for critical configuration values in your application startup
+
+**Security Note**: The `config.json` file is bundled into the application and can be viewed by anyone with access to the built executable. Only store non-sensitive configuration in this file. Use environment variables for sensitive data like API keys, passwords, and secrets.
 
 ## Example: Full Configuration Workflow
 

CONFIG.md

@@ -5,7 +5,7 @@ a = Analysis(
     ['main.py'],
     pathex=[],
     binaries=[],
-    datas=[],
+    datas=[('config.json', '.')],
     hiddenimports=[],
     hookspath=[],
     hooksconfig={},

build.spec

@@ -0,0 +1,9 @@
+{
+  "APP_NAME": "My Custom App",
+  "APP_VERSION": "1.0.0",
+  "APP_ENV": "development",
+  "APP_DEBUG": true,
+  "APP_RESPONSE_NUMBER": 100,
+  "APP_MESSAGE": "Hello from the environment!",
+  "APP_LOGGING_LEVEL": "DEBUG"
+}

config.json

@@ -4,32 +4,67 @@
 """
 
 import os
+import sys
+import json
 import importlib.util
 from typing import Any, Dict, Optional
 from pathlib import Path
+import tempfile
+import shutil
 
 
 class ConfigManager:
     """Manages application configuration with support for multiple config files and environment overrides."""
 
-    def __init__(self, config_dir: str = "config", env_file: str = ".env"):
+    def __init__(self, config_dir: str = "config", json_file: str = "config.json"):
         self.config_dir = Path(config_dir)
-        self.env_file = Path(env_file)
+        self.json_file = Path(json_file)
         self._config_cache: Dict[str, Dict[str, Any]] = {}
-        self._env_vars: Dict[str, str] = {}
+        self._json_vars: Dict[str, Any] = {}
+        self._extracted_json_path: Optional[Path] = None
 
-        # Load environment variables from .env file
-        self._load_env_file()
+        # Load configuration from JSON file
+        self._load_json_file()
 
-    def _load_env_file(self) -> None:
-        """Load environment variables from .env file if it exists."""
-        if self.env_file.exists():
-            with open(self.env_file, 'r') as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith('#') and '=' in line:
-                        key, value = line.split('=', 1)
-                        self._env_vars[key.strip()] = value.strip().strip('"').strip("'")
+    def _load_json_file(self) -> None:
+        """Load configuration from JSON file. If bundled, extract it temporarily."""
+        json_path = self.json_file
+        
+        # Check if this is a bundled application (PyInstaller)
+        if hasattr(sys, '_MEIPASS'):
+            # Extract JSON from bundled resources to a temporary location
+            bundled_json = Path(sys._MEIPASS) / self.json_file.name
+            if bundled_json.exists():
+                # Create a temporary file
+                temp_fd, temp_path = tempfile.mkstemp(suffix='.json')
+                os.close(temp_fd)
+                
+                # Copy the bundled JSON to temp location
+                shutil.copy2(bundled_json, temp_path)
+                json_path = Path(temp_path)
+                self._extracted_json_path = json_path
+        
+        # Load the JSON file if it exists
+        if json_path.exists():
+            try:
+                with open(json_path, 'r', encoding='utf-8') as f:
+                    self._json_vars = json.load(f)
+            except (json.JSONDecodeError, IOError) as e:
+                print(f"Warning: Could not load JSON config file {json_path}: {e}")
+                self._json_vars = {}
+    
+    def __del__(self):
+        """Clean up extracted JSON file when the ConfigManager is destroyed."""
+        self._cleanup_extracted_json()
+    
+    def _cleanup_extracted_json(self) -> None:
+        """Delete the extracted JSON file if it exists."""
+        if hasattr(self, '_extracted_json_path') and self._extracted_json_path and self._extracted_json_path.exists():
+            try:
+                self._extracted_json_path.unlink()
+                self._extracted_json_path = None
+            except OSError:
+                pass  # Ignore cleanup errors
 
     def _load_config_file(self, config_name: str) -> Dict[str, Any]:
         """Load a specific config file."""
@@ -56,24 +91,23 @@ def _load_config_file(self, config_name: str) -> Dict[str, Any]:
     def get(self, key: str, default: Any = None) -> Any:
         """
         Get a configuration value using dot notation (e.g., 'app.name' or 'database.host').
-        Environment variables take precedence over config files.
+        JSON configuration takes precedence over config files.
+        Environment variables take precedence over everything.
         """
-        # Check for environment variable override first
+        # Check for environment variable override first (highest priority)
         env_key = key.upper().replace('.', '_')
-        if env_key in self._env_vars:
-            value = self._env_vars[env_key]
-            # Convert string boolean values
-            if value.lower() in ('true', 'false'):
-                return value.lower() == 'true'
-            return value
         if env_key in os.environ:
             value = os.environ[env_key]
             # Convert string boolean values
             if value.lower() in ('true', 'false'):
                 return value.lower() == 'true'
             return value
+        
+        # Check for JSON config override (second priority)
+        if env_key in self._json_vars:
+            return self._json_vars[env_key]
 
-        # Parse the key to get config file and setting
+        # Parse the key to get config file and setting (lowest priority)
         if '.' not in key:
             return default
 
@@ -124,7 +158,9 @@ def reload(self, config_name: Optional[str] = None) -> None:
                 del self._config_cache[config_name]
         else:
             self._config_cache.clear()
-            self._load_env_file()
+            # Clean up old extracted JSON and reload
+            self._cleanup_extracted_json()
+            self._load_json_file()
 
     def all(self, config_name: str) -> Dict[str, Any]:
         """Get all configuration values for a specific config file."""

config_manager.py

@@ -24,7 +24,7 @@ async def show_app_info(self):
         """Display application information."""
         # Get basic app configuration
         app_name = helpers.get_config('app.name', 'Unknown App')
-        app_version = helpers.get_config('app.version', '0.0.0')
+        app_version = helpers.get_config('app.version', '1.0.0')
         app_env = helpers.get_config('app.env', 'unknown')
         app_debug = helpers.get_config('app.debug', False)
 

modules/display.py

@@ -15,7 +15,7 @@ It was developed by LexianDEV
 This template includes a powerful configuration system inspired by Laravel. You can:
 
 - Define configuration in Python files (`config/app.py`, `config/database.py`, etc.)
-- Override settings with environment variables or `.env` file
+- Override settings with JSON configuration or environment variables
 - Access configuration using dot notation: `helpers.get_config('app.name')`
 - Modify configuration at runtime for testing
 

readme.md

@@ -47,9 +47,9 @@ def test_config_loading():
         print("✓ Config file loading works")
 
 
-def test_env_overrides():
-    """Test environment variable overrides."""
-    print("Testing environment overrides...")
+def test_json_overrides():
+    """Test JSON configuration overrides."""
+    print("Testing JSON configuration overrides...")
 
     with tempfile.TemporaryDirectory() as temp_dir:
         config_dir = Path(temp_dir) / "config"
@@ -62,21 +62,23 @@ def test_env_overrides():
 debug = False
 """)
 
-        # Create .env file
-        env_file = Path(temp_dir) / ".env"
-        env_file.write_text("""
-APP_NAME=Override App
-APP_DEBUG=true
+        # Create JSON config file
+        json_file = Path(temp_dir) / "config.json"
+        json_file.write_text("""
+{
+    "APP_NAME": "Override App",
+    "APP_DEBUG": true
+}
 """)
 
         # Test config manager
-        manager = ConfigManager(config_dir=str(config_dir), env_file=str(env_file))
+        manager = ConfigManager(config_dir=str(config_dir), json_file=str(json_file))
 
-        # Test environment overrides
+        # Test JSON overrides
         assert manager.get('app.name') == "Override App"
         assert manager.get('app.debug') == True
 
-        print("✓ Environment overrides work")
+        print("✓ JSON configuration overrides work")
 
 
 def test_runtime_config_changes():
@@ -93,8 +95,8 @@ def test_runtime_config_changes():
 name = "Original App"
 """)
 
-        # Test config manager with no .env file
-        manager = ConfigManager(config_dir=str(config_dir), env_file="/nonexistent/.env")
+        # Test config manager with no JSON file
+        manager = ConfigManager(config_dir=str(config_dir), json_file="/nonexistent/config.json")
 
         # Test runtime changes
         original_name = manager.get('app.name')
@@ -110,6 +112,44 @@ def test_runtime_config_changes():
         print("✓ Runtime config changes work")
 
 
+def test_bundled_json_extraction():
+    """Test JSON extraction and cleanup for bundled applications."""
+    print("Testing bundled JSON extraction and cleanup...")
+    
+    with tempfile.TemporaryDirectory() as temp_dir:
+        config_dir = Path(temp_dir) / "config"
+        config_dir.mkdir()
+        
+        # Create a test config file
+        test_config = config_dir / "app.py"
+        test_config.write_text("""
+name = "Original App"
+debug = False
+""")
+        
+        # Create JSON config file
+        json_file = Path(temp_dir) / "config.json"
+        json_file.write_text("""
+{
+    "APP_NAME": "Bundled App",
+    "APP_DEBUG": true
+}
+""")
+        
+        # Test config manager
+        manager = ConfigManager(config_dir=str(config_dir), json_file=str(json_file))
+        
+        # Test JSON loading
+        assert manager.get('app.name') == "Bundled App"
+        assert manager.get('app.debug') == True
+        
+        # Test cleanup - the manager should properly initialize without extracted path
+        # since this is not a bundled environment
+        assert manager._extracted_json_path is None
+        
+        print("✓ Bundled JSON extraction and cleanup work")
+
+
 def test_helpers_integration():
     """Test helper functions."""
     print("Testing helper functions...")
@@ -133,8 +173,9 @@ def run_tests():
 
     try:
         test_config_loading()
-        test_env_overrides()
+        test_json_overrides()
         test_runtime_config_changes()
+        test_bundled_json_extraction()
         test_helpers_integration()
 
         print("\n✅ All tests passed!")