create-autostack 1.0.0

package/templates/backend/FASTAPI/MYSQL/.env

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

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

@@ -0,0 +1,29 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+# MySQL connection via environment variables
+DB_USER = os.getenv("DB_USER", "root")
+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")
+
+DATABASE_URL = f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+
+engine = create_engine(DATABASE_URL, pool_pre_ping=True)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

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

@@ -0,0 +1,32 @@
+from fastapi import FastAPI, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from config import engine, Base
+from routes import router
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    Base.metadata.create_all(bind=engine)
+    yield
+
+app = FastAPI(
+    title="AutoStack API",
+    description="Full-stack API built with FastAPI and MySQL",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust this in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(router)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=5000, reload=True)

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

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, Integer, String
+from config import Base
+
+class User(Base):
+    __tablename__ = "user"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String(80), unique=True, nullable=False, index=True)
+    email = Column(String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "username": self.username,
+            "email": self.email
+        }
+
+
+class Note(Base):
+    __tablename__ = "note"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String(80), unique=True, nullable=False, index=True)
+    content = Column(String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "title": self.title,
+            "content": self.content
+        }

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

@@ -0,0 +1,6 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+sqlalchemy==2.0.25
+pymysql==1.1.0
+python-dotenv==1.0.0
+pydantic[email]==2.5.3

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

@@ -0,0 +1,180 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from config import get_db
+from models import User, Note
+from schemas import (
+    UserCreate, UserUpdate, UserResponse,
+    NoteCreate, NoteUpdate, NoteResponse
+)
+
+router = APIRouter()
+
+@router.get("/", status_code=status.HTTP_200_OK)
+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 {"message": message, "backend": "FastAPI", "database": "PostgreSQL", "filepath": 'backend/main.py'}
+
+
+# Example User REST APIs
+@router.get("/get-users", response_model=dict, status_code=status.HTTP_200_OK)
+def get_users(db: Session = Depends(get_db)):
+    users = db.query(User).all()
+    json_users = [user.to_json() for user in users]
+    return {"users": json_users}
+
+
+@router.post("/create-user", status_code=status.HTTP_201_CREATED)
+def create_user(user: UserCreate, db: Session = Depends(get_db)):
+    new_user = User(username=user.username, email=user.email)
+    try:
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    return {"message": "New User Created"}
+
+
+@router.patch("/update-users/{user_id}", status_code=status.HTTP_200_OK)
+def update_user(user_id: int, user_data: UserUpdate, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.id == user_id).first()
+    
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+    
+    update_data = user_data.model_dump(exclude_unset=True)
+    if not update_data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No data provided"
+        )
+    
+    for field, value in update_data.items():
+        setattr(user, field, value)
+    
+    try:
+        db.commit()
+        db.refresh(user)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "User Updated"}
+
+
+@router.delete("/delete-user/{user_id}", status_code=status.HTTP_200_OK)
+def delete_user(user_id: int, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.id == user_id).first()
+    
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+    
+    try:
+        db.delete(user)
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "User Deleted"}
+
+
+# Example Note REST APIs
+@router.get("/get-notes", response_model=dict, status_code=status.HTTP_200_OK)
+def get_notes(db: Session = Depends(get_db)):
+    notes = db.query(Note).all()
+    json_notes = [note.to_json() for note in notes]
+    return {"notes": json_notes}
+
+
+@router.post("/create-note", status_code=status.HTTP_201_CREATED)
+def create_note(note: NoteCreate, db: Session = Depends(get_db)):
+    new_note = Note(title=note.title, content=note.content)
+    try:
+        db.add(new_note)
+        db.commit()
+        db.refresh(new_note)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    return {"message": "New Note Created"}
+
+
+@router.patch("/update-notes/{note_id}", status_code=status.HTTP_200_OK)
+def update_note(note_id: int, note_data: NoteUpdate, db: Session = Depends(get_db)):
+    note = db.query(Note).filter(Note.id == note_id).first()
+    
+    if not note:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Note not found"
+        )
+    
+    update_data = note_data.model_dump(exclude_unset=True)
+    if not update_data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No data provided for updation"
+        )
+    
+    for field, value in update_data.items():
+        setattr(note, field, value)
+    
+    try:
+        db.commit()
+        db.refresh(note)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "Note Updated"}
+
+
+@router.delete("/delete-note/{note_id}", status_code=status.HTTP_200_OK)
+def delete_note(note_id: int, db: Session = Depends(get_db)):
+    note = db.query(Note).filter(Note.id == note_id).first()
+    
+    if not note:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Note not found"
+        )
+    
+    try:
+        db.delete(note)
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "Note Deleted"}

