create-autostack 1.0.0

package/templates/backend/FLASK/MONGODB/models.py

@@ -0,0 +1,16 @@
+from bson import ObjectId
+
+def serialize_user(doc):
+    return {
+        "id": str(doc.get("_id")),
+        "username": doc.get("username"),
+        "email": doc.get("email"),
+    }
+
+
+def serialize_note(doc):
+    return {
+        "id": str(doc.get("_id")),
+        "title": doc.get("title"),
+        "content": doc.get("content"),
+    }

package/templates/backend/FLASK/MONGODB/requirements.txt

@@ -0,0 +1,6 @@
+Flask==3.0.0
+flask-cors==4.0.0
+pymongo==4.6.1
+Flask-PyMongo==2.3.0
+python-dotenv==1.0.0
+pydantic==2.5.3

package/templates/backend/FLASK/MONGODB/routes.py

@@ -0,0 +1,137 @@
+from flask import request, jsonify
+from MDB_config import app, db
+from models import serialize_user, serialize_note
+from bson import ObjectId
+
+@app.route("/autostack", methods=["GET"]) 
+def autostack():
+    message = """ 
+        Congrats! You have successfully set up your full-stack project!
+        If you're reading this message, it means your frontend and backend are completely connected!
+        You are ready to create your next big project!
+"""
+    return jsonify({"message": message, "backend": "Flask", "database": "MongoDB", "filepath": 'backend/main.py'}), 200
+
+# Example User REST APIs
+@app.route("/get-users", methods=["GET"])
+def get_users():
+    users = list(db.users.find())
+    json_users = [serialize_user(u) for u in users]
+    return jsonify({"users": json_users}), 200
+
+@app.route("/create-user", methods=["POST"])
+def create_user():
+    username = request.json.get("username")
+    email = request.json.get("email")
+    if not username or not email:
+        return jsonify({"message": "Missing fields"}), 400
+
+    # optional uniqueness check
+    if db.users.find_one({"$or": [{"username": username}, {"email": email}] } ): 
+        return jsonify({"message": "User with same username or email already exists"}), 400
+
+    res = db.users.insert_one({"username": username, "email": email})
+    return jsonify({"message": "New User Created", "id": str(res.inserted_id)}), 201
+
+
+@app.route("/update-users/<user_id>", methods=["PATCH"])
+def update_user(user_id):
+    try:
+        _id = ObjectId(user_id)
+    except Exception:
+        return jsonify({"message": "Invalid user id"}), 400
+
+    data = request.json
+    if not data:
+        return jsonify({"message": "No data provided"}), 400
+
+    update = {}
+    if "username" in data:
+        update["username"] = data["username"]
+    if "email" in data:
+        update["email"] = data["email"]
+
+    if not update:
+        return jsonify({"message": "No valid fields to update"}), 400
+
+    result = db.users.update_one({"_id": _id}, {"$set": update})
+    if result.matched_count == 0:
+        return jsonify({"message": "User not found"}), 404
+
+    return jsonify({"message": "User Updated"}), 200
+
+
+@app.route("/delete-user/<user_id>", methods=["DELETE"])
+def delete_user(user_id):
+    try:
+        _id = ObjectId(user_id)
+    except Exception:
+        return jsonify({"message": "Invalid user id"}), 400
+
+    result = db.users.delete_one({"_id": _id})
+    if result.deleted_count == 0:
+        return jsonify({"message": "User not found"}), 404
+
+    return jsonify({"message": "User Deleted"}), 200
+
+
+# Example Notes REST APIs
+@app.route("/get-notes", methods=["GET"])
+def get_notes():
+    notes = list(db.notes.find())
+    json_notes = [serialize_note(n) for n in notes]
+    return jsonify({"notes": json_notes}), 200
+
+@app.route("/create-note", methods=["POST"])
+def create_note():
+    title = request.json.get("title")
+    content = request.json.get("content")
+    if not title or not content:
+        return jsonify({"message": "Missing fields"}), 400
+
+    if db.notes.find_one({"title": title}):
+        return jsonify({"message": "Note with same title already exists"}), 400
+
+    res = db.notes.insert_one({"title": title, "content": content})
+    return jsonify({"message": "New Note Created", "id": str(res.inserted_id)}), 201
+
+
+@app.route("/update-notes/<note_id>", methods=["PATCH"])
+def update_note(note_id):
+    try:
+        _id = ObjectId(note_id)
+    except Exception:
+        return jsonify({"message": "Invalid note id"}), 400
+
+    data = request.json
+    if not data:
+        return jsonify({"message": "No data provided for updation"}), 400
+
+    update = {}
+    if "title" in data:
+        update["title"] = data["title"]
+    if "content" in data:
+        update["content"] = data["content"]
+
+    if not update:
+        return jsonify({"message": "No valid fields to update"}), 400
+
+    result = db.notes.update_one({"_id": _id}, {"$set": update})
+    if result.matched_count == 0:
+        return jsonify({"message": "Note not found"}), 404
+
+    return jsonify({"message": "Note Updated"}), 200
+
+
+@app.route("/delete-note/<note_id>", methods=["DELETE"])
+def delete_note(note_id):
+    try:
+        _id = ObjectId(note_id)
+    except Exception:
+        return jsonify({"message": "Invalid note id"}), 400
+
+    result = db.notes.delete_one({"_id": _id})
+    if result.deleted_count == 0:
+        return jsonify({"message": "Note not found"}), 404
+
+    return jsonify({"message": "Note Deleted"}), 200

