app.py

from flask import Flask, render_template, request, jsonify
import json
import re

app = Flask(__name__)

# Path format configurations
PATH_FORMATS = {
    'postgresql': {'separator': '->', 'key_format': "'{}'", 'index_format': '{}', 'prefix': ''},
    'javascript': {'separator': '.', 'key_format': '{}', 'index_format': '[{}]', 'prefix': ''},
    'python': {'separator': '', 'key_format': "['{}']", 'index_format': '[{}]', 'prefix': ''},
    'jsonpath': {'separator': '.', 'key_format': '{}', 'index_format': '[{}]', 'prefix': '$'}
}

@app.route('/', methods=['GET', 'POST'])
def index():
    return render_template('index.html')

@app.route('/format_json', methods=['POST'])
def format_json():
    try:
        data = request.json.get('data', '')
        if not data.strip():
            return jsonify({'error': 'No JSON data provided'}), 400
        parsed = json.loads(data)
        formatted_json = json.dumps(parsed, indent=2)
        return jsonify({'formatted': formatted_json, 'valid': True})
    except json.JSONDecodeError as e:
        error_msg = f"Invalid JSON at line {e.lineno}, column {e.colno}: {e.msg}"
        return jsonify({'error': error_msg, 'line': e.lineno, 'column': e.colno}), 400

@app.route('/validate_json', methods=['POST'])
def validate_json():
    """Validate JSON without formatting - returns validation status"""
    try:
        data = request.json.get('data', '')
        if not data.strip():
            return jsonify({'valid': False, 'error': 'No JSON data provided'})
        json.loads(data)
        return jsonify({'valid': True})
    except json.JSONDecodeError as e:
        error_msg = f"Line {e.lineno}, column {e.colno}: {e.msg}"
        return jsonify({'valid': False, 'error': error_msg, 'line': e.lineno, 'column': e.colno})

@app.route('/search_json', methods=['POST'])
def search_json():
    data = request.json.get('data', '')
    search_term = request.json.get('search_term', '').lower()
    path_format = request.json.get('path_format', 'postgresql')
    custom_config = request.json.get('custom_config', None)
    
    if not data.strip():
        return jsonify({'error': 'No JSON data provided'}), 400
    if not search_term:
        return jsonify({'error': 'No search term provided'}), 400
    
    # Use custom config if provided, otherwise use preset formats
    if path_format == 'custom' and custom_config:
        format_config = {
            'separator': custom_config.get('separator', '->'),
            'key_format': custom_config.get('key_format', "'{}'"),
            'index_format': custom_config.get('index_format', '{}'),
            'prefix': custom_config.get('prefix', '')
        }
    else:
        format_config = PATH_FORMATS.get(path_format, PATH_FORMATS['postgresql'])

    def format_path(path_parts):
        """Convert path parts to the selected format"""
        if not path_parts:
            return format_config['prefix'] or 'root'
        
        result = format_config['prefix']
        for i, part in enumerate(path_parts):
            if part['type'] == 'key':
                formatted_part = format_config['key_format'].format(part['value'])
            else:  # index
                formatted_part = format_config['index_format'].format(part['value'])
            
            # Add separator logic
            if format_config['separator'] and result and result != format_config['prefix']:
                # For formats like python where index doesn't need separator
                if path_format == 'python' or (path_format in ['javascript', 'jsonpath'] and part['type'] == 'index'):
                    result += formatted_part
                else:
                    result += format_config['separator'] + formatted_part
            else:
                result += formatted_part
        
        return result

    def search_with_path(obj, term, path=None):
        results = []
        matches = []

        if path is None:
            path = []

        if isinstance(obj, dict):
            for key, value in obj.items():
                new_path = path + [{'type': 'key', 'value': key}]
                if term in key.lower():
                    results.append({'path': format_path(new_path)})
                    matches.append({'value': key, 'path': format_path(new_path)})
                if isinstance(value, (dict, list)):
                    sub_results, sub_matches = search_with_path(value, term, new_path)
                    results.extend(sub_results)
                    matches.extend(sub_matches)
                elif term in str(value).lower():
                    results.append({'path': format_path(new_path)})
                    matches.append({'value': str(value), 'path': format_path(new_path)})
        elif isinstance(obj, list):
            for i, item in enumerate(obj):
                new_path = path + [{'type': 'index', 'value': i}]
                if isinstance(item, (dict, list)):
                    sub_results, sub_matches = search_with_path(item, term, new_path)
                    results.extend(sub_results)
                    matches.extend(sub_matches)
                elif term in str(item).lower():
                    results.append({'path': format_path(new_path)})
                    matches.append({'value': str(item), 'path': format_path(new_path)})
        return results, matches

    try:
        json_data = json.loads(data)
        search_results, matches = search_with_path(json_data, search_term)
        return jsonify({'results': search_results, 'matches': matches})
    except json.JSONDecodeError as e:
        error_msg = f"Invalid JSON at line {e.lineno}, column {e.colno}: {e.msg}"
        return jsonify({'error': error_msg}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)