Simple tools to create RESTful backend API based on TorToiseORM and Starlette stack.

The main goal of the project is to provide easy-to-use tools for creating simple backend applications, inspired by Django REST based on:

• TorTosie ORM https://github.com/tortoise/tortoise-orm
• Starlette https://www.starlette.io/

The project provides:

• Serializer
• View

Tool similar to Django REST Serializer, which purpose is to:

• interface with the database model while performing CRUD operations Provide save, update and delete method.
• data serialization Provide methods to serialize model instance into dict, dict to model instance.
• data validation Validates data integrity against the model class. Inside serializer it is possible to enclose custom validation logic by adding validation methods.
• defining access to model attributes provides the ability to define the available fields of the database model.
• creating dynamic model attributes Provide ability to define custom property methods for model that's are dynamic calculate.

Tool similar to Django REST ModelViewSet, which purpose is to:

• provide basic views for CRUD operations. View implement GET, POST, PATCH, DELETE methods OOTB
• provide ability to define queryset access. Inside view we can assign queryset which will be used

Definition based on Django REST. Each Seriliazier must have a defined model and fields to operate on. These definitions must be inside the Meta class.

from tortoise_rest_utils.serializer import Serializer


class SampleSerializer(Serializer):
    class Meta:
            model = SampleModel
            fields = ('attribute_1', 'attribute_2')

Each value inside fields must be part od model attribute or belongs to serialized methods. We can define read only custom model properties by using methods like:

class SampleSerializer(Serializer):
    class Meta:
            model = SampleModel
            fields = (attribute_1', 'attribute_2', 'serialized_attribute')
            
    async def get_serialized_attribute(self):
        return 'Foo'

Methods that start with 'get_' are handled like model properties in pattern: 'get_<field_name>'. After creating serialized attribute You should inlcude field_name in fields. Each serialized attribute is corutine.

It is possible to create custom validation method for field from model attributes:

class SampleSerializer(Serializer):
    class Meta:
            model = SampleModel
            fields = (attribute_1', 'attribute_2')
            
    async def validate_attribute_1(self, data):
        if data is not 'Foo':
            return False

Methods that start with 'validate_' are handled like validators to model attribute in pattern: 'validate_<field_name>'. During validation Serializer pass initial data into each validator method. Each validator method is corutine.

It is possible to create foreign key slug field:

class SampleSerializer(Serializer):
    sample_slug = ForeignKeyField(slug_field='foo',
                                  queryset=lambda: Model.all(),
                                  many=False)

class Meta:
    model = SampleModel
    fields = (attribute_1', 'attribute_2', 'sample_slug')