package/templates/backend/FLASK/MYSQL/.env

@@ -0,0 +1,7 @@
+# MySQL configuration
+# Replace the values below with your MySQL server credentials
+DB_USER=your_mysql_user
+DB_PASSWORD=your_mysql_password
+DB_HOST=localhost
+DB_PORT=3306
+DB_NAME=example_db

package/templates/backend/FLASK/MYSQL/config.py

@@ -0,0 +1,24 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from flask_cors import CORS
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+# MySQL connection via environment variables. Example URI:
+# mysql+pymysql://<user>:<password>@<host>:<port>/<dbname>
+DB_USER = os.getenv("DB_USER", "root") # default value
+DB_PASSWORD = os.getenv("DB_PASSWORD", "")
+DB_HOST = os.getenv("DB_HOST", "localhost")
+DB_PORT = os.getenv("DB_PORT", "3306")
+DB_NAME = os.getenv("DB_NAME", "example_db")
+
+app.config['SQLALCHEMY_DATABASE_URI'] = (
+    f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+)
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+db = SQLAlchemy(app)

package/templates/backend/FLASK/MYSQL/main.py

@@ -0,0 +1,8 @@
+from config import app, db
+from routes import *  
+
+if __name__ == "__main__":
+    # with app.app_context(): // Uncomment this after your database is ready to connect 
+    #     db.create_all()
+    app.run(debug=True, port=5000)
+

package/templates/backend/FLASK/MYSQL/models.py

@@ -0,0 +1,26 @@
+from config import db
+
+class User(db.Model): 
+    id = db.Column(db.Integer, primary_key = True)
+    username = db.Column(db.String(80), unique=True, nullable=False)
+    email = db.Column(db.String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "username": self.username,
+            "email": self.email
+        }
+    
+
+class Note(db.Model): 
+    id = db.Column(db.Integer, primary_key = True)
+    title = db.Column(db.String(80), unique=True, nullable=False)
+    content = db.Column(db.String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "title": self.title,
+            "content": self.content
+        }

package/templates/backend/FLASK/MYSQL/requirements.txt

@@ -0,0 +1,6 @@
+Flask==3.0.0
+flask-cors==4.0.0
+Flask-SQLAlchemy==3.1.1
+PyMySQL==1.1.0
+python-dotenv==1.0.0
+Flask-Migrate==4.0.5

