create-flask-react 0.1.0__py3-none-any.whl

create_flask_react/main.py

@@ -0,0 +1,50 @@
+"""CLI entry point for create-flask-react."""
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+TEMPLATE_DIR = Path(__file__).parent / "template"
+IGNORE = shutil.ignore_patterns(
+    ".venv", "node_modules", "__pycache__", "*.pyc", ".env",
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create a new Flask + React project"
+    )
+    parser.add_argument(
+        "project_name",
+        help="Name of the project directory to create (use '.' for current directory)",
+    )
+    args = parser.parse_args()
+
+    if args.project_name == ".":
+        dest = Path.cwd()
+    else:
+        dest = Path.cwd() / args.project_name
+
+    if dest.exists() and args.project_name != ".":
+        if any(dest.iterdir()):
+            print(f"Error: {dest} already exists and is not empty.", file=sys.stderr)
+            sys.exit(1)
+
+    dest.mkdir(parents=True, exist_ok=True)
+
+    shutil.copytree(TEMPLATE_DIR, dest, dirs_exist_ok=True, ignore=IGNORE)
+
+    # Create .env from .env.example
+    env_example = dest / ".env.example"
+    env_file = dest / ".env"
+    if env_example.exists() and not env_file.exists():
+        shutil.copy2(env_example, env_file)
+
+    print(f"Created Flask + React project in {dest.resolve()}")
+    print()
+    print("Next steps:")
+    print(f"  cd {args.project_name}")
+    print("  make dev")
+    print()
+    print("Then open http://localhost:5173 in your browser.")

create_flask_react/template/.env.example

@@ -0,0 +1,10 @@
+# Database
+POSTGRES_USER=app
+POSTGRES_PASSWORD=changeme
+POSTGRES_DB=app
+DATABASE_URL=postgresql://app:changeme@db:5432/app
+
+# Flask
+SECRET_KEY=change-this-to-a-random-secret
+FLASK_ENV=development
+FLASK_DEBUG=1

create_flask_react/template/.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+
+# Node
+node_modules/
+dist/
+
+# Environment
+.env
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Docker
+*.log

create_flask_react/template/Makefile

@@ -0,0 +1,22 @@
+.PHONY: dev stop logs db-migrate db-upgrade shell clean
+
+dev:
+	docker compose up --build
+
+stop:
+	docker compose down
+
+logs:
+	docker compose logs -f
+
+db-migrate:
+	docker compose exec backend uv run flask db migrate
+
+db-upgrade:
+	docker compose exec backend uv run flask db upgrade
+
+shell:
+	docker compose exec backend uv run flask shell
+
+clean:
+	docker compose down -v

create_flask_react/template/backend/.dockerignore

@@ -0,0 +1,3 @@
+.venv
+__pycache__
+*.pyc

create_flask_react/template/backend/Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.12-slim
+WORKDIR /app
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+COPY pyproject.toml uv.lock* ./
+RUN uv sync
+COPY . .

create_flask_react/template/backend/app/__init__.py

@@ -0,0 +1,23 @@
+import os
+from flask import Flask
+from .config import config
+from .extensions import db, migrate, login_manager
+
+
+def create_app():
+    app = Flask(__name__, static_folder="static", static_url_path="/")
+
+    env = os.getenv("FLASK_ENV", "development")
+    app.config.from_object(config[env])
+
+    db.init_app(app)
+    migrate.init_app(app, db)
+    login_manager.init_app(app)
+
+    from .routes import api_bp
+    from .routes.main import main_bp
+
+    app.register_blueprint(api_bp)
+    app.register_blueprint(main_bp)
+
+    return app

create_flask_react/template/backend/app/config.py

@@ -0,0 +1,29 @@
+import os
+
+
+class BaseConfig:
+    SECRET_KEY = os.getenv("SECRET_KEY", "change-this-to-a-random-secret")
+    SQLALCHEMY_DATABASE_URI = os.getenv("DATABASE_URL")
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    SESSION_COOKIE_SAMESITE = "Lax"
+    SESSION_COOKIE_HTTPONLY = True
+
+
+class DevelopmentConfig(BaseConfig):
+    DEBUG = True
+
+
+class ProductionConfig(BaseConfig):
+    DEBUG = False
+
+
+class TestConfig(BaseConfig):
+    TESTING = True
+    SQLALCHEMY_DATABASE_URI = "sqlite:///:memory:"
+
+
+config = {
+    "development": DevelopmentConfig,
+    "production": ProductionConfig,
+    "testing": TestConfig,
+}