package/templates/backend/FASTAPI/MYSQL/schemas.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel, EmailStr
+
+# User Schemas
+class UserCreate(BaseModel):
+    username: str
+    email: EmailStr
+
+class UserUpdate(BaseModel):
+    username: str | None = None
+    email: EmailStr | None = None
+
+class UserResponse(BaseModel):
+    id: int
+    username: str
+    email: str
+
+    class Config:
+        from_attributes = True
+
+
+# Note Schemas
+class NoteCreate(BaseModel):
+    title: str
+    content: str
+
+class NoteUpdate(BaseModel):
+    title: str | None = None
+    content: str | None = None
+
+class NoteResponse(BaseModel):
+    id: int
+    title: str
+    content: str
+
+    class Config:
+        from_attributes = True

package/templates/backend/FASTAPI/POSTGRESQL/.env

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

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

@@ -0,0 +1,29 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+# PostgreSQL connection via environment variables
+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")
+
+DATABASE_URL = f"postgresql+psycopg2://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+
+engine = create_engine(DATABASE_URL, pool_pre_ping=True)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

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

@@ -0,0 +1,32 @@
+from fastapi import FastAPI, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from config import engine, Base
+from routes import router
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    Base.metadata.create_all(bind=engine)
+    yield
+
+app = FastAPI(
+    title="AutoStack API",
+    description="Full-stack API built with FastAPI and MySQL",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust this in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(router)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=5000, reload=True)

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

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, Integer, String
+from config import Base
+
+class User(Base):
+    __tablename__ = "user"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String(80), unique=True, nullable=False, index=True)
+    email = Column(String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "username": self.username,
+            "email": self.email
+        }
+
+
+class Note(Base):
+    __tablename__ = "note"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String(80), unique=True, nullable=False, index=True)
+    content = Column(String(120), unique=True, nullable=False)
+
+    def to_json(self):
+        return {
+            "id": self.id,
+            "title": self.title,
+            "content": self.content
+        }

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

@@ -0,0 +1,6 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+sqlalchemy==2.0.25
+psycopg2-binary==2.9.9
+python-dotenv==1.0.0
+pydantic[email]==2.5.3

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