package/templates/backend/FLASK/MYSQL/routes.py

@@ -0,0 +1,135 @@
+
+from flask import request, jsonify
+from config import app, db
+from models import User, Note
+
+@app.route("/autostack", methods=["GET"]) 
+def autostack():
+    message = """ 
+        Congrats! You have successfully set up your full-stack project!
+        If you're reading this message, it means your frontend and backend are completely connected!
+        You are ready to create your next big project!
+"""
+    return jsonify({"message": message, "backend": "Flask", "database": "MySQL", "filepath": 'backend/main.py'}), 200
+
+# Example user REST APIs
+@app.route("/get-users", methods=["GET"])
+def get_users():
+    users = User.query.all()
+    json_users = list(map(lambda x: x.to_json(), users))
+    return jsonify({"users": json_users}), 200
+
+@app.route("/create-user", methods=["POST"])
+def create_user():
+    username = request.json.get("username")
+    email = request.json.get("email")
+    
+    if not username or not email:
+        return(jsonify({"message": "Missing fields"})), 400
+    
+    new_user = User(username=username, email=email)
+    try:
+        db.session.add(new_user)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+    
+    return jsonify({"message": "New User Created"}), 201
+    
+
+@app.route("/update-users/<int:user_id>", methods=["PATCH"])
+def update_user(user_id):
+    user = User.query.get(user_id)
+    if not user:
+        return jsonify({"message": "User not found"}), 404
+    data = request.json
+    if not data:
+        return jsonify({"message": "No data provided"}), 400
+    
+    if "username" in data:
+        user.username = data["username"]
+    if "email" in data:
+        user.email = data["email"]
+
+    try:
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "User Updated"}), 200
+
+
+@app.route("/delete-user/<int:user_id>", methods=["DELETE"])
+def delete_user(user_id):
+    user = User.query.get(user_id)
+    if not user:
+        return jsonify({"message": "User not found"}), 404
+    try:
+        db.session.delete(user)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "User Deleted"}), 200
+
+
+# Example Notes REST APIs
+@app.route("/get-notes", methods=["GET"])
+def get_notes():
+    notes = Note.query.all()
+    json_notes = list(map(lambda x: x.to_json(), notes))
+    return jsonify({"notes": json_notes}), 200
+
+@app.route("/create-note", methods=["POST"])
+def create_note():
+    title = request.json.get("title")
+    content = request.json.get("content")
+    
+    if not title or not content:
+        return(jsonify({"message": "Missing fields"})), 400
+    
+    new_note = Note(title=title, content=content)
+    try:
+        db.session.add(new_note)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+    
+    return jsonify({"message": "New Note Created"}), 201
+    
+
+@app.route("/update-notes/<int:note_id>", methods=["PATCH"])
+def update_note(note_id):
+    note = Note.query.get(note_id)
+    if not note:
+        return jsonify({"message": "Note not found"}), 404
+    data = request.json
+    
+    if not data:
+        return jsonify({"message": "No data provided for updation"})
+    
+    if "title" in data:
+        note.title = data["title"]
+    if "content" in data:
+        note.content = data["content"]
+
+    try:
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "User Updated"}), 200
+
+
+@app.route("/delete-note/<int:note_id>", methods=["DELETE"])
+def delete_note(note_id):
+    note = Note.query.get(note_id)
+    if not note:
+        return jsonify({"message": "Note not found"}), 404
+    try:
+        db.session.delete(note)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "Note Deleted"}), 200

package/templates/backend/FLASK/POSTGRESQL/.env

@@ -0,0 +1,5 @@
+DB_USER=postgres
+DB_PASSWORD=
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=example_db

package/templates/backend/FLASK/POSTGRESQL/config.py

