django-rudra 0.1.2

A Django app to query models.

What problem does it solve?

1. It’s a simple django package which can help developers to create APIs faster without writing views.

2. It works quite similar to GraphQL, but it’s not GraphQL. It’s just a simple package which can help you to create APIs with url configurations only.

3. So next time when you want to create an API, you don’t need to write views, you just need to write url configurations.

4. Even frontend folks can create or tweak APIs without writing views.

Setup

1. In urls.py:

   from django.urls import path, include
   
   urlpatterns = [
       path('rudra/', include('rudra.urls')),
   ]

2. In somepath/response.py:

   '''
       Sample success and error response functions
       Configure how you want to return success and error responses
   '''
   
   from typing import Union
   from django.http import JsonResponse
   
   def success_response(data: Union[dict, list], has_next: bool = None) -> JsonResponse:
       '''
           :param data: either dict or list, depending on the response
           :param has_next: if the response is paginated, then this will be True or False
       '''
       return JsonResponse({'data': data, 'status': 'success', 'has_next': has_next})
   
   def error_response(error: Exception) -> JsonResponse:
       return JsonResponse({'error': str(error), 'status': 'error'})

3. In settings.py:

   '''
       Configure Rudra settings
       Register your models with serializer in settings
   '''
   
   from rudra.settings import RudraBaseSettings, RudraMetaSettings, SerializerSettings
   
   # other settings
   ...
   
   INSTALLED_APPS = [
       ...
       'rudra',
   ]
   
   # other settings
   ...
   
   class RudraSettings(RudraBaseSettings):
       success_path = 'somepath/response.success_response'
       error_path = 'somepath/response.error_response'
       user_serializer_path = 'user.serializer.UserSerializer' # Serializer to be used for user model
       fixed_page_number = 9999999 # If you want to set a fixed page number for pagination
   
       # Register your models here
       # You can pass multiple models and their configurations in this list
       meta_settings = [
           RudraMetaSettings(
               model_path='django.contrib.auth.models.User',
               methods_allowed=['get', 'post', 'put', 'patch', 'delete'],
   
               # Either pass serializer_path or map_serializer
               # with map_serializer, you can pass different serializers for different request methods
               # with serializer_context you can pass context to serializer
               serializer_settings=SerializerSettings(
                   serializer_path='user.serializer.UserSerializer',
                   serializer_context=lambda request: {'request': request},
                   map_serializer={
                       'get': 'user.serializer.UserSerializerGet',
                       'post': 'user.serializer.UserSerializerPost',
                   }
               )
           )
       ]
   
   RUDRASETTINGS = RudraSettings()

How to use

1. Get all registered models and their configurations:

   GET: https://{{base_url}}/rudra/models
   
   Sample Response:
   # Note: Response will contain json with key as model and value will be the list of fiedls(and their configurations)
   {
       "User": [
           {
               "name": "logentry",
               "type": "ForeignKey",
               "related_model": "LogEntry",
               "description": null
           },
           {
               "name": "id",
               "type": "AutoField",
               "related_model": null,
               "description": "Integer"
           },
           {
               "name": "password",
               "type": "CharField",
               "related_model": null,
               "description": "String (up to %(max_length)s)"
           },
           {
               "name": "last_login",
               "type": "DateTimeField",
               "related_model": null,
               "description": "Date (with time)"
           },
           {
               "name": "is_superuser",
               "type": "BooleanField",
               "related_model": null,
               "description": "Boolean (Either True or False)"
           },
           {
               "name": "username",
               "type": "CharField",
               "related_model": null,
               "description": "String (up to %(max_length)s)"
           },
           {
               "name": "first_name",
               "type": "CharField",
               "related_model": null,
               "description": "String (up to %(max_length)s)"
           },
           {
               "name": "last_name",
               "type": "CharField",
               "related_model": null,
               "description": "String (up to %(max_length)s)"
           },
           {
               "name": "email",
               "type": "CharField",
               "related_model": null,
               "description": "Email address"
           },
           {
               "name": "is_staff",
               "type": "BooleanField",
               "related_model": null,
               "description": "Boolean (Either True or False)"
           },
           {
               "name": "is_active",
               "type": "BooleanField",
               "related_model": null,
               "description": "Boolean (Either True or False)"
           },
           {
               "name": "date_joined",
               "type": "DateTimeField",
               "related_model": null,
               "description": "Date (with time)"
           },
           {
               "name": "groups",
               "type": "ManyToManyField",
               "related_model": "Group",
               "description": "Many-to-many relationship"
           },
           {
               "name": "user_permissions",
               "type": "ManyToManyField",
               "related_model": "Permission",
               "description": "Many-to-many relationship"
           }
       ]
   }

2. Querying models:

   GET: https://{{base_url}}/rudra/{{model_name}}
   Query Params:
   # add your filters in query params
   {
       'pk': 1,
       'username': 'admin',
       'email': '[e-mail]',
       ...
       # you can add any field name and its value
       # you can also add filters similar to django queryset
       # for example:
       'username__icontains': 'ad',
   
       # you can also add pagination
       'page': 1,
       'page_size': 10,
   
       # you can also add ordering
       'order_by': 'username',
   
       # if you want to receive all results, then
       'all': True
       # else you will receive only single result
   }

3. Use other request methods:

   {{METHOD}}: https://{{base_url}}/rudra/{{model_name}}
   
   # Note: You can use any request method, eg: POST, PUT, PATCH, DELETE
   
   # Note: You can also pass data in request body
   
   # Note: For DELETE request, make sure you pass filters in request body

4. Deep query models:

   # This api is used to query models with more configurations
   # More configurations will be added soon
   
   POST: https://{{base_url}}/rudra/query/{{model_name}}/
   Query Params:
   {
       'page': 1,
       'page_size': 10,
       'all': True # if you want to receive all results
       # don't pass anything if you want to receive single result
   }
   
   BODY:
   {
       'filters': {
           # Add your filters here
           'pk': 1,
           'username': 'admin',
           'email': '[e-mail]',
           'last_name': null
       },
       'order_by_list': [
           'id',
           '-username',
       ],
       'select_related': [
           'logentry',
           'groups',
           'user_permissions',
       ],
       'prefetch_related': [
           'logentry',
           'groups',
           'user_permissions',
       ],
   }

5. Get User:

   GET: https://{{base_url}}/rudra/get-user/