@@ -0,0 +1,180 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+from config import get_db
+from models import User, Note
+from schemas import (
+    UserCreate, UserUpdate, UserResponse,
+    NoteCreate, NoteUpdate, NoteResponse
+)
+
+router = APIRouter()
+
+@router.get("/", status_code=status.HTTP_200_OK)
+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 {"message": message, "backend": "FastAPI", "database": "PostgreSQL", "filepath": 'backend/main.py'}
+
+
+# Example User REST APIs
+@router.get("/get-users", response_model=dict, status_code=status.HTTP_200_OK)
+def get_users(db: Session = Depends(get_db)):
+    users = db.query(User).all()
+    json_users = [user.to_json() for user in users]
+    return {"users": json_users}
+
+
+@router.post("/create-user", status_code=status.HTTP_201_CREATED)
+def create_user(user: UserCreate, db: Session = Depends(get_db)):
+    new_user = User(username=user.username, email=user.email)
+    try:
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    return {"message": "New User Created"}
+
+
+@router.patch("/update-users/{user_id}", status_code=status.HTTP_200_OK)
+def update_user(user_id: int, user_data: UserUpdate, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.id == user_id).first()
+    
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+    
+    update_data = user_data.model_dump(exclude_unset=True)
+    if not update_data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No data provided"
+        )
+    
+    for field, value in update_data.items():
+        setattr(user, field, value)
+    
+    try:
+        db.commit()
+        db.refresh(user)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "User Updated"}
+
+
+@router.delete("/delete-user/{user_id}", status_code=status.HTTP_200_OK)
+def delete_user(user_id: int, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.id == user_id).first()
+    
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+    
+    try:
+        db.delete(user)
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "User Deleted"}
+
+
+# Example Note REST APIs
+@router.get("/get-notes", response_model=dict, status_code=status.HTTP_200_OK)
+def get_notes(db: Session = Depends(get_db)):
+    notes = db.query(Note).all()
+    json_notes = [note.to_json() for note in notes]
+    return {"notes": json_notes}
+
+
+@router.post("/create-note", status_code=status.HTTP_201_CREATED)
+def create_note(note: NoteCreate, db: Session = Depends(get_db)):
+    new_note = Note(title=note.title, content=note.content)
+    try:
+        db.add(new_note)
+        db.commit()
+        db.refresh(new_note)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    return {"message": "New Note Created"}
+
+
+@router.patch("/update-notes/{note_id}", status_code=status.HTTP_200_OK)
+def update_note(note_id: int, note_data: NoteUpdate, db: Session = Depends(get_db)):
+    note = db.query(Note).filter(Note.id == note_id).first()
+    
+    if not note:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Note not found"
+        )
+    
+    update_data = note_data.model_dump(exclude_unset=True)
+    if not update_data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No data provided for updation"
+        )
+    
+    for field, value in update_data.items():
+        setattr(note, field, value)
+    
+    try:
+        db.commit()
+        db.refresh(note)
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "Note Updated"}
+
+
+@router.delete("/delete-note/{note_id}", status_code=status.HTTP_200_OK)
+def delete_note(note_id: int, db: Session = Depends(get_db)):
+    note = db.query(Note).filter(Note.id == note_id).first()
+    
+    if not note:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Note not found"
+        )
+    
+    try:
+        db.delete(note)
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    
+    return {"message": "Note Deleted"}

package/templates/backend/FASTAPI/POSTGRESQL/schemas.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel, EmailStr
+
+# User Schemas
+class UserCreate(BaseModel):
+    username: str
+    email: EmailStr
+
+class UserUpdate(BaseModel):
+    username: str | None = None
+    email: EmailStr | None = None
+
+class UserResponse(BaseModel):
+    id: int
+    username: str
+    email: str
+
+    class Config:
+        from_attributes = True
+
+
+# Note Schemas
+class NoteCreate(BaseModel):
+    title: str
+    content: str
+
+class NoteUpdate(BaseModel):
+    title: str | None = None
+    content: str | None = None
+
+class NoteResponse(BaseModel):
+    id: int
+    title: str
+    content: str
+
+    class Config:
+        from_attributes = True

package/templates/backend/FLASK/MONGODB/.env

@@ -0,0 +1,6 @@
+MONGO_URI=mongodb://myUser:myPassword@host1.example.com:27017/myDatabase
+DB_USER=myUser
+DB_PASSWORD=myPassword
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=myDatabase

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

@@ -0,0 +1,27 @@
+from flask import Flask
+from flask_cors import CORS
+from dotenv import load_dotenv
+import os
+from pymongo import MongoClient
+
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+# MongoDB settings (supports full MONGO_URI or components)
+MONGO_URI = os.getenv("MONGO_URI")
+MDB_USER = os.getenv("DB_USER", "mongodbuser")
+MDB_PASSWORD = os.getenv("DB_PASSWORD", "")
+MDB_HOST = os.getenv("DB_HOST", "localhost")
+MDB_PORT = os.getenv("DB_PORT", "27017")
+MDB_NAME = os.getenv("DB_NAME", os.getenv("DB_NAME", "example_db"))
+
+if not MONGO_URI:
+    if MDB_USER:
+        MONGO_URI = f"mongodb://{MDB_USER}:{MDB_PASSWORD}@{MDB_HOST}:{MDB_PORT}"
+    else:
+        MONGO_URI = f"mongodb://{MDB_HOST}:{MDB_PORT}"
+
+client = MongoClient(MONGO_URI)
+db = client[MDB_NAME]

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

@@ -0,0 +1,5 @@
+from config import app, db
+from routes import *
+
+if __name__ == "__main__":
+    app.run(debug=True, port=5000)