@@ -0,0 +1,24 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from flask_cors import CORS
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+# PostgreSQL connection via environment variables. Example URI:
+# postgresql+psycopg2://<user>:<password>@<host>:<port>/<dbname>
+DB_USER = os.getenv("DB_USER", "postgres")
+DB_PASSWORD = os.getenv("DB_PASSWORD", "")
+DB_HOST = os.getenv("DB_HOST", "localhost")
+DB_PORT = os.getenv("DB_PORT", "5432")
+DB_NAME = os.getenv("DB_NAME", "example_db")
+
+app.config['SQLALCHEMY_DATABASE_URI'] = (
+    f"postgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+)
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+db = SQLAlchemy(app)

package/templates/backend/FLASK/POSTGRESQL/main.py

@@ -0,0 +1,7 @@
+from config import app, db
+from routes import *
+
+if __name__ == "__main__":
+    # with app.app_context(): // Uncomment this after your database is ready to connect 
+    #     db.create_all()
+    app.run(debug=True, port=5000)

package/templates/backend/FLASK/POSTGRESQL/models.py

@@ -0,0 +1,26 @@
+from config import db
+
+class User(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False)
+    email = db.Column(db.String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "username": self.username,
+            "email": self.email,
+        }
+
+
+class Note(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String(80), unique=True, nullable=False)
+    content = db.Column(db.String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "title": self.title,
+            "content": self.content,
+        }

package/templates/backend/FLASK/POSTGRESQL/requirements.txt

@@ -0,0 +1,6 @@
+Flask==3.0.0
+flask-cors==4.0.0
+Flask-SQLAlchemy==3.1.1
+psycopg2-binary==2.9.9
+python-dotenv==1.0.0
+Flask-Migrate==4.0.5

package/templates/backend/FLASK/POSTGRESQL/routes.py

@@ -0,0 +1,134 @@
+from flask import request, jsonify
+from config import app, db
+from models import User, Note
+
+@app.route("/autostack", methods=["GET"]) 
+def autostack():
+    message = """ 
+        Congrats! You have successfully set up your full-stack project!
+        If you're reading this message, it means your frontend and backend are completely connected!
+        You are ready to create your next big project!
+"""
+    return jsonify({"message": message, "backend": "Flask", "database": "PostgreSQL", "filepath": 'backend/main.py'}), 200
+
+# These are example user REST APIs
+@app.route("/get-users", methods=["GET"])
+def get_users():
+    users = User.query.all()
+    json_users = list(map(lambda x: x.to_json(), users))
+    return jsonify({"users": json_users}), 200
+
+@app.route("/create-user", methods=["POST"])
+def create_user():
+    username = request.json.get("username")
+    email = request.json.get("email")
+    
+    if not username or not email:
+        return(jsonify({"message": "Missing fields"})), 400
+    
+    new_user = User(username=username, email=email)
+    try:
+        db.session.add(new_user)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+    
+    return jsonify({"message": "New User Created"}), 201
+    
+
+@app.route("/update-users/<int:user_id>", methods=["PATCH"])
+def update_user(user_id):
+    user = User.query.get(user_id)
+    if not user:
+        return jsonify({"message": "User not found"}), 404
+    data = request.json
+    if not data:
+        return jsonify({"message": "No data provided"}), 400
+    
+    if "username" in data:
+        user.username = data["username"]
+    if "email" in data:
+        user.email = data["email"]
+
+    try:
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "User Updated"}), 200
+
+
+@app.route("/delete-user/<int:user_id>", methods=["DELETE"])
+def delete_user(user_id):
+    user = User.query.get(user_id)
+    if not user:
+        return jsonify({"message": "User not found"}), 404
+    try:
+        db.session.delete(user)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "User Deleted"}), 200
+
+
+# These are examples notes REST APIs
+@app.route("/get-notes", methods=["GET"])
+def get_notes():
+    notes = Note.query.all()
+    json_notes = list(map(lambda x: x.to_json(), notes))
+    return jsonify({"notes": json_notes}), 200
+
+@app.route("/create-note", methods=["POST"])
+def create_note():
+    title = request.json.get("title")
+    content = request.json.get("content")
+    
+    if not title or not content:
+        return(jsonify({"message": "Missing fields"})), 400
+    
+    new_note = Note(title=title, content=content)
+    try:
+        db.session.add(new_note)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+    
+    return jsonify({"message": "New Note Created"}), 201
+    
+
+@app.route("/update-notes/<int:note_id>", methods=["PATCH"])
+def update_note(note_id):
+    note = Note.query.get(note_id)
+    if not note:
+        return jsonify({"message": "Note not found"}), 404
+    data = request.json
+    
+    if not data:
+        return jsonify({"message": "No data provided for updation"})
+    
+    if "title" in data:
+        note.title = data["title"]
+    if "content" in data:
+        note.content = data["content"]
+
+    try:
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "User Updated"}), 200
+
+
+@app.route("/delete-note/<int:note_id>", methods=["DELETE"])
+def delete_note(note_id):
+    note = Note.query.get(note_id)
+    if not note:
+        return jsonify({"message": "Note not found"}), 404
+    try:
+        db.session.delete(note)
+        db.session.commit()
+    except Exception as e:
+        return jsonify({"message": str(e)}), 400
+
+    return jsonify({"message": "Note Deleted"}), 200

