server.py

from pymongo import MongoClient
from flask import Flask, jsonify, request
from bson.objectid import ObjectId
from bson import BSON

port = 27017  # Change to the port mongodb backend is running.
client = MongoClient(f"mongodb://localhost:{port}")
app = Flask(__name__)

@app.route("/")
def home():
    return jsonify({"message": "MongoDB is running"})

@app.route("/create_database", methods=["POST"])
def create_database():
    data = request.get_json()
    if not data or "database_name" not in data:
        return jsonify({"message": "Please provide a database_name"}), 400

    db_name = data["database_name"]
    try:
        db = client[db_name]
        db["init_collection"].insert_one({"init": True})
        db.drop_collection("init_collection")
        return jsonify({"message": f"Database '{db_name}' created successfully"})
    except Exception as e:
        return jsonify({"message": str(e)}), 500

@app.route("/insert_one", methods=["POST"])
def insert_one_endpoint():
    data = request.get_json()
    required_fields = ["database_name", "collection_name", "document"]

    if not data or not all(field in data for field in required_fields):
        return jsonify({"message": f"Please provide {required_fields}"}), 400

    db_name = data["database_name"]
    collection_name = data["collection_name"]
    document = data["document"]

    try:
        db = client[db_name]
        collection = db[collection_name]
        result = collection.insert_one(document)
        return jsonify({"message": "Document inserted successfully", "inserted_id": str(result.inserted_id)})
    except Exception as e:
        return jsonify({"message": str(e)}), 500
    
@app.route("/insert_many", methods=["POST"])
def insert_many_endpoint():
    data = request.get_json()
    required_fields = ["database_name", "collection_name", "documents"]

    if not data or not all(field in data for field in required_fields):
        return jsonify({"message": f"Please provide {required_fields}"}), 400

    db_name = data["database_name"]
    collection_name = data["collection_name"]
    documents = data["documents"]

    try:
        db = client[db_name]
        collection = db[collection_name]
        result = collection.insert_many(documents)
        inserted_ids = [str(_id) for _id in result.inserted_ids]
        return jsonify({"message": "Documents inserted successfully", "inserted_ids": inserted_ids})
    except Exception as e:
        return jsonify({"message": str(e)}), 500

@app.route("/find", methods=["POST"])
def fetch_documents_route():
    """
    Expected JSON data:
    {
        "database": "mydatabase",
        "collection": "mycollection",
        "filter": {"key": "value"}   # optional, default is {}
    }
    """
    data = request.get_json()
    required_fields = ["database", "collection"]

    if not data or not all(field in data for field in required_fields):
        return jsonify({"message": f"Please provide {required_fields}"}), 400

    db_name = data["database"]
    collection_name = data["collection"]
    filter_query = data.get("filter", {})
    
    if '_id' in filter_query and isinstance(filter_query['_id'], str):
        try:
            filter_query['_id'] = ObjectId(filter_query['_id'])
        except Exception:
            return jsonify({"message": "Invalid ObjectId format for _id"}), 400

    try:
        db = client[db_name]
        collection = db[collection_name]
        cursor = collection.find(filter_query)
    
        documents = []
        for doc in cursor:
            doc['_id'] = str(doc['_id'])
            documents.append(doc)
            
        return jsonify({"documents": documents})
    except Exception as e:
        return jsonify({"message": str(e)}), 500

