Add FastAPI REST API with SQLite database

- Set up project structure
- Add database models and SQLAlchemy setup
- Configure Alembic for migrations
- Create API endpoints for items
- Add health check endpoint
- Update documentation

generated with BackendIM... (backend.im)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Automated Action 2025-05-15 22:33:58 +00:00
parent 97bdba2174
commit b00b44023a
24 changed files with 675 additions and 2 deletions

View File

@ -1,3 +1,91 @@
# FastAPI Application
# Generic REST API Service
This is a FastAPI application bootstrapped by BackendIM, the AI-powered backend generation platform.
A modern, production-ready REST API service built with FastAPI and SQLite.
## Features
- FastAPI framework for high performance
- SQLAlchemy ORM with SQLite database
- Alembic migrations
- Pydantic for data validation
- Automatic API documentation (Swagger UI and ReDoc)
- Health check endpoint
- CRUD operations for items
- Project structure optimized for scaling
## Getting Started
### Prerequisites
- Python 3.8+
- Git
### Installation
1. Clone the repository:
```bash
git clone <repository-url>
cd genericrestapiservice
```
2. Create a virtual environment and activate it:
```bash
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
```
3. Install dependencies:
```bash
pip install -r requirements.txt
```
4. Run migrations:
```bash
alembic upgrade head
```
5. Start the application:
```bash
uvicorn main:app --reload
```
The API will be available at http://localhost:8000
## API Documentation
- Swagger UI: http://localhost:8000/docs
- ReDoc: http://localhost:8000/redoc
## Project Structure
```
.
├── alembic/ # Database migrations
│ ├── versions/ # Migration versions
│ ├── env.py # Alembic environment
│ └── script.py.mako # Migration script template
├── app/ # Application package
│ ├── api/ # API endpoints
│ │ ├── v1/ # API v1
│ │ │ └── endpoints/ # API endpoints by resource
│ │ └── api.py # API router setup
│ ├── core/ # Core application code
│ │ └── config.py # Application configuration
│ ├── crud/ # CRUD operations
│ ├── database/ # Database setup
│ │ └── session.py # DB session management
│ ├── models/ # SQLAlchemy models
│ └── schemas/ # Pydantic schemas
├── alembic.ini # Alembic configuration
├── main.py # Application entry point
└── requirements.txt # Project dependencies
```
## API Endpoints
- `GET /api/v1/health`: Health check endpoint
- `GET /api/v1/items`: List all items
- `POST /api/v1/items`: Create a new item
- `GET /api/v1/items/{item_id}`: Get a specific item
- `PUT /api/v1/items/{item_id}`: Update a specific item
- `DELETE /api/v1/items/{item_id}`: Delete a specific item

102
alembic.ini Normal file
View File