package/templates/backend/NODEJS/MONGODB/config/dbConn.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+
+export const connectDB = async () => {
+    try {
+        await mongoose.connect(process.env.MONGO_URI);
+        console.log('MONGODB connected successfully!');
+    } catch (error) {
+        console.error("Error connecting to MongoDB: ", error);
+        process.exit(1);
+    }
+}

package/templates/backend/NODEJS/MONGODB/controllers/noteController.js

@@ -0,0 +1,79 @@
+import { Note } from "../models/noteModel.js"
+import mongoose from "mongoose"
+
+// Get All Notes
+export const getAllNotes = async (req, res) => {
+    try {
+        const notes = await Note.find();
+        res.status(200).json(notes);
+    } catch (error) {
+        res.status(500).json({error: error.message});
+    }
+}
+
+// Get A Single Note
+export const getNoteByID = async (req, res) => {
+    try {
+        const { id } = req.params;
+        if (!mongoose.Types.ObjectId.isValid(id)) {
+            return res.status(404).json({message: "Note not found!"})
+        }
+        const note = await Note.findById(id);
+        if (!note) {
+            return res.status(404).json({message: "Note not found!"})
+        }
+        res.status(200).json(note);
+    } catch (error) {
+        res.status(500).json({error: error.message});
+    }
+}
+
+// Create A Note
+export const createNote = async (req, res) => {
+    try {
+        const {title, content} = req.body;
+        if (!title || !content) {
+            return res.status(400).json({message: "Please fill in all the fields"})
+        }
+        const newNote = new Note({title, content});
+        const savedNote = await newNote.save();
+        res.status(201).json({message: "Note created successfully", createdNote: savedNote});
+    } catch (error) {
+        res.status(500).json({message: "Error creating note", error: error.message});
+    }
+}
+
+
+// Update Note
+export const updateNote = async (req, res) => {
+    try {
+        const {title, content} = req.body;
+        const updatedNote = await Note.findByIdAndUpdate(
+            req.params.id,
+            {
+                title, 
+                content
+            },
+            {
+                new: true  // Returns the updated note
+            }
+        )
+        if (!updatedNote) return res.status(404).json({message: "Note not found!"});
+        res.status(200).json({message: "Note updated successfully", updatedNote: updatedNote});
+    } catch (error) {
+        res.status(500).json({message: "Error updating note", error: error.message});
+    }
+}
+
+
+// Delete Note
+export const deleteNote = async (req, res) => {
+    try {
+        const deletedNote = await Note.findByIdAndDelete(req.params.id);
+        if (!deletedNote) return res.status(404).json({message: "Note not found"});
+        res.status(200).json({message: "Note deleted successfully", deletedNote});
+    } catch (error) {
+        res.status(500).json({message: "Error deleting note", error: error.message});
+    }
+}
+