create_flask_react/template/backend/app/extensions.py

@@ -0,0 +1,19 @@
+from flask import jsonify
+from flask_login import LoginManager
+from flask_migrate import Migrate
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+migrate = Migrate()
+login_manager = LoginManager()
+
+
+@login_manager.user_loader
+def load_user(user_id):
+    from .models.user import User
+    return db.session.get(User, int(user_id))
+
+
+@login_manager.unauthorized_handler
+def unauthorized():
+    return jsonify({"error": "Authentication required"}), 401

create_flask_react/template/backend/app/models/__init__.py

@@ -0,0 +1,3 @@
+from .user import User
+
+__all__ = ["User"]

create_flask_react/template/backend/app/models/user.py

@@ -0,0 +1,18 @@
+from datetime import datetime, timezone
+from flask_login import UserMixin
+from werkzeug.security import generate_password_hash, check_password_hash
+from ..extensions import db
+
+
+class User(UserMixin, db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    email = db.Column(db.String(255), unique=True, nullable=False, index=True)
+    password_hash = db.Column(db.String(256), nullable=False)
+    is_active = db.Column(db.Boolean, default=True)
+    created_at = db.Column(db.DateTime, default=lambda: datetime.now(timezone.utc))
+
+    def set_password(self, password):
+        self.password_hash = generate_password_hash(password)
+
+    def check_password(self, password):
+        return check_password_hash(self.password_hash, password)

create_flask_react/template/backend/app/routes/__init__.py

@@ -0,0 +1,16 @@
+from flask import Blueprint
+from flask_restx import Api
+
+api_bp = Blueprint("api", __name__, url_prefix="/api")
+
+api = Api(
+    api_bp,
+    version="1.0",
+    title="API",
+    description="Flask + React Starter API",
+    doc="/docs",
+)
+
+from .auth import ns as auth_ns  # noqa: E402
+
+api.add_namespace(auth_ns)

create_flask_react/template/backend/app/routes/auth.py

@@ -0,0 +1,107 @@
+from flask_login import current_user, login_required, login_user, logout_user
+from flask_restx import Namespace, Resource, fields
+from ..extensions import db
+from ..models.user import User
+
+ns = Namespace("auth", description="Authentication")
+
+credentials_model = ns.model("Credentials", {
+    "email": fields.String(required=True, description="User email"),
+    "password": fields.String(required=True, description="User password"),
+})
+
+user_model = ns.model("User", {
+    "id": fields.Integer(description="User ID"),
+    "email": fields.String(description="User email"),
+    "created_at": fields.DateTime(description="Account creation date"),
+})
+
+error_model = ns.model("Error", {
+    "error": fields.String(description="Error message"),
+})
+
+message_model = ns.model("Message", {
+    "message": fields.String(description="Status message"),
+})
+
+
+@ns.route("/register")
+class Register(Resource):
+    @ns.expect(credentials_model)
+    @ns.response(201, "User created", user_model)
+    @ns.response(400, "Validation error", error_model)
+    @ns.response(409, "Email already registered", error_model)
+    def post(self):
+        """Register a new user."""
+        data = ns.payload
+        email = data.get("email")
+        password = data.get("password")
+
+        if not email or not password:
+            return {"error": "Email and password are required"}, 400
+
+        if User.query.filter_by(email=email).first():
+            return {"error": "Email already registered"}, 409
+
+        user = User(email=email)
+        user.set_password(password)
+        db.session.add(user)
+        db.session.commit()
+
+        login_user(user)
+
+        return {
+            "id": user.id,
+            "email": user.email,
+            "created_at": user.created_at.isoformat(),
+        }, 201
+
+
+@ns.route("/login")
+class Login(Resource):
+    @ns.expect(credentials_model)
+    @ns.response(200, "Login successful", user_model)
+    @ns.response(401, "Invalid credentials", error_model)
+    def post(self):
+        """Log in with email and password."""
+        data = ns.payload
+        email = data.get("email")
+        password = data.get("password")
+
+        user = User.query.filter_by(email=email).first()
+
+        if user is None or not user.check_password(password):
+            return {"error": "Invalid email or password"}, 401
+
+        login_user(user)
+
+        return {
+            "id": user.id,
+            "email": user.email,
+            "created_at": user.created_at.isoformat(),
+        }, 200
+
+
+@ns.route("/logout")
+class Logout(Resource):
+    @login_required
+    @ns.response(200, "Logged out", message_model)
+    @ns.response(401, "Not authenticated", error_model)
+    def post(self):
+        """Log out the current user."""
+        logout_user()
+        return {"message": "Logged out"}, 200
+
+
+@ns.route("/me")
+class Me(Resource):
+    @login_required
+    @ns.response(200, "Current user", user_model)
+    @ns.response(401, "Not authenticated", error_model)
+    def get(self):
+        """Get the current authenticated user."""
+        return {
+            "id": current_user.id,
+            "email": current_user.email,
+            "created_at": current_user.created_at.isoformat(),
+        }, 200

create_flask_react/template/backend/app/routes/main.py

@@ -0,0 +1,19 @@
+import os
+from flask import Blueprint, send_from_directory, current_app
+
+main_bp = Blueprint("main", __name__)
+
+
+@main_bp.route("/", defaults={"path": ""})
+@main_bp.route("/<path:path>")
+def serve(path):
+    static_folder = os.path.join(current_app.root_path, "static")
+
+    if path and os.path.exists(os.path.join(static_folder, path)):
+        return send_from_directory(static_folder, path)
+
+    index_path = os.path.join(static_folder, "index.html")
+    if os.path.exists(index_path):
+        return send_from_directory(static_folder, "index.html")
+
+    return "Frontend not built. Run the Vite dev server or build the frontend.", 404

create_flask_react/template/backend/migrations/README

@@ -0,0 +1 @@
+Single-database configuration for Flask.

create_flask_react/template/backend/migrations/alembic.ini

@@ -0,0 +1,40 @@
+[alembic]
+
+[loggers]
+keys = root,sqlalchemy,alembic,flask_migrate
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[logger_flask_migrate]
+level = INFO
+handlers =
+qualname = flask_migrate
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

create_flask_react/template/backend/migrations/env.py

@@ -0,0 +1,69 @@
+import logging
+from logging.config import fileConfig
+
+from flask import current_app
+from alembic import context
+
+config = context.config
+fileConfig(config.config_file_name)
+logger = logging.getLogger("alembic.env")
+
+
+def get_engine():
+    try:
+        return current_app.extensions["migrate"].db.get_engine()
+    except (TypeError, AttributeError):
+        return current_app.extensions["migrate"].db.engine
+
+
+def get_engine_url():
+    try:
+        return (
+            get_engine()
+            .url.render_as_string(hide_password=False)
+            .replace("%", "%%")
+        )
+    except AttributeError:
+        return str(get_engine().url).replace("%", "%%")
+
+
+config.set_main_option("sqlalchemy.url", get_engine_url())
+target_db = current_app.extensions["migrate"].db
+
+
+def get_metadata():
+    if hasattr(target_db, "metadatas"):
+        return target_db.metadatas[None]
+    return target_db.metadata
+
+
+def run_migrations_offline():
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(url=url, target_metadata=get_metadata(), literal_binds=True)
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    def process_revision_directives(context, revision, directives):
+        if getattr(config.cmd_opts, "autogenerate", False):
+            script = directives[0]
+            if script.upgrade_ops.is_empty():
+                directives[:] = []
+                logger.info("No changes in schema detected.")
+
+    connectable = get_engine()
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=get_metadata(),
+            process_revision_directives=process_revision_directives,
+        )
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

create_flask_react/template/backend/migrations/script.py.mako

@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

create_flask_react/template/backend/migrations/versions/001_create_user_table.py

@@ -0,0 +1,32 @@
+"""create user table
+
+Revision ID: 001
+Revises:
+Create Date: 2024-01-01 00:00:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = "001"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "user",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("email", sa.String(length=255), nullable=False),
+        sa.Column("password_hash", sa.String(length=256), nullable=False),
+        sa.Column("is_active", sa.Boolean(), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_user_email"), "user", ["email"], unique=True)
+
+
+def downgrade():
+    op.drop_index(op.f("ix_user_email"), table_name="user")
+    op.drop_table("user")

create_flask_react/template/backend/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "backend"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+    "flask>=3.0",
+    "flask-login>=0.6",
+    "flask-restx>=1.3",
+    "flask-sqlalchemy>=3.1",
+    "flask-migrate>=4.0",
+    "psycopg2-binary>=2.9",
+    "werkzeug>=3.0",
+]