fastrecord 0.1.1

A Rails-like ORM for FastAPI using SQLModel

FastRecord

A Rails-like ORM for FastAPI using SQLModel, bringing Active Record pattern to Python.

Version Compatibility

FastRecord	Python	FastAPI	SQLModel	Redis
0.1.x	≥3.9	≥0.115.5	≥0.0.22	≥5.2.0

Requirements

• Python: 3.9 or higher required for modern typing features and performance improvements
• FastAPI: 0.115.5 or higher for middleware and dependency injection features
• SQLModel: 0.0.22 or higher for ORM functionality
• Redis: 5.2.0 or higher (with hiredis) for caching support
• Pydantic Settings: 2.6.1 or higher for configuration management
• Inflect: 7.4.0 or higher for naming conventions

[Previous README content remains the same...]

Features

• Active Record pattern implementation
• Chainable query interface
• Built-in caching with Redis/memory support
• Callbacks (before/after save, create, update, destroy)
• Validations
• Relationship management (has_many, belongs_to, has_one)
• Soft deletes
• Pagination
• Eager loading

Installation

pip install fastrecord

Quick Start

from fastrecord import FastRecord, Field
from typing import Optional, List
from datetime import datetime


class User(FastRecord):
    name: str = Field(...)
    email: str = Field(...)
    posts: List["Post"] = []


class Post(FastRecord):
    title: str = Field(...)
    content: str = Field(...)
    author_id: Optional[int] = Field(default=None, foreign_key="user.id")
    author: Optional[User] = None


# Create
user = User.create(name="John", email="[e-mail]")

# Query
user = User.where(name="John").first()
posts = Post.where(author_id=user.id).order("created_at").limit(5).all()

# Update
user.update(name="John Doe")

# Delete
user.delete()  # Soft delete
user.destroy()  # Hard delete

Configuration

from fastrecord import configure

configure(
    DATABASE_URL="postgresql://user:pass@localhost/dbname",
    CACHE_ENABLED=True,
    CACHE_TYPE="redis",
    CACHE_REDIS_URL="redis://localhost:6379/0"
)

FastAPI Integration

from fastapi import FastAPI
from fastrecord import DatabaseMiddleware

app = FastAPI()
app.add_middleware(DatabaseMiddleware)

Validations

from fastrecord.validation import PresenceValidator, FormatValidator


class User(FastRecord):
    name: str = Field(...)
    email: str = Field(...)

    @validates("name", PresenceValidator)
    def validate_name(self):
        pass

    @validates("email", FormatValidator, with_=r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
    def validate_email(self):
        pass

Relationships

class User(FastRecord):
    posts = has_many("Post")
    profile = has_one("Profile")


class Post(FastRecord):
    author = belongs_to("User")

Caching

class User(FastRecord):
    @cached(ttl=3600)
    def expensive_calculation(self):
        # Complex computation
        pass


# Query caching
users = User.where(active=True).cache(ttl=300).all()

License

MIT License. See LICENSE file for details.

Contributing

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Author

Tushar Mangukiya [e-mail]

FastRecord Examples

• Example.md
• Cache Example.md
• Advanced Usage Examples.md