@ -0,0 +1,102 @@
# A generic, single database configuration.
[alembic]
# path to migration scripts
script_location = alembic
# template used to generate migration files
# file_template = %%(rev)s_%%(slug)s
# sys.path path, will be prepended to sys.path if present.
# defaults to the current working directory.
prepend_sys_path = .
# timezone to use when rendering the date within the migration file
# as well as the filename.
# If specified, requires the python-dateutil library that can be
# installed by adding `alembic[tz]` to the pip requirements
# string value is passed to dateutil.tz.gettz()
# leave blank for localtime
# timezone =
# max length of characters to apply to the
# "slug" field
# truncate_slug_length = 40
# set to 'true' to run the environment during
# the 'revision' command, regardless of autogenerate
# revision_environment = false
# set to 'true' to allow .pyc and .pyo files without
# a source .py file to be detected as revisions in the
# versions/ directory
# sourceless = false
# version location specification; This defaults
# to alembic/versions. When using multiple version
# directories, initial revisions must be specified with --version-path.
# The path separator used here should be the separator specified by "version_path_separator" below.
# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
# version path separator; As mentioned above, this is the character used to split
# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
# Valid values for version_path_separator are:
#
# version_path_separator = :
# version_path_separator = ;
# version_path_separator = space
version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
# the output encoding used when revision files
# are written from script.py.mako
# output_encoding = utf-8
sqlalchemy.url = sqlite:////app/storage/db/db.sqlite
[post_write_hooks]
# post_write_hooks defines scripts or Python functions that are run
# on newly generated revision scripts. See the documentation for further
# detail and examples
# format using "black" - use the console_scripts runner, against the "black" entrypoint
# hooks = black
# black.type = console_scripts
# black.entrypoint = black
# black.options = -l 79 REVISION_SCRIPT_FILENAME
# Logging configuration
[loggers]
keys = root,sqlalchemy,alembic
[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
[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

80
alembic/env.py Normal file
View File

@ -0,0 +1,80 @@
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from alembic import context
# This is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basically.
fileConfig(config.config_file_name)
# Add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
from app.database.session import Base
from app.models import Item
target_metadata = Base.metadata
# Other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection, target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()

24
alembic/script.py.mako Normal file
View File

@ -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"}

View File

@ -0,0 +1,39 @@
"""create items table
Revision ID: 001
Revises:
Create Date: 2025-05-15
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '001'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# Create items table
op.create_table(
'items',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('name', sa.String(), nullable=False),
sa.Column('description', sa.String(), nullable=True),
sa.Column('is_active', sa.Boolean(), nullable=False, default=True),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)')),
sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_items_id'), 'items', ['id'], unique=False)
op.create_index(op.f('ix_items_name'), 'items', ['name'], unique=False)
def downgrade():
# Drop items table
op.drop_index(op.f('ix_items_name'), table_name='items')
op.drop_index(op.f('ix_items_id'), table_name='items')
op.drop_table('items')

0
app/__init__.py Normal file
View File

0
app/api/__init__.py Normal file
View File

35
app/api/api.py Normal file
View File

@ -0,0 +1,35 @@
from fastapi import FastAPI, APIRouter
from fastapi.middleware.cors import CORSMiddleware
from app.core.config import settings
from app.api.v1.endpoints import health, items
# Create FastAPI app
app = FastAPI(
title=settings.PROJECT_NAME,
description=settings.DESCRIPTION,
version=settings.VERSION,
openapi_url=f"{settings.API_V1_STR}/openapi.json",
docs_url="/docs",
redoc_url="/redoc",
)
# Set up CORS
if settings.BACKEND_CORS_ORIGINS:
app.add_middleware(
CORSMiddleware,
allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# Create API router
api_router = APIRouter()
# Include routers from endpoints
api_router.include_router(health.router, prefix="/health", tags=["health"])
api_router.include_router(items.router, prefix="/items", tags=["items"])
# Add API router to app
app.include_router(api_router, prefix=settings.API_V1_STR)

0
app/api/v1/__init__.py Normal file
View File

View File

View File

@ -0,0 +1,25 @@
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from app.database.session import get_db
router = APIRouter()
@router.get("", response_model=dict)
def health_check(db: Session = Depends(get_db)):
"""
Health check endpoint to verify API and database are working
"""
try:
# Check if DB connection is working
db.execute("SELECT 1")
return {
"status": "ok",
"message": "API is healthy and database connection is working"
}
except Exception as e:
return {
"status": "error",
"message": f"Database connection failed: {str(e)}"
}

View File

@ -0,0 +1,93 @@
from typing import Any, List, Optional
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from app import crud
from app.database.session import get_db
from app.schemas.item import Item, ItemCreate, ItemUpdate
router = APIRouter()
@router.get("", response_model=List[Item])
def read_items(
db: Session = Depends(get_db),
skip: int = 0,
limit: int = 100,
) -> Any:
"""
Retrieve items.
"""
items = crud.get_multi(db, skip=skip, limit=limit)
return items
@router.post("", response_model=Item)
def create_item(
*,
db: Session = Depends(get_db),
item_in: ItemCreate,
) -> Any:
"""
Create new item.
"""
item = crud.create(db=db, obj_in=item_in)
return item
@router.get("/{item_id}", response_model=Item)
def read_item(
*,
db: Session = Depends(get_db),
item_id: int,
) -> Any:
"""
Get item by ID.
"""
item = crud.get(db=db, item_id=item_id)
if not item:
raise HTTPException(
status_code=404,
detail="Item not found",
)
return item
@router.put("/{item_id}", response_model=Item)
def update_item(
*,
db: Session = Depends(get_db),
item_id: int,
item_in: ItemUpdate,
) -> Any:
"""
Update an item.
"""
item = crud.get(db=db, item_id=item_id)
if not item:
raise HTTPException(
status_code=404,
detail="Item not found",
)
item = crud.update(db=db, db_obj=item, obj_in=item_in)
return item
@router.delete("/{item_id}", response_model=Item)
def delete_item(
*,
db: Session = Depends(get_db),
item_id: int,
) -> Any:
"""
Delete an item.
"""
item = crud.get(db=db, item_id=item_id)
if not item:
raise HTTPException(
status_code=404,
detail="Item not found",
)
item = crud.remove(db=db, item_id=item_id)
return item

0
app/core/__init__.py Normal file
View File

26
app/core/config.py Normal file
View File

@ -0,0 +1,26 @@
from pydantic_settings import BaseSettings
from pathlib import Path
class Settings(BaseSettings):
API_V1_STR: str = "/api/v1"
PROJECT_NAME: str = "Generic REST API Service"
DESCRIPTION: str = "A generic REST API service built with FastAPI and SQLite"
VERSION: str = "0.1.0"
# CORS
BACKEND_CORS_ORIGINS: list[str] = ["*"]
# Server settings
HOST: str = "0.0.0.0"
PORT: int = 8000
RELOAD: bool = True
# Database
DB_DIR = Path("/app") / "storage" / "db"
class Config:
case_sensitive = True
settings = Settings()

1
app/crud/__init__.py Normal file
View File

@ -0,0 +1 @@
from app.crud.item import get, get_by_name, get_multi, create, update, remove # noqa

52
app/crud/item.py Normal file
View File

@ -0,0 +1,52 @@
from typing import List, Optional
from sqlalchemy.orm import Session
from app.models.item import Item
from app.schemas.item import ItemCreate, ItemUpdate
def get(db: Session, item_id: int) -> Optional[Item]:
return db.query(Item).filter(Item.id == item_id).first()
def get_by_name(db: Session, name: str) -> Optional[Item]:
return db.query(Item).filter(Item.name == name).first()
def get_multi(
db: Session, *, skip: int = 0, limit: int = 100
) -> List[Item]:
return db.query(Item).offset(skip).limit(limit).all()
def create(db: Session, *, obj_in: ItemCreate) -> Item:
db_obj = Item(
name=obj_in.name,
description=obj_in.description,
is_active=obj_in.is_active,
)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def update(
db: Session, *, db_obj: Item, obj_in: ItemUpdate
) -> Item:
update_data = obj_in.model_dump(exclude_unset=True)
for field in update_data:
setattr(db_obj, field, update_data[field])
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def remove(db: Session, *, item_id: int) -> Optional[Item]:
obj = db.query(Item).get(item_id)
if obj:
db.delete(obj)
db.commit()
return obj

0
app/database/__init__.py Normal file
View File

29
app/database/session.py Normal file
View File

@ -0,0 +1,29 @@
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from app.core.config import settings
# Create directory if it doesn't exist
settings.DB_DIR.mkdir(parents=True, exist_ok=True)
SQLALCHEMY_DATABASE_URL = f"sqlite:///{settings.DB_DIR}/db.sqlite"
engine = create_engine(
SQLALCHEMY_DATABASE_URL,
connect_args={"check_same_thread": False}
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
def get_db():
"""
Dependency for getting DB session
"""
db = SessionLocal()
try:
yield db
finally:
db.close()

1
app/models/__init__.py Normal file
View File

@ -0,0 +1 @@
from app.models.item import Item # noqa

15
app/models/item.py Normal file
View File

@ -0,0 +1,15 @@
from sqlalchemy import Column, Integer, String, Boolean, DateTime
from sqlalchemy.sql import func
from app.database.session import Base
class Item(Base):
__tablename__ = "items"
id = Column(Integer, primary_key=True, index=True)
name = Column(String, index=True)
description = Column(String, nullable=True)
is_active = Column(Boolean, default=True)
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), onupdate=func.now())

1
app/schemas/__init__.py Normal file
View File

@ -0,0 +1 @@
from app.schemas.item import Item, ItemCreate, ItemUpdate, ItemInDB # noqa

42
app/schemas/item.py Normal file
View File

@ -0,0 +1,42 @@
from datetime import datetime
from typing import Optional
from pydantic import BaseModel
# Shared properties
class ItemBase(BaseModel):
name: str
description: Optional[str] = None
is_active: Optional[bool] = True
# Properties to receive on item creation
class ItemCreate(ItemBase):
pass
# Properties to receive on item update
class ItemUpdate(ItemBase):
name: Optional[str] = None
is_active: Optional[bool] = None
# Properties shared by models stored in DB
class ItemInDBBase(ItemBase):
id: int
created_at: datetime
updated_at: Optional[datetime] = None
class Config:
from_attributes = True
# Properties to return to client
class Item(ItemInDBBase):
pass
# Properties stored in DB
class ItemInDB(ItemInDBBase):
pass

11
main.py Normal file
View File

@ -0,0 +1,11 @@
import uvicorn
from app.core.config import settings
from app.api.api import app
if __name__ == "__main__":
uvicorn.run(
"main:app",
host=settings.HOST,
port=settings.PORT,
reload=settings.RELOAD,
)

9
requirements.txt Normal file
View File

@ -0,0 +1,9 @@
fastapi==0.109.0
uvicorn==0.27.0
sqlalchemy==2.0.25
alembic==1.13.1
pydantic==2.5.3
pydantic-settings==2.1.0
python-multipart==0.0.6
email-validator==2.1.0
ruff==0.2.0