@app.route("/update_one", methods=["POST"])
def update_single_document():
    data = request.get_json()
    required_fields = ["database", "collection", "filter", "update"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    filter_query = data["filter"]
    update_operation = data["update"]
    try:
        db = client[db_name]
        collection = db[collection_name]
        result = collection.update_one(filter_query, update_operation)
        if result.matched_count == 0: return jsonify({"message": "No document matched the filter"})
        return jsonify({"message": "Document updated successfully", "modified_count": result.modified_count})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/delete_one", methods=["POST"])
def delete_single_document():
    data = request.get_json()
    required_fields = ["database", "collection", "filter"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    filter_query = data["filter"]
    try:
        db = client[db_name]
        collection = db[collection_name]
        result = collection.delete_one(filter_query)
        if result.deleted_count == 0: return jsonify({"message": "No document matched the filter"})
        return jsonify({"message": "Document deleted successfully", "deleted_count": result.deleted_count})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/delete_many", methods=["POST"])
def delete_multiple_documents():
    data = request.get_json()
    required_fields = ["database", "collection", "filter"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    filter_query = data["filter"]
    try:
        db = client[db_name]
        collection = db[collection_name]
        result = collection.delete_many(filter_query)
        if result.deleted_count == 0: return jsonify({"message": "No documents matched the filter"})
        return jsonify({"message": "Documents deleted successfully", "deleted_count": result.deleted_count})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/update_many", methods=["POST"])
def update_multiple_documents():
    data = request.get_json()
    required_fields = ["database", "collection", "filter", "update"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    filter_query = data["filter"]
    update_operation = data["update"]
    try:
        db = client[db_name]
        collection = db[collection_name]
        result = collection.update_many(filter_query, update_operation)
        if result.matched_count == 0: return jsonify({"message": "No documents matched the filter"})
        return jsonify({"message": "Documents updated successfully", "matched_count": result.matched_count, "modified_count": result.modified_count})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/drop_collection", methods=["POST"])
def drop_collection_route():
    data = request.get_json()
    required_fields = ["database", "collection"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    try:
        db = client[db_name]
        if collection_name in db.list_collection_names():
            db.drop_collection(collection_name)
            return jsonify({"message": f"Collection '{collection_name}' dropped successfully"})
        return jsonify({"message": f"Collection '{collection_name}' does not exist"})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/list_collections", methods=["POST"])
def list_collections_route():
    data = request.get_json()
    if not data or "database" not in data: return jsonify({"message": "Please provide 'database'"}), 400
    db_name = data["database"]
    try:
        db = client[db_name]
        collections = db.list_collection_names()
        return jsonify({"collections": collections})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/drop_database", methods=["POST"])
def drop_database_route():
    data = request.get_json()
    if not data or "database" not in data: return jsonify({"message": "Please provide 'database'"}), 400
    db_name = data["database"]
    try:
        if db_name in client.list_database_names():
            client.drop_database(db_name)
            return jsonify({"message": f"Database '{db_name}' dropped successfully"})
        return jsonify({"message": f"Database '{db_name}' does not exist"})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/create_index", methods=["POST"])
def create_index_route():
    data = request.get_json()
    required_fields = ["database", "collection", "fields"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    fields = data["fields"]
    unique = data.get("unique", False)
    try:
        db = client[db_name]
        collection = db[collection_name]
        index_name = collection.create_index(fields, unique=unique)
        return jsonify({"message": "Index created successfully", "index_name": index_name})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/list_indexes", methods=["POST"])
def list_indexes_route():
    data = request.get_json()
    required_fields = ["database", "collection"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    try:
        db = client[db_name]
        collection = db[collection_name]
        indexes = list(collection.list_indexes())
        index_list = []
        for index in indexes:
            index_dict = dict(index)
            if 'key' in index_dict:
                index_dict['key'] = dict(index_dict['key'])
            index_list.append(index_dict)
        return jsonify({"indexes": index_list})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/drop_index", methods=["POST"])
def drop_index_route():
    data = request.get_json()
    required_fields = ["database", "collection", "index_name"]
    if not data or not all(field in data for field in required_fields): return jsonify({"message": f"Please provide {required_fields}"}), 400
    db_name = data["database"]
    collection_name = data["collection"]
    index_name = data["index_name"]
    try:
        db = client[db_name]
        collection = db[collection_name]
        collection.drop_index(index_name)
        return jsonify({"message": f"Index '{index_name}' dropped successfully"})
    except Exception as e: return jsonify({"message": str(e)}), 500

@app.route("/get_size", methods=["POST"])
def get_size_route():
    """
    Returns the size in bytes of a database, collection, or a single document.
    - To get DB size: {"database": "db_name"}
    - To get Collection size: {"database": "db_name", "collection": "coll_name"}
    - To get Document size: {"database": "db_name", "collection": "coll_name", "filter": {"_id": "..."}}
    """
    data = request.get_json()
    if not data or "database" not in data:
        return jsonify({"message": "Please provide at least a 'database' name"}), 400

    db_name = data["database"]
    collection_name = data.get("collection")
    filter_query = data.get("filter")

    try:
        db = client[db_name]

        if collection_name and filter_query:
            collection = db[collection_name]
            if '_id' in filter_query and isinstance(filter_query['_id'], str):
                 filter_query['_id'] = ObjectId(filter_query['_id'])

            doc = collection.find_one(filter_query)
            if not doc:
                return jsonify({"message": "Document not found"}), 404
            
            doc_size = len(BSON.encode(doc))
            return jsonify({"target": "document", "size": doc_size, "unit": "bytes"})

        elif collection_name:
            stats = db.command("collstats", collection_name)
            return jsonify({"target": "collection", "size": stats["size"], "count": stats["count"], "unit": "bytes"})

        else:
            stats = db.command("dbstats")
            return jsonify({"target": "database", "size": stats["dataSize"], "unit": "bytes"})

    except Exception as e:
        return jsonify({"message": str(e)}), 500

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