flask-appbuilder 3.2.1rc1__py3-none-any.whl → 5.0.2rc1__py3-none-any.whl

flask_appbuilder/api/__init__.py

@@ -1,27 +1,36 @@
+from __future__ import annotations
+
 import functools
 import json
 import logging
 import re
 import traceback
-from typing import Callable, Dict, List, Optional, Set
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TYPE_CHECKING,
+    Union,
+)
 import urllib.parse
 
 from apispec import APISpec, yaml_utils
 from apispec.exceptions import DuplicateComponentNameError
 from flask import Blueprint, current_app, jsonify, make_response, request, Response
-from flask_babel import lazy_gettext as _
-import jsonschema
-from marshmallow import Schema, ValidationError
-from marshmallow_sqlalchemy.fields import Related, RelatedList
-import prison
-from sqlalchemy.exc import IntegrityError
-from werkzeug.exceptions import BadRequest
-import yaml
-
-from .convert import Model2SchemaConverter
-from .schemas import get_info_schema, get_item_schema, get_list_schema
-from .._compat import as_unicode
-from ..const import (
+from flask_appbuilder._compat import as_unicode
+from flask_appbuilder.api.convert import Model2SchemaConverter
+from flask_appbuilder.api.schemas import (
+    get_info_schema,
+    get_item_schema,
+    get_list_schema,
+)
+from flask_appbuilder.baseviews import AbstractViewApi
+from flask_appbuilder.const import (
     API_ADD_COLUMNS_RES_KEY,
     API_ADD_COLUMNS_RIS_KEY,
     API_ADD_TITLE_RES_KEY,
@@ -50,6 +59,7 @@ from ..const import (
     API_PERMISSIONS_RIS_KEY,
     API_RESULT_RES_KEY,
     API_SELECT_COLUMNS_RIS_KEY,
+    API_SELECT_SEL_COLUMNS_RIS_KEY,
     API_SHOW_COLUMNS_RES_KEY,
     API_SHOW_COLUMNS_RIS_KEY,
     API_SHOW_TITLE_RES_KEY,
@@ -57,15 +67,45 @@ from ..const import (
     API_URI_RIS_KEY,
     PERMISSION_PREFIX,
 )
-from ..exceptions import FABException, InvalidOrderByColumnFABException
-from ..security.decorators import permission_name, protect
+from flask_appbuilder.exceptions import (
+    DatabaseException,
+    FABException,
+    InvalidColumnArgsFABException,
+    InvalidOrderByColumnFABException,
+)
+from flask_appbuilder.hooks import (
+    get_before_request_hooks,
+    wrap_route_handler_with_hooks,
+)
+from flask_appbuilder.models.filters import Filters
+from flask_appbuilder.models.sqla import Model
+from flask_appbuilder.models.sqla.filters import BaseFilter
+from flask_appbuilder.models.sqla.interface import SQLAInterface
+from flask_appbuilder.security.decorators import permission_name, protect
+from flask_appbuilder.utils.limit import Limit
+from flask_babel import lazy_gettext as _
+import jsonschema
+from marshmallow import Schema, ValidationError
+from marshmallow.fields import Field
+from marshmallow_sqlalchemy.fields import Related, RelatedList
+import prison
+from werkzeug.exceptions import BadRequest
+import yaml
+
+if TYPE_CHECKING:
+    from flask_appbuilder import AppBuilder
+
 
 log = logging.getLogger(__name__)
 
 
-def get_error_msg():
+ModelKeyType = Union[str, int]
+QueryRelatedFieldsFilters = Dict[str, List[List[Any]]]
+
+
+def get_error_msg() -> str:
     """
-        (inspired on Superset code)
+    (inspired on Superset code)
     :return: (str)
     """
     if current_app.config.get("FAB_API_SHOW_STACKTRACE"):
@@ -73,61 +113,63 @@ def get_error_msg():
     return "Fatal error"
 
 
-def safe(f):
+def safe(f: Callable[..., Any]) -> Callable[..., Any]:
     """
     A decorator that catches uncaught exceptions and
     return the response in JSON format (inspired on Superset code)
     """
 
-    def wraps(self, *args, **kwargs):
+    def wraps(self: "BaseApi", *args: Any, **kwargs: Any) -> Response:
         try:
             return f(self, *args, **kwargs)
         except BadRequest as e:
             return self.response_400(message=str(e))
         except Exception as e:
-            logging.exception(e)
+            log.exception(e)
             return self.response_500(message=get_error_msg())
 
     return functools.update_wrapper(wraps, f)
 
 
-def rison(schema=None):
+def rison(
+    schema: Optional[Dict[str, Any]] = None
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """
-        Use this decorator to parse URI *Rison* arguments to
-        a python data structure, your method gets the data
-        structure on kwargs['rison']. Response is HTTP 400
-        if *Rison* is not correct::
+    Use this decorator to parse URI *Rison* arguments to
+    a python data structure, your method gets the data
+    structure on kwargs['rison']. Response is HTTP 400
+    if *Rison* is not correct::
 
-            class ExampleApi(BaseApi):
-                    @expose('/risonjson')
-                    @rison()
-                    def rison_json(self, **kwargs):
-                        return self.response(200, result=kwargs['rison'])
+        class ExampleApi(BaseApi):
+                @expose('/risonjson')
+                @rison()
+                def rison_json(self, **kwargs):
+                    return self.response(200, result=kwargs['rison'])
 
-        You can additionally pass a JSON schema to
-        validate Rison arguments::
+    You can additionally pass a JSON schema to
+    validate Rison arguments::
 
-            schema = {
-                "type": "object",
-                "properties": {
-                    "arg1": {
-                        "type": "integer"
-                    }
+        schema = {
+            "type": "object",
+            "properties": {
+                "arg1": {
+                    "type": "integer"
                 }
             }
+        }
 
-            class ExampleApi(BaseApi):
-                    @expose('/risonjson')
-                    @rison(schema)
-                    def rison_json(self, **kwargs):
-                        return self.response(200, result=kwargs['rison'])
+        class ExampleApi(BaseApi):
+                @expose('/risonjson')
+                @rison(schema)
+                def rison_json(self, **kwargs):
+                    return self.response(200, result=kwargs['rison'])
 
     """
 
-    def _rison(f):
-        def wraps(self, *args, **kwargs):
+    def _rison(f: Callable[..., Any]) -> Callable[..., Any]:
+        def wraps(self: "BaseApi", *args: Any, **kwargs: Any) -> Response:
             value = request.args.get(API_URI_RIS_KEY, None)
-            kwargs["rison"] = dict()
+            kwargs["rison"] = {}
             if value:
                 try:
                     kwargs["rison"] = prison.loads(value)
@@ -150,7 +192,13 @@ def rison(schema=None):
                 try:
                     jsonschema.validate(instance=kwargs["rison"], schema=schema)
                 except jsonschema.ValidationError as e:
-                    return self.response_400(message=f"Not a valid rison schema {e}")
+                    try:
+                        validation_message = str(e).split("\n", 1)[0]
+                    except Exception:
+                        validation_message = str(e)
+                    return self.response_400(
+                        message=f"Not a valid rison schema {validation_message}"
+                    )
             return f(self, *args, **kwargs)
 
         return functools.update_wrapper(wraps, f)
@@ -158,26 +206,26 @@ def rison(schema=None):
     return _rison
 
 
-def expose(url="/", methods=("GET",)):
+def expose(url: str = "/", methods: Tuple[str] = ("GET",)) -> Callable[..., Any]:
     """
-        Use this decorator to expose API endpoints on your API classes.
+    Use this decorator to expose API endpoints on your API classes.
 
-        :param url:
-            Relative URL for the endpoint
-        :param methods:
-            Allowed HTTP methods. By default only GET is allowed.
+    :param url:
+        Relative URL for the endpoint
+    :param methods:
+        Allowed HTTP methods. By default only GET is allowed.
     """
 
-    def wrap(f):
+    def wrap(f: Callable[..., Any]) -> Callable[..., Any]:
         if not hasattr(f, "_urls"):
-            f._urls = []
-        f._urls.append((url, methods))
+            f._urls = []  # type: ignore
+        f._urls.append((url, methods))  # type: ignore
         return f
 
     return wrap
 
 
-def merge_response_func(func, key):
+def merge_response_func(func: Callable[..., Any], key: str) -> Callable[..., Any]:
     """
         Use this decorator to set a new merging
         response function to HTTP endpoints
@@ -193,106 +241,120 @@ def merge_response_func(func, key):
     :return: None
     """
 
-    def wrap(f):
+    def wrap(f: Callable[..., Any]) -> Callable[..., Any]:
         if not hasattr(f, "_response_key_func_mappings"):
-            f._response_key_func_mappings = dict()
-        f._response_key_func_mappings[key] = func
+            f._response_key_func_mappings = {}  # type: ignore
+        f._response_key_func_mappings[key] = func  # type: ignore
         return f
 
     return wrap
 
 
-class BaseApi(object):
+class BaseApi(AbstractViewApi):
     """
-        All apis inherit from this class.
-        it's constructor will register your exposed urls on flask
-        as a Blueprint.
+    All apis inherit from this class.
+    it's constructor will register your exposed urls on flask
+    as a Blueprint.
 
-        This class does not expose any urls,
-        but provides a common base for all APIS.
+    This class does not expose any urls,
+    but provides a common base for all APIS.
     """
 
-    appbuilder = None
-    blueprint = None
     endpoint: Optional[str] = None
 
     version: Optional[str] = "v1"
     """
-        Define the Api version for this resource/class
+    Define the Api version for this resource/class
     """
     route_base: Optional[str] = None
     """
-        Define the route base where all methods will suffix from
+    Define the route base where all methods will suffix from
     """
     resource_name: Optional[str] = None
     """
-        Defines a custom resource name, overrides the inferred from Class name
-        makes no sense to use it with route base
+    Defines a custom resource name, overrides the inferred from Class name
+    makes no sense to use it with route base
     """
     base_permissions: Optional[List[str]] = None
     """
-        A list of allowed base permissions::
+    A list of allowed base permissions::
 
-            class ExampleApi(BaseApi):
-                base_permissions = ['can_get']
+        class ExampleApi(BaseApi):
+            base_permissions = ['can_get']
 
     """
     class_permission_name: Optional[str] = None
     """
-        Override class permission name default fallback to self.__class__.__name__
+    Override class permission name default fallback to self.__class__.__name__
     """
     previous_class_permission_name: Optional[str] = None
     """
-        If set security converge will replace all permissions tuples
-        with this name by the class_permission_name or self.__class__.__name__
+    If set security converge will replace all permissions tuples
+    with this name by the class_permission_name or self.__class__.__name__
     """
     method_permission_name: Optional[Dict[str, str]] = None
     """
-        Override method permission names, example::
+    Override method permission names, example::
 
-            method_permissions_name = {
-                'get_list': 'read',
-                'get': 'read',
-                'put': 'write',
-                'post': 'write',
-                'delete': 'write'
-            }
+        method_permissions_name = {
+            'get_list': 'read',
+            'get': 'read',
+            'put': 'write',
+            'post': 'write',
+            'delete': 'write'
+        }
     """
     previous_method_permission_name: Optional[Dict[str, str]] = None
     """
-        Use same structure as method_permission_name. If set security converge
-        will replace all method permissions by the new ones
+    Use same structure as method_permission_name. If set security converge
+    will replace all method permissions by the new ones
     """
     allow_browser_login = False
     """
-        Will allow flask-login cookie authorization on the API
-        default is False.
+    Will allow flask-login cookie authorization on the API
+    default is False.
     """
     csrf_exempt = True
     """
-        If using flask-wtf CSRFProtect exempt the API from check
+    If using flask-wtf CSRFProtect exempt the API from check
     """
-    apispec_parameter_schemas: Optional[Dict[str, Dict]] = None
+    apispec_parameter_schemas: Optional[Dict[str, Dict[str, Any]]] = None
     """
-        Set your custom Rison parameter schemas here so that
-        they get registered on the OpenApi spec::
+    Set your custom Rison parameter schemas here so that
+    they get registered on the OpenApi spec::
 
-            custom_parameter = {
-                "type": "object"
-                "properties": {
-                    "name": {
-                        "type": "string"
-                    }
+        custom_parameter = {
+            "type": "object"
+            "properties": {
+                "name": {
+                    "type": "string"
                 }
             }
+        }
 
-            class CustomApi(BaseApi):
-                apispec_parameter_schemas = {
-                    "custom_parameter": custom_parameter
-                }
+        class CustomApi(BaseApi):
+            apispec_parameter_schemas = {
+                "custom_parameter": custom_parameter
+            }
     """
-    _apispec_parameter_schemas = None
+    _apispec_parameter_schemas: Optional[Dict[str, Dict[str, Any]]] = None
 
+    openapi_spec_component_schemas: Tuple[Type[Schema], ...] = tuple()
+    """
+    A Tuple containing marshmallow schemas to be registered on the OpenAPI spec
+    has component schemas, these can be referenced by the endpoint's spec like:
+    `$ref: '#/components/schemas/MyCustomSchema'` Where MyCustomSchema is the
+    marshmallow schema class name.
+
+    To set your own OpenAPI schema component name, declare your schemas with:
+    __component_name__
+
+    class Schema1(Schema):
+        __component_name__ = "MyCustomSchema"
+        id = fields.Integer()
+        ...
+
+    """
     responses = {
         "400": {
             "description": "Bad request",
@@ -362,68 +424,85 @@ class BaseApi(object):
         },
     }
     """
-        Override custom OpenApi responses
+    Override custom OpenApi responses
     """
 
-    exclude_route_methods = set()
+    exclude_route_methods: Set[str] = set()
     """
-        Does not register routes for a set of builtin ModelRestApi functions.
-        example::
+    Does not register routes for a set of builtin ModelRestApi functions.
+    example::
 
-            class ContactModelView(ModelRestApi):
-                datamodel = SQLAInterface(Contact)
-                exclude_route_methods = {"info", "get_list", "get"}
+        class ContactModelView(ModelRestApi):
+            datamodel = SQLAInterface(Contact)
+            exclude_route_methods = {"info", "get_list", "get"}
 
 
-        The previous examples will only register the `put`, `post` and `delete` routes
+    The previous examples will only register the `put`, `post` and `delete` routes
     """
-    include_route_methods: Set[str] = None
+    include_route_methods: Optional[Set[str]] = None
     """
-        If defined will assume a white list setup, where all endpoints are excluded
-        except those define on this attribute
-        example::
+    If defined will assume a white list setup, where all endpoints are excluded
+    except those define on this attribute
+    example::
 
-            class ContactModelView(ModelRestApi):
-                datamodel = SQLAInterface(Contact)
-                include_route_methods = {"list"}
+        class ContactModelView(ModelRestApi):
+            datamodel = SQLAInterface(Contact)
+            include_route_methods = {"list"}
 
 
-        The previous example will exclude all endpoints except the `list` endpoint
+    The previous example will exclude all endpoints except the `list` endpoint
     """
-    openapi_spec_methods: Dict = {}
+    openapi_spec_methods: Dict[str, Any] = {}
     """
-        Merge OpenAPI spec defined on the method's doc.
-        For example to merge/override `get_list`::
+    Merge OpenAPI spec defined on the method's doc.
+    For example to merge/override `get_list`::
 
 
-            class GreetingApi(BaseApi):
-                resource_name = "greeting"
-                openapi_spec_methods = {
-                    "greeting": {
-                        "get": {
-                           "description": "Override description",
-                        }
+        class GreetingApi(BaseApi):
+            resource_name = "greeting"
+            openapi_spec_methods = {
+                "greeting": {
+                    "get": {
+                       "description": "Override description",
                     }
                 }
+            }
     """
     openapi_spec_tag: Optional[str] = None
     """
-        By default all endpoints will be tagged (grouped) to their class name.
-        Use this attribute to override the tag name
+    By default all endpoints will be tagged (grouped) to their class name.
+    Use this attribute to override the tag name
+    """
+
+    limits: Optional[List[Limit]] = None
+    """
+    List of limits for this api.
+
+    Use it like this if you want to restrict the rate of requests to a view::
+
+        class MyView(ModelView):
+            limits = [Limit("2 per 5 second")]
+
+    or use the decorator @limit.
     """
 
     def __init__(self) -> None:
         """
-            Initialization of base permissions
-            based on exposed methods and actions
+        Initialization of base permissions
+        based on exposed methods and actions
 
-            Initialization of extra args
+        Initialization of extra args
         """
+        self.appbuilder = None
+        self.blueprint = None
+
         # Init OpenAPI
-        self._response_key_func_mappings = dict()
-        self.apispec_parameter_schemas = self.apispec_parameter_schemas or dict()
-        self._apispec_parameter_schemas = self._apispec_parameter_schemas or dict()
+        self._response_key_func_mappings: Dict[str, Any] = {}
+        self.apispec_parameter_schemas = self.apispec_parameter_schemas or {}
+        self._apispec_parameter_schemas = self._apispec_parameter_schemas or {}
         self._apispec_parameter_schemas.update(self.apispec_parameter_schemas)
+        if self.openapi_spec_component_schemas is None:
+            self.openapi_spec_component_schemas = ()
 
         # Init class permission override attrs
         if not self.previous_class_permission_name and self.class_permission_name:
@@ -444,7 +523,13 @@ class BaseApi(object):
         if self.base_permissions is None:
             self.base_permissions = set()
             is_add_base_permissions = True
+
+        if self.limits is None:
+            self.limits = []
+
         for attr_name in dir(self):
+            if hasattr(getattr(self, attr_name), "_limit"):
+                self.limits.append(getattr(getattr(self, attr_name), "_limit"))
             # If include_route_methods is not None white list
             if (
                 self.include_route_methods is not None
@@ -464,7 +549,12 @@ class BaseApi(object):
                     self.base_permissions.add(PERMISSION_PREFIX + _permission_name)
         self.base_permissions = list(self.base_permissions)
 
-    def create_blueprint(self, appbuilder, endpoint=None, static_folder=None):
+    def create_blueprint(
+        self,
+        appbuilder: "AppBuilder",
+        endpoint: Optional[str] = None,
+        static_folder: Optional[str] = None,
+    ) -> Blueprint:
         # Store appbuilder instance
         self.appbuilder = appbuilder
         # If endpoint name is not provided, get it from the class name
@@ -472,13 +562,11 @@ class BaseApi(object):
         self.resource_name = self.resource_name or self.__class__.__name__.lower()
 
         if self.route_base is None:
-            self.route_base = "/api/{}/{}".format(
-                self.version, self.resource_name.lower()
-            )
+            self.route_base = f"/api/{self.version}/{self.resource_name.lower()}"
         self.blueprint = Blueprint(self.endpoint, __name__, url_prefix=self.route_base)
         # Exempt API from CSRF protect
         if self.csrf_exempt:
-            csrf = self.appbuilder.app.extensions.get("csrf")
+            csrf = current_app.extensions.get("csrf")
             if csrf:
                 csrf.exempt(self.blueprint)
 
@@ -498,9 +586,9 @@ class BaseApi(object):
                     ):
                         continue
                     if attr_name in self.exclude_route_methods:
-                        log.info(f"Not registering api spec for method {attr_name}")
+                        log.info("Not registering api spec for method %s", attr_name)
                         continue
-                    operations = dict()
+                    operations = {}
                     path = self.path_helper(path=url, operations=operations)
                     self.operation_helper(
                         path=path, operations=operations, methods=methods, func=attr
@@ -514,14 +602,29 @@ class BaseApi(object):
 
     def add_apispec_components(self, api_spec: APISpec) -> None:
         for k, v in self.responses.items():
-            api_spec.components._responses[k] = v
+            try:
+                api_spec.components.response(k, v)
+            except DuplicateComponentNameError:
+                pass
         for k, v in self._apispec_parameter_schemas.items():
             try:
                 api_spec.components.schema(k, v)
             except DuplicateComponentNameError:
                 pass
+        for schema in self.openapi_spec_component_schemas:
+            try:
+                if hasattr(schema, "__component_name__"):
+                    component_name = schema.__component_name__
+                elif isinstance(schema, type):
+                    component_name = schema.__name__
+                else:
+                    component_name = schema.__class__.__name__
+                api_spec.components.schema(component_name, schema=schema)
+            except DuplicateComponentNameError:
+                pass
 
     def _register_urls(self) -> None:
+        before_request_hooks = get_before_request_hooks(self)
         for attr_name in dir(self):
             if (
                 self.include_route_methods is not None
@@ -529,18 +632,29 @@ class BaseApi(object):
             ):
                 continue
             if attr_name in self.exclude_route_methods:
-                log.info(f"Not registering route for method {attr_name}")
+                log.debug("Not registering route for method %s", attr_name)
                 continue
             attr = getattr(self, attr_name)
             if hasattr(attr, "_urls"):
                 for url, methods in attr._urls:
-                    log.info(
-                        f"Registering route {self.blueprint.url_prefix}{url} {methods}"
+                    log.debug(
+                        "Registering route %s%s %s",
+                        self.blueprint.url_prefix,
+                        url,
+                        methods,
+                    )
+                    route_handler = wrap_route_handler_with_hooks(
+                        attr_name, attr, before_request_hooks
+                    )
+                    self.blueprint.add_url_rule(
+                        url, attr_name, route_handler, methods=methods
                     )
-                    self.blueprint.add_url_rule(url, attr_name, attr, methods=methods)
 
     def path_helper(
-        self, path: str = None, operations: Dict[str, Dict] = None, **kwargs
+        self,
+        path: str = None,
+        operations: Optional[Dict[str, Dict]] = None,
+        **kwargs: Any,
     ) -> str:
         """
             Works like an apispec plugin
@@ -555,15 +669,20 @@ class BaseApi(object):
         """
         RE_URL = re.compile(r"<(?:[^:<>]+:)?([^<>]+)>")
         path = RE_URL.sub(r"{\1}", path)
-        return f"/{self.resource_name}{path}"
+        return f"{self.route_base}{path}"
 
     def operation_helper(
-        self, path=None, operations=None, methods=None, func=None, **kwargs
-    ):
+        self,
+        path: Optional[str] = None,
+        operations: Dict[str, Any] = None,
+        methods: List[str] = None,
+        func: Callable[..., Response] = None,
+        **kwargs: Any,
+    ) -> None:
         """May mutate operations.
         :param str path: Path to the resource
-        :param dict operations: A `dict` mapping HTTP methods to operation object. See
-        :param list methods: A list of methods registered for this path
+        :param dict operations: A `dict` mapping HTTP methods to operation object.
+        :param list methods: A list of HTTP methods registered for this path
         """
         for method in methods:
             try:
@@ -588,45 +707,45 @@ class BaseApi(object):
                 operations[method.lower()] = {}
 
     @staticmethod
-    def _prettify_name(name):
+    def _prettify_name(name: str) -> str:
         """
-            Prettify pythonic variable name.
+        Prettify pythonic variable name.
 
-            For example, 'HelloWorld' will be converted to 'Hello World'
+        For example, 'HelloWorld' will be converted to 'Hello World'
 
-            :param name:
-                Name to prettify.
+        :param name:
+            Name to prettify.
         """
         return re.sub(r"(?<=.)([A-Z])", r" \1", name)
 
     @staticmethod
-    def _prettify_column(name):
+    def _prettify_column(name: str) -> str:
         """
-            Prettify pythonic variable name.
+        Prettify pythonic variable name.
 
-            For example, 'hello_world' will be converted to 'Hello World'
+        For example, 'hello_world' will be converted to 'Hello World'
 
-            :param name:
-                Name to prettify.
+        :param name:
+            Name to prettify.
         """
         return re.sub("[._]", " ", name).title()
 
-    def get_uninit_inner_views(self):
+    def get_uninit_inner_views(self) -> List[Type[AbstractViewApi]]:
         """
-            Will return a list with views that need to be initialized.
-            Normally related_views from ModelView
+        Will return a list with views that need to be initialized.
+        Normally related_views from ModelView
         """
         return []
 
-    def get_init_inner_views(self, views):
+    def get_init_inner_views(self) -> List[AbstractViewApi]:
         """
-            Sets initialized inner views
+        Sets initialized inner views
         """
         pass  # pragma: no cover
 
     def get_method_permission(self, method_name: str) -> str:
         """
-            Returns the permission name for a method
+        Returns the permission name for a method
         """
         if self.method_permission_name:
             return self.method_permission_name.get(method_name, method_name)
@@ -634,7 +753,13 @@ class BaseApi(object):
             if hasattr(getattr(self, method_name), "_permission_name"):
                 return getattr(getattr(self, method_name), "_permission_name")
 
-    def set_response_key_mappings(self, response, func, rison_args, **kwargs):
+    def set_response_key_mappings(
+        self,
+        response: Dict[str, Any],
+        func: Callable[..., Response],
+        rison_args: Dict[str, Any],
+        **kwargs: Any,
+    ) -> None:
         if not hasattr(func, "_response_key_func_mappings"):
             return  # pragma: no cover
         _keys = rison_args.get("keys", None)
@@ -646,7 +771,9 @@ class BaseApi(object):
                 if k in _keys:
                     v(self, response, **kwargs)
 
-    def merge_current_user_permissions(self, response, **kwargs):
+    def merge_current_user_permissions(
+        self, response: Dict[str, Any], **kwargs: Any
+    ) -> None:
         response[API_PERMISSIONS_RES_KEY] = [
             permission
             for permission in self.base_permissions
@@ -654,9 +781,9 @@ class BaseApi(object):
         ]
 
     @staticmethod
-    def response(code, **kwargs) -> Response:
+    def response(code: int, **kwargs: Any) -> Response:
         """
-            Generic HTTP JSON response method
+        Generic HTTP JSON response method
 
         :param code: HTTP code (int)
         :param kwargs: Data structure for response (dict)
@@ -669,7 +796,7 @@ class BaseApi(object):
 
     def response_400(self, message: str = None) -> Response:
         """
-            Helper method for HTTP 400 response
+        Helper method for HTTP 400 response
 
         :param message: Error message (str)
         :return: HTTP Json response
@@ -679,7 +806,7 @@ class BaseApi(object):
 
     def response_422(self, message: str = None) -> Response:
         """
-            Helper method for HTTP 422 response
+        Helper method for HTTP 422 response
 
         :param message: Error message (str)
         :return: HTTP Json response
@@ -689,7 +816,7 @@ class BaseApi(object):
 
     def response_401(self) -> Response:
         """
-            Helper method for HTTP 401 response
+        Helper method for HTTP 401 response
 
         :param message: Error message (str)
         :return: HTTP Json response
@@ -698,7 +825,7 @@ class BaseApi(object):
 
     def response_403(self) -> Response:
         """
-            Helper method for HTTP 403 response
+        Helper method for HTTP 403 response
 
         :param message: Error message (str)
         :return: HTTP Json response
@@ -707,7 +834,7 @@ class BaseApi(object):
 
     def response_404(self) -> Response:
         """
-            Helper method for HTTP 404 response
+        Helper method for HTTP 404 response
 
         :param message: Error message (str)
         :return: HTTP Json response
@@ -716,7 +843,7 @@ class BaseApi(object):
 
     def response_500(self, message: str = None) -> Response:
         """
-            Helper method for HTTP 500 response
+        Helper method for HTTP 500 response
 
         :param message: Error message (str)
         :return: HTTP Json response
@@ -725,289 +852,250 @@ class BaseApi(object):
         return self.response(500, **{"message": message})
 
 
-class BaseModelApi(BaseApi):
-    datamodel = None
+class ModelRestApi(BaseApi):
+    datamodel: SQLAInterface
     """
-        Your sqla model you must initialize it like::
+    Your sqla model you must initialize it like::
 
-            class MyModelApi(BaseModelApi):
-                datamodel = SQLAInterface(MyTable)
+        class MyModelApi(BaseModelApi):
+            datamodel = SQLAInterface(MyTable)
     """
     search_columns = None
     """
-        List with allowed search columns, if not provided all possible search
-        columns will be used. If you want to limit the search (*filter*) columns
-         possibilities, define it with a list of column names from your model::
+    List with allowed search columns, if not provided all possible search
+    columns will be used. If you want to limit the search (*filter*) columns
+     possibilities, define it with a list of column names from your model::
 
-            class MyView(ModelRestApi):
-                datamodel = SQLAInterface(MyTable)
-                search_columns = ['name', 'address']
+        class MyView(ModelRestApi):
+            datamodel = SQLAInterface(MyTable)
+            search_columns = ['name', 'address']
 
     """
-    search_filters = None
+    search_filters: dict[str, BaseFilter] | None = None
     """
-        Override default search filters for columns
+    Override default search filters for columns
     """
     search_exclude_columns = None
     """
-        List with columns to exclude from search. Search includes all possible
-        columns by default
+    List with columns to exclude from search. Search includes all possible
+    columns by default
     """
     label_columns = None
     """
-        Dictionary of labels for your columns, override this if you want
-         different pretify labels
+    Dictionary of labels for your columns, override this if you want
+     different pretify labels
 
-        example (will just override the label for name column)::
+    example (will just override the label for name column)::
 
-            class MyView(ModelRestApi):
-                datamodel = SQLAInterface(MyTable)
-                label_columns = {'name':'My Name Label Override'}
+        class MyView(ModelRestApi):
+            datamodel = SQLAInterface(MyTable)
+            label_columns = {'name':'My Name Label Override'}
 
     """
     base_filters = None
     """
-        Filter the view use: [['column_name',BaseFilter,'value'],]
+    Filter the view use: [['column_name',BaseFilter,'value'],]
 
-        example::
+    example::
 
-            def get_user():
-                return g.user
+        def get_user():
+            return g.user
 
-            class MyView(ModelRestApi):
-                datamodel = SQLAInterface(MyTable)
-                base_filters = [['created_by', FilterEqualFunction, get_user],
-                                ['name', FilterStartsWith, 'a']]
+        class MyView(ModelRestApi):
+            datamodel = SQLAInterface(MyTable)
+            base_filters = [['created_by', FilterEqualFunction, get_user],
+                            ['name', FilterStartsWith, 'a']]
 
     """
 
     base_order = None
     """
-        Use this property to set default ordering for lists
-         ('col_name','asc|desc')::
+    Use this property to set default ordering for lists
+     ('col_name','asc|desc')::
 
-            class MyView(ModelRestApi):
-                datamodel = SQLAInterface(MyTable)
-                base_order = ('my_column_name','asc')
+        class MyView(ModelRestApi):
+            datamodel = SQLAInterface(MyTable)
+            base_order = ('my_column_name','asc')
 
     """
     _base_filters = None
     """ Internal base Filter from class Filters will always filter view """
     _filters = None
     """
-        Filters object will calculate all possible filter types
-        based on search_columns
+    Filters object will calculate all possible filter types
+    based on search_columns
     """
-
-    def __init__(self, **kwargs):
-        """
-            Constructor
-        """
-        datamodel = kwargs.get("datamodel", None)
-        if datamodel:
-            self.datamodel = datamodel
-        self._init_properties()
-        self._init_titles()
-        super(BaseModelApi, self).__init__()
-
-    def _gen_labels_columns(self, list_columns):
-        """
-            Auto generates pretty label_columns from list of columns
-        """
-        for col in list_columns:
-            if not self.label_columns.get(col):
-                self.label_columns[col] = self._prettify_column(col)
-
-    def _label_columns_json(self, cols=None):
-        """
-            Prepares dict with labels to be JSON serializable
-        """
-        ret = {}
-        cols = cols or []
-        d = {k: v for (k, v) in self.label_columns.items() if k in cols}
-        for key, value in d.items():
-            ret[key] = as_unicode(_(value).encode("UTF-8"))
-        return ret
-
-    def _init_properties(self):
-        self.label_columns = self.label_columns or {}
-        self.base_filters = self.base_filters or []
-        self.search_exclude_columns = self.search_exclude_columns or []
-        self.search_columns = self.search_columns or []
-
-        self._base_filters = self.datamodel.get_filters().add_filter_list(
-            self.base_filters
-        )
-        search_columns = self.datamodel.get_search_columns_list()
-        if not self.search_columns:
-            self.search_columns = [
-                x for x in search_columns if x not in self.search_exclude_columns
-            ]
-        self._gen_labels_columns(self.datamodel.get_columns_list())
-
-    def _init_titles(self):
-        pass
-
-
-class ModelRestApi(BaseModelApi):
     list_title = ""
     """
-        List Title, if not configured the default is
-        'List ' with pretty model name
+    List Title, if not configured the default is
+    'List ' with pretty model name
     """
     show_title: Optional[str] = ""
     """
-        Show Title , if not configured the default is
-        'Show ' with pretty model name
+    Show Title , if not configured the default is
+    'Show ' with pretty model name
     """
     add_title: Optional[str] = ""
     """
-        Add Title , if not configured the default is
-        'Add ' with pretty model name
+    Add Title , if not configured the default is
+    'Add ' with pretty model name
     """
     edit_title: Optional[str] = ""
     """
-        Edit Title , if not configured the default is
-        'Edit ' with pretty model name
+    Edit Title , if not configured the default is
+    'Edit ' with pretty model name
     """
     list_select_columns: Optional[List[str]] = None
     """
-        A List of column names that will be included on the SQL select.
-        This is useful for including all necessary columns that are referenced
-        by properties listed on `list_columns` without generating N+1 queries.
+    A List of column names that will be included on the SQL select.
+    This is useful for including all necessary columns that are referenced
+    by properties listed on `list_columns` without generating N+1 queries.
+    """
+    list_outer_default_load = False
+    """
+    If True, the default load for outer joins will be applied on the get item endpoint.
+    This is useful for when you want to control the load of the many-to-many and
+    many-to-one relationships at the model level. Will apply:
+     https://docs.sqlalchemy.org/en/14/orm/loading_relationships.html#sqlalchemy.orm.Load.defaultload
     """
     list_columns: Optional[List[str]] = None
     """
-        A list of columns (or model's methods) to be displayed on the list view.
-        Use it to control the order of the display
+    A list of columns (or model's methods) to be displayed on the list view.
+    Use it to control the order of the display
     """
     show_select_columns: Optional[List[str]] = None
     """
-        A List of column names that will be included on the SQL select.
-        This is useful for including all necessary columns that are referenced
-        by properties listed on `show_columns` without generating N+1 queries.
+    A List of column names that will be included on the SQL select.
+    This is useful for including all necessary columns that are referenced
+    by properties listed on `show_columns` without generating N+1 queries.
+    """
+    show_outer_default_load = False
+    """
+    If True, the default load for outer joins will be applied on the get item endpoint.
+    This is useful for when you want to control the load of the many-to-many and
+    many-to-one relationships at the model level. Will apply:
+     https://docs.sqlalchemy.org/en/14/orm/loading_relationships.html#sqlalchemy.orm.Load.defaultload
     """
     show_columns: Optional[List[str]] = None
     """
-        A list of columns (or model's methods) for the get item endpoint.
-        Use it to control the order of the results
+    A list of columns (or model's methods) for the get item endpoint.
+    Use it to control the order of the results
     """
     add_columns: Optional[List[str]] = None
     """
-        A list of columns (or model's methods) to be allowed to post
+    A list of columns (or model's methods) to be allowed to post
     """
     edit_columns: Optional[List[str]] = None
     """
-        A list of columns (or model's methods) to be allowed to update
+    A list of columns (or model's methods) to be allowed to update
     """
     list_exclude_columns: Optional[List[str]] = None
     """
-        A list of columns to exclude from the get list endpoint.
-        By default all columns are included.
+    A list of columns to exclude from the get list endpoint.
+    By default all columns are included.
     """
     show_exclude_columns: Optional[List[str]] = None
     """
-        A list of columns to exclude from the get item endpoint.
-        By default all columns are included.
+    A list of columns to exclude from the get item endpoint.
+    By default all columns are included.
     """
     add_exclude_columns: Optional[List[str]] = None
     """
-        A list of columns to exclude from the add endpoint.
-        By default all columns are included.
+    A list of columns to exclude from the add endpoint.
+    By default all columns are included.
     """
     edit_exclude_columns: Optional[List[str]] = None
     """
-        A list of columns to exclude from the edit endpoint.
-        By default all columns are included.
+    A list of columns to exclude from the edit endpoint.
+    By default all columns are included.
     """
     order_columns: Optional[List[str]] = None
     """ Allowed order columns """
     page_size = 20
     """
-        Use this property to change default page size
+    Use this property to change default page size
     """
     max_page_size: Optional[int] = None
     """
-        class override for the FAB_API_MAX_SIZE, use special -1 to allow for any page
-        size
+    class override for the FAB_API_MAX_SIZE, use special -1 to allow for any page
+    size
     """
     description_columns: Optional[Dict[str, str]] = None
     """
-        Dictionary with column descriptions that will be shown on the forms::
+    Dictionary with column descriptions that will be shown on the forms::
 
-            class MyView(ModelView):
-                datamodel = SQLAModel(MyTable, db.session)
-
-                description_columns = {'name':'your models name column',
-                                        'address':'the address column'}
+        class MyView(ModelRestApi):
+            datamodel = SQLAModel(Model1)
+            description_columns = {'name':'your models name column',
+                                    'address':'the address column'}
     """
     validators_columns: Optional[Dict[str, Callable]] = None
     """ Dictionary to add your own marshmallow validators """
 
     add_query_rel_fields = None
     """
-        Add Customized query for related add fields.
-        Assign a dictionary where the keys are the column names of
-        the related models to filter, the value for each key, is a list of lists with the
-        same format as base_filter
-        {'relation col name':[['Related model col',FilterClass,'Filter Value'],...],...}
-        Add a custom filter to form related fields::
+    Add Customized query for related add fields.
+    Assign a dictionary where the keys are the column names of
+    the related models to filter, the value for each key, is a list of lists with the
+    same format as base_filter
+    {'relation col name':[['Related model col',FilterClass,'Filter Value'],...],...}
+    Add a custom filter to form related fields::
 
-            class ContactModelView(ModelRestApi):
-                datamodel = SQLAModel(Contact)
-                add_query_rel_fields = {'group':[['name',FilterStartsWith,'W']]}
+        class ContactModelView(ModelRestApi):
+            datamodel = SQLAModel(Contact)
+            add_query_rel_fields = {'group':[['name',FilterStartsWith,'W']]}
 
     """
     edit_query_rel_fields = None
     """
-        Add Customized query for related edit fields.
-        Assign a dictionary where the keys are the column names of
-        the related models to filter, the value for each key, is a list of lists with the
-        same format as base_filter
-        {'relation col name':[['Related model col',FilterClass,'Filter Value'],...],...}
-        Add a custom filter to form related fields::
+    Add Customized query for related edit fields.
+    Assign a dictionary where the keys are the column names of
+    the related models to filter, the value for each key, is a list of lists with the
+    same format as base_filter
+    {'relation col name':[['Related model col',FilterClass,'Filter Value'],...],...}
+    Add a custom filter to form related fields::
 
-            class ContactModelView(ModelRestApi):
-                datamodel = SQLAModel(Contact, db.session)
-                edit_query_rel_fields = {'group':[['name',FilterStartsWith,'W']]}
+        class ContactModelView(ModelRestApi):
+            datamodel = SQLAModel(Contact)
+            edit_query_rel_fields = {'group':[['name',FilterStartsWith,'W']]}
 
     """
     order_rel_fields = None
     """
-        Impose order on related fields.
-        assign a dictionary where the keys are the related column names::
+    Impose order on related fields.
+    assign a dictionary where the keys are the related column names::
 
-            class ContactModelView(ModelRestApi):
-                datamodel = SQLAModel(Contact)
-                order_rel_fields = {
-                    'group': ('name', 'asc')
-                    'gender': ('name', 'asc')
-                }
+        class ContactModelView(ModelRestApi):
+            datamodel = SQLAModel(Contact)
+            order_rel_fields = {
+                'group': ('name', 'asc')
+                'gender': ('name', 'asc')
+            }
     """
     list_model_schema: Optional[Schema] = None
     """
-        Override to provide your own marshmallow Schema
-        for JSON to SQLA dumps
+    Override to provide your own marshmallow Schema
+    for JSON to SQLA dumps
     """
     add_model_schema: Optional[Schema] = None
     """
-        Override to provide your own marshmallow Schema
-        for JSON to SQLA dumps
+    Override to provide your own marshmallow Schema
+    for JSON to SQLA dumps
     """
     edit_model_schema: Optional[Schema] = None
     """
-        Override to provide your own marshmallow Schema
-        for JSON to SQLA dumps
+    Override to provide your own marshmallow Schema
+    for JSON to SQLA dumps
     """
     show_model_schema: Optional[Schema] = None
     """
-        Override to provide your own marshmallow Schema
-        for JSON to SQLA dumps
+    Override to provide your own marshmallow Schema
+    for JSON to SQLA dumps
     """
     model2schemaconverter = Model2SchemaConverter
     """
-        Override to use your own Model2SchemaConverter
-        (inherit from BaseModel2SchemaConverter)
+    Override to use your own Model2SchemaConverter
+    (inherit from BaseModel2SchemaConverter)
     """
     _apispec_parameter_schemas = {
         "get_info_schema": get_info_schema,
@@ -1015,16 +1103,20 @@ class ModelRestApi(BaseModelApi):
         "get_list_schema": get_list_schema,
     }
 
-    def __init__(self):
-        super(ModelRestApi, self).__init__()
+    def __init__(self) -> None:
+        super().__init__()
+        self._init_properties()
+        self._init_titles()
         self.validators_columns = self.validators_columns or {}
         self.model2schemaconverter = self.model2schemaconverter(
             self.datamodel, self.validators_columns
         )
 
-    def create_blueprint(self, appbuilder, *args, **kwargs):
+    def create_blueprint(
+        self, appbuilder: "AppBuilder", *args: Any, **kwargs: Any
+    ) -> Blueprint:
         self._init_model_schemas()
-        return super(ModelRestApi, self).create_blueprint(appbuilder, *args, **kwargs)
+        return super().create_blueprint(appbuilder, *args, **kwargs)
 
     @property
     def list_model_schema_name(self) -> str:
@@ -1042,8 +1134,8 @@ class ModelRestApi(BaseModelApi):
     def edit_model_schema_name(self) -> str:
         return f"{self.__class__.__name__}.put"
 
-    def add_apispec_components(self, api_spec):
-        super(ModelRestApi, self).add_apispec_components(api_spec)
+    def add_apispec_components(self, api_spec: APISpec) -> None:
+        super().add_apispec_components(api_spec)
         api_spec.components.schema(
             self.list_model_schema_name, schema=self.list_model_schema
         )
@@ -1057,7 +1149,26 @@ class ModelRestApi(BaseModelApi):
             self.show_model_schema_name, schema=self.show_model_schema
         )
 
-    def _init_model_schemas(self):
+    def _gen_labels_columns(self, list_columns: List[str]) -> None:
+        """
+        Auto generates pretty label_columns from list of columns
+        """
+        for col in list_columns:
+            if not self.label_columns.get(col):
+                self.label_columns[col] = self._prettify_column(col)
+
+    def _label_columns_json(self, cols: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Prepares dict with labels to be JSON serializable
+        """
+        ret = {}
+        cols = cols or []
+        d = {k: v for (k, v) in self.label_columns.items() if k in cols}
+        for key, value in d.items():
+            ret[key] = as_unicode(_(value).encode("UTF-8"))
+        return ret
+
+    def _init_model_schemas(self) -> None:
         # Create Marshmalow schemas if one is not specified
         if self.list_model_schema is None:
             self.list_model_schema = self.model2schemaconverter.convert(
@@ -1067,14 +1178,12 @@ class ModelRestApi(BaseModelApi):
             self.add_model_schema = self.model2schemaconverter.convert(
                 self.add_columns,
                 nested=False,
-                enum_dump_by_name=True,
                 parent_schema_name=self.add_model_schema_name,
             )
         if self.edit_model_schema is None:
             self.edit_model_schema = self.model2schemaconverter.convert(
                 self.edit_columns,
                 nested=False,
-                enum_dump_by_name=True,
                 parent_schema_name=self.edit_model_schema_name,
             )
         if self.show_model_schema is None:
@@ -1082,11 +1191,10 @@ class ModelRestApi(BaseModelApi):
                 self.show_columns, parent_schema_name=self.show_model_schema_name
             )
 
-    def _init_titles(self):
+    def _init_titles(self) -> None:
         """
-            Init Titles if not defined
+        Init Titles if not defined
         """
-        super(ModelRestApi, self)._init_titles()
         class_name = self.datamodel.model_name
         if not self.list_title:
             self.list_title = "List " + self._prettify_name(class_name)
@@ -1100,9 +1208,23 @@ class ModelRestApi(BaseModelApi):
 
     def _init_properties(self) -> None:
         """
-            Init Properties
+        Initializes all properties
         """
-        super(ModelRestApi, self)._init_properties()
+        self.label_columns = self.label_columns or {}
+        self.base_filters = self.base_filters or []
+        self.search_exclude_columns = self.search_exclude_columns or []
+        self.search_columns = self.search_columns or []
+
+        self._base_filters = self.datamodel.get_filters().add_filter_list(
+            self.base_filters
+        )
+        search_columns = self.datamodel.get_search_columns_list()
+        if not self.search_columns:
+            self.search_columns = [
+                x for x in search_columns if x not in self.search_exclude_columns
+            ]
+        self._gen_labels_columns(self.datamodel.get_columns_list())
+
         # Reset init props
         self.description_columns = self.description_columns or {}
         self.list_exclude_columns = self.list_exclude_columns or []
@@ -1149,45 +1271,57 @@ class ModelRestApi(BaseModelApi):
         self.edit_query_rel_fields = self.edit_query_rel_fields or dict()
         self.add_query_rel_fields = self.add_query_rel_fields or dict()
 
-    def merge_add_field_info(self, response, **kwargs):
-        _kwargs = kwargs.get("add_columns", {})
+    def _fetch_entities(self, model_class: Model, ids: List[int]):
+        if not ids:
+            return []
+        return (
+            current_app.appbuilder.session.query(model_class)
+            .filter(model_class.id.in_(ids))
+            .all()
+        )
+
+    def merge_add_field_info(self, response: Dict[str, Any], **kwargs: Any) -> None:
+        add_columns_info = kwargs.get("add_columns", {})
         response[API_ADD_COLUMNS_RES_KEY] = self._get_fields_info(
             self.add_columns,
             self.add_model_schema,
             self.add_query_rel_fields,
-            **_kwargs,
+            **add_columns_info,
         )
 
-    def merge_edit_field_info(self, response, **kwargs):
-        _kwargs = kwargs.get("edit_columns", {})
+    def merge_edit_field_info(self, response: Dict[str, Any], **kwargs: Any) -> None:
+        edit_columns_info = kwargs.get("edit_columns", {})
         response[API_EDIT_COLUMNS_RES_KEY] = self._get_fields_info(
             self.edit_columns,
             self.edit_model_schema,
             self.edit_query_rel_fields,
-            **_kwargs,
+            **edit_columns_info,
         )
 
-    def merge_search_filters(self, response, **kwargs):
+    def merge_search_filters(self, response: Dict[str, Any], **kwargs: Any) -> None:
         # Get possible search fields and all possible operations
-        search_filters = dict()
+        search_filters = {}
         dict_filters = self._filters.get_search_filters()
         for col in self.search_columns:
+            if col not in dict_filters:
+                # column not in search filters but defined has one
+                continue
             search_filters[col] = [
                 {"name": as_unicode(flt.name), "operator": flt.arg_name}
                 for flt in dict_filters[col]
             ]
         response[API_FILTERS_RES_KEY] = search_filters
 
-    def merge_add_title(self, response, **kwargs):
+    def merge_add_title(self, response: Dict[str, Any], **kwargs: Any) -> None:
         response[API_ADD_TITLE_RES_KEY] = self.add_title
 
-    def merge_edit_title(self, response, **kwargs):
+    def merge_edit_title(self, response: Dict[str, Any], **kwargs: Any) -> None:
         response[API_EDIT_TITLE_RES_KEY] = self.edit_title
 
-    def merge_label_columns(self, response, **kwargs):
-        _pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
-        if _pruned_select_cols:
-            columns = _pruned_select_cols
+    def merge_label_columns(self, response: Dict[str, Any], **kwargs: Any) -> None:
+        pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
+        if pruned_select_cols:
+            columns = pruned_select_cols
         else:
             # Send the exact labels for the caller operation
             if kwargs.get("caller") == "list":
@@ -1198,24 +1332,26 @@ class ModelRestApi(BaseModelApi):
                 columns = self.label_columns  # pragma: no cover
         response[API_LABEL_COLUMNS_RES_KEY] = self._label_columns_json(columns)
 
-    def merge_list_label_columns(self, response, **kwargs):
+    def merge_list_label_columns(self, response: Dict[str, Any], **kwargs: Any) -> None:
         self.merge_label_columns(response, caller="list", **kwargs)
 
-    def merge_show_label_columns(self, response, **kwargs):
+    def merge_show_label_columns(self, response: Dict[str, Any], **kwargs: Any) -> None:
         self.merge_label_columns(response, caller="show", **kwargs)
 
-    def merge_show_columns(self, response, **kwargs):
-        _pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
-        if _pruned_select_cols:
-            response[API_SHOW_COLUMNS_RES_KEY] = _pruned_select_cols
+    def merge_show_columns(self, response: Dict[str, Any], **kwargs: Any) -> None:
+        pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
+        if pruned_select_cols:
+            response[API_SHOW_COLUMNS_RES_KEY] = pruned_select_cols
         else:
             response[API_SHOW_COLUMNS_RES_KEY] = self.show_columns
 
-    def merge_description_columns(self, response, **kwargs):
-        _pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
-        if _pruned_select_cols:
+    def merge_description_columns(
+        self, response: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
+        if pruned_select_cols:
             response[API_DESCRIPTION_COLUMNS_RES_KEY] = self._description_columns_json(
-                _pruned_select_cols
+                pruned_select_cols
             )
         else:
             # Send all descriptions if cols are or request pruned
@@ -1223,38 +1359,38 @@ class ModelRestApi(BaseModelApi):
                 self.description_columns
             )
 
-    def merge_list_columns(self, response, **kwargs):
-        _pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
-        if _pruned_select_cols:
-            response[API_LIST_COLUMNS_RES_KEY] = _pruned_select_cols
+    def merge_list_columns(self, response: Dict[str, Any], **kwargs: Any) -> None:
+        pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
+        if pruned_select_cols:
+            response[API_LIST_COLUMNS_RES_KEY] = pruned_select_cols
         else:
             response[API_LIST_COLUMNS_RES_KEY] = self.list_columns
 
-    def merge_order_columns(self, response, **kwargs):
-        _pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
-        if _pruned_select_cols:
+    def merge_order_columns(self, response: Dict[str, Any], **kwargs: Any) -> None:
+        pruned_select_cols = kwargs.get(API_SELECT_COLUMNS_RIS_KEY, [])
+        if pruned_select_cols:
             response[API_ORDER_COLUMNS_RES_KEY] = [
                 order_col
                 for order_col in self.order_columns
-                if order_col in _pruned_select_cols
+                if order_col in pruned_select_cols
             ]
         else:
             response[API_ORDER_COLUMNS_RES_KEY] = self.order_columns
 
-    def merge_list_title(self, response, **kwargs):
+    def merge_list_title(self, response: Dict[str, Any], **kwargs: Any) -> None:
         response[API_LIST_TITLE_RES_KEY] = self.list_title
 
-    def merge_show_title(self, response, **kwargs):
+    def merge_show_title(self, response: Dict[str, Any], **kwargs: Any) -> None:
         response[API_SHOW_TITLE_RES_KEY] = self.show_title
 
-    def info_headless(self, **kwargs) -> Response:
+    def info_headless(self, **kwargs: Any) -> Response:
         """
-            response for CRUD REST meta data
+        response for CRUD REST meta data
         """
-        _response = dict()
-        _args = kwargs.get("rison", {})
-        self.set_response_key_mappings(_response, self.info, _args, **_args)
-        return self.response(200, **_response)
+        payload = {}
+        rison_args = kwargs.get("rison", {})
+        self.set_response_key_mappings(payload, self.info, rison_args, **rison_args)
+        return self.response(200, **payload)
 
     @expose("/_info", methods=["GET"])
     @protect()
@@ -1269,8 +1405,8 @@ class ModelRestApi(BaseModelApi):
     @merge_response_func(merge_search_filters, API_FILTERS_RIS_KEY)
     @merge_response_func(merge_add_title, API_ADD_TITLE_RIS_KEY)
     @merge_response_func(merge_edit_title, API_EDIT_TITLE_RIS_KEY)
-    def info(self, **kwargs):
-        """ Endpoint that renders a response for CRUD REST meta data
+    def info(self, **kwargs: Any) -> Response:
+        """Endpoint that renders a response for CRUD REST meta data
         ---
         get:
           description: >-
@@ -1326,7 +1462,7 @@ class ModelRestApi(BaseModelApi):
         """
         return self.info_headless(**kwargs)
 
-    def get_headless(self, pk, **kwargs) -> Response:
+    def get_headless(self, pk: ModelKeyType, **kwargs: Any) -> Response:
         """
             Get an item from Model
 
@@ -1334,29 +1470,39 @@ class ModelRestApi(BaseModelApi):
         :param kwargs: Query string parameter arguments
         :return: HTTP Response
         """
-        item = self.datamodel.get(pk, self._base_filters, self.show_select_columns)
+        response = {}
+        args = kwargs.get("rison", {})
+        # handle select columns
+        try:
+            select_columns, pruned_select_cols = self._handle_columns_args(
+                args,
+                self.show_select_columns,
+                self.show_columns,
+            )
+        except InvalidColumnArgsFABException as e:
+            return self.response_400(message=str(e))
+
+        item = self.datamodel.get(
+            pk,
+            self._base_filters,
+            select_columns,
+            self.show_outer_default_load,
+        )
         if not item:
             return self.response_404()
 
-        _response = dict()
-        _args = kwargs.get("rison", {})
-        select_cols = _args.get(API_SELECT_COLUMNS_RIS_KEY, [])
-        _pruned_select_cols = [col for col in select_cols if col in self.show_columns]
         self.set_response_key_mappings(
-            _response,
-            self.get,
-            _args,
-            **{API_SELECT_COLUMNS_RIS_KEY: _pruned_select_cols},
+            response, self.get, args, **{API_SELECT_COLUMNS_RIS_KEY: pruned_select_cols}
         )
-        if _pruned_select_cols:
-            _show_model_schema = self.model2schemaconverter.convert(_pruned_select_cols)
+        if pruned_select_cols:
+            show_model_schema = self.model2schemaconverter.convert(pruned_select_cols)
         else:
-            _show_model_schema = self.show_model_schema
+            show_model_schema = self.show_model_schema
 
-        _response["id"] = pk
-        _response[API_RESULT_RES_KEY] = _show_model_schema.dump(item, many=False)
-        self.pre_get(_response)
-        return self.response(200, **_response)
+        response["id"] = pk
+        response[API_RESULT_RES_KEY] = show_model_schema.dump(item, many=False)
+        self.pre_get(response)
+        return self.response(200, **response)
 
     @expose("/<int:pk>", methods=["GET"])
     @protect()
@@ -1367,7 +1513,7 @@ class ModelRestApi(BaseModelApi):
     @merge_response_func(merge_show_columns, API_SHOW_COLUMNS_RIS_KEY)
     @merge_response_func(merge_description_columns, API_DESCRIPTION_COLUMNS_RIS_KEY)
     @merge_response_func(merge_show_title, API_SHOW_TITLE_RIS_KEY)
-    def get(self, pk, **kwargs):
+    def get(self, pk: ModelKeyType, **kwargs: Any) -> Response:
         """Get item from Model
         ---
         get:
@@ -1440,40 +1586,47 @@ class ModelRestApi(BaseModelApi):
         """
         return self.get_headless(pk, **kwargs)
 
-    def get_list_headless(self, **kwargs) -> Response:
+    def get_list_headless(self, **kwargs: Any) -> Response:
         """
-            Get list of items from Model
+        Get list of items from Model
         """
-        _response = dict()
-        _args = kwargs.get("rison", {})
+        response = dict()
+        args = kwargs.get("rison", {})
         # handle select columns
-        select_cols = _args.get(API_SELECT_COLUMNS_RIS_KEY, [])
-        _pruned_select_cols = [col for col in select_cols if col in self.list_columns]
+        try:
+            select_columns, pruned_select_cols = self._handle_columns_args(
+                args,
+                self.list_select_columns,
+                self.list_columns,
+            )
+        except InvalidColumnArgsFABException as e:
+            return self.response_400(message=str(e))
+
         # map decorated metadata
         self.set_response_key_mappings(
-            _response,
+            response,
             self.get_list,
-            _args,
-            **{API_SELECT_COLUMNS_RIS_KEY: _pruned_select_cols},
+            args,
+            **{API_SELECT_COLUMNS_RIS_KEY: pruned_select_cols},
         )
         # Create a response schema with the computed response columns,
         # defined or requested
-        if _pruned_select_cols:
-            _list_model_schema = self.model2schemaconverter.convert(_pruned_select_cols)
+        if pruned_select_cols:
+            list_model_schema = self.model2schemaconverter.convert(pruned_select_cols)
         else:
-            _list_model_schema = self.list_model_schema
+            list_model_schema = self.list_model_schema
         # handle filters
         try:
-            joined_filters = self._handle_filters_args(_args)
+            joined_filters = self._handle_filters_args(args)
         except FABException as e:
             return self.response_400(message=str(e))
         # handle base order
         try:
-            order_column, order_direction = self._handle_order_args(_args)
+            order_column, order_direction = self._handle_order_args(args)
         except InvalidOrderByColumnFABException as e:
             return self.response_400(message=str(e))
         # handle pagination
-        page_index, page_size = self._handle_page_args(_args)
+        page_index, page_size = self._handle_page_args(args)
         # Make the query
         count, lst = self.datamodel.query(
             joined_filters,
@@ -1481,14 +1634,15 @@ class ModelRestApi(BaseModelApi):
             order_direction,
             page=page_index,
             page_size=page_size,
-            select_columns=self.list_select_columns,
+            select_columns=select_columns,
+            outer_default_load=self.list_outer_default_load,
         )
         pks = self.datamodel.get_keys(lst)
-        _response[API_RESULT_RES_KEY] = _list_model_schema.dump(lst, many=True)
-        _response["ids"] = pks
-        _response["count"] = count
-        self.pre_get_list(_response)
-        return self.response(200, **_response)
+        response[API_RESULT_RES_KEY] = list_model_schema.dump(lst, many=True)
+        response["ids"] = pks
+        response["count"] = count
+        self.pre_get_list(response)
+        return self.response(200, **response)
 
     @expose("/", methods=["GET"])
     @protect()
@@ -1500,7 +1654,7 @@ class ModelRestApi(BaseModelApi):
     @merge_response_func(merge_description_columns, API_DESCRIPTION_COLUMNS_RIS_KEY)
     @merge_response_func(merge_list_columns, API_LIST_COLUMNS_RIS_KEY)
     @merge_response_func(merge_list_title, API_LIST_TITLE_RIS_KEY)
-    def get_list(self, **kwargs):
+    def get_list(self, **kwargs: Any) -> Response:
         """Get list of items from Model
         ---
         get:
@@ -1586,8 +1740,7 @@ class ModelRestApi(BaseModelApi):
 
     def post_headless(self) -> Response:
         """
-            POST/Add item to Model
-        :return:
+        POST/Add item to Model
         """
         if not request.is_json:
             return self.response_400(message="Request is not JSON")
@@ -1598,7 +1751,7 @@ class ModelRestApi(BaseModelApi):
         # This validates custom Schema with custom validations
         self.pre_add(item)
         try:
-            self.datamodel.add(item, raise_exception=True)
+            self.datamodel.add(item)
             self.post_add(item)
             return self.response(
                 201,
@@ -1607,14 +1760,16 @@ class ModelRestApi(BaseModelApi):
                     "id": self.datamodel.get_pk_value(item),
                 },
             )
-        except IntegrityError as e:
-            return self.response_422(message=str(e.orig))
+        except DatabaseException as e:
+            return self.response_422(
+                message=f"Database exception occurred: {e.__cause__}"
+            )
 
     @expose("/", methods=["POST"])
     @protect()
     @safe
     @permission_name("post")
-    def post(self):
+    def post(self) -> Response:
         """POST item to Model
         ---
         post:
@@ -1648,9 +1803,9 @@ class ModelRestApi(BaseModelApi):
         """
         return self.post_headless()
 
-    def put_headless(self, pk) -> Response:
+    def put_headless(self, pk: ModelKeyType) -> Response:
         """
-            PUT/Edit item to Model
+        PUT/Edit item to Model
         """
         item = self.datamodel.get(pk, self._base_filters)
         if not request.is_json:
@@ -1664,20 +1819,22 @@ class ModelRestApi(BaseModelApi):
             return self.response_422(message=err.messages)
         self.pre_update(item)
         try:
-            self.datamodel.edit(item, raise_exception=True)
+            self.datamodel.edit(item)
             self.post_update(item)
             return self.response(
                 200,
                 **{API_RESULT_RES_KEY: self.edit_model_schema.dump(item, many=False)},
             )
-        except IntegrityError as e:
-            return self.response_422(message=str(e.orig))
+        except DatabaseException as e:
+            return self.response_422(
+                message=f"Database exception occurred: {e.__cause__}"
+            )
 
     @expose("/<pk>", methods=["PUT"])
     @protect()
     @safe
     @permission_name("put")
-    def put(self, pk):
+    def put(self, pk: ModelKeyType) -> Response:
         """PUT item to Model
         ---
         put:
@@ -1716,26 +1873,28 @@ class ModelRestApi(BaseModelApi):
         """
         return self.put_headless(pk)
 
-    def delete_headless(self, pk) -> Response:
+    def delete_headless(self, pk: ModelKeyType) -> Response:
         """
-            Delete item from Model
+        Delete item from Model
         """
         item = self.datamodel.get(pk, self._base_filters)
         if not item:
             return self.response_404()
         self.pre_delete(item)
         try:
-            self.datamodel.delete(item, raise_exception=True)
+            self.datamodel.delete(item)
             self.post_delete(item)
             return self.response(200, message="OK")
-        except IntegrityError as e:
-            return self.response_422(message=str(e.orig))
+        except DatabaseException as e:
+            return self.response_422(
+                message=f"Database exception occurred: {e.__cause__}"
+            )
 
     @expose("/<pk>", methods=["DELETE"])
     @protect()
     @safe
     @permission_name("delete")
-    def delete(self, pk):
+    def delete(self, pk: ModelKeyType) -> Response:
         """Delete item from Model
         ---
         delete:
@@ -1769,11 +1928,13 @@ class ModelRestApi(BaseModelApi):
     ------------------------------------------------
     """
 
-    def _handle_page_args(self, rison_args):
+    def _handle_page_args(
+        self, rison_args: Dict[str, Any]
+    ) -> Tuple[Optional[int], Optional[int]]:
         """
-            Helper function to handle rison page
-            arguments, sets defaults and impose
-            FAB_API_MAX_PAGE_SIZE
+        Helper function to handle rison page
+        arguments, sets defaults and impose
+        FAB_API_MAX_PAGE_SIZE
 
         :param rison_args:
         :return: (tuple) page, page_size
@@ -1782,26 +1943,28 @@ class ModelRestApi(BaseModelApi):
         page_size = rison_args.get(API_PAGE_SIZE_RIS_KEY, self.page_size)
         return self._sanitize_page_args(page, page_size)
 
-    def _sanitize_page_args(self, page, page_size):
-        _page = page or 0
-        _page_size = page_size or self.page_size
+    def _sanitize_page_args(
+        self, page: Optional[int], page_size: Optional[int]
+    ) -> Tuple[Optional[int], Optional[int]]:
+        page_ = page or 0
+        page_size_ = page_size or self.page_size
         max_page_size = self.max_page_size or current_app.config.get(
             "FAB_API_MAX_PAGE_SIZE"
         )
         # Accept special -1 to uncap the page size
         if max_page_size == -1:
-            if _page_size == -1:
+            if page_size_ == -1:
                 return None, None
             else:
-                return _page, _page_size
-        if _page_size > max_page_size or _page_size < 1:
-            _page_size = max_page_size
-        return _page, _page_size
+                return page_, page_size_
+        if page_size_ > max_page_size or page_size_ < 1:
+            page_size_ = max_page_size
+        return page_, page_size_
 
-    def _handle_order_args(self, rison_args):
+    def _handle_order_args(self, rison_args: Dict[str, Any]) -> Tuple[str, str]:
         """
-            Help function to handle rison order
-            arguments
+        Help function to handle rison order
+        arguments
 
         :param rison_args:
         :return:
@@ -1812,20 +1975,53 @@ class ModelRestApi(BaseModelApi):
             return self.base_order
         if not order_column:
             return "", ""
-        elif order_column not in self.order_columns:
+        elif self.order_columns and order_column not in self.order_columns:
             raise InvalidOrderByColumnFABException(
                 f"Invalid order by column: {order_column}"
             )
         return order_column, order_direction
 
-    def _handle_filters_args(self, rison_args):
+    def _handle_filters_args(self, rison_args: Dict[str, Any]) -> Filters:
         self._filters.clear_filters()
         self._filters.rest_add_filters(rison_args.get(API_FILTERS_RIS_KEY, []))
         return self._filters.get_joined_filters(self._base_filters)
 
-    def _description_columns_json(self, cols=None):
+    def _handle_columns_args(
+        self,
+        args: Dict[str, Any],
+        default_select_columns: List[str],
+        default_response_columns: List[str],
+    ) -> Tuple[List[str], List[str]]:
+        """
+        Handle the column args from the request.
+        """
+        select_columns_arg = args.get(API_SELECT_SEL_COLUMNS_RIS_KEY, [])
+        response_columns_arg = args.get(API_SELECT_COLUMNS_RIS_KEY, [])
+        if select_columns_arg and response_columns_arg:
+            raise InvalidColumnArgsFABException(
+                "Cannot use both select and sel columns"
+            )
+        select_columns = default_select_columns
+        response_columns = []
+        if select_columns_arg:
+            select_columns = [
+                col for col in select_columns_arg if col in default_select_columns
+            ]
+            response_columns = [
+                col for col in select_columns_arg if col in default_response_columns
+            ]
+        elif response_columns_arg:
+            response_columns = [
+                col for col in response_columns_arg if col in default_response_columns
+            ]
+
+        return select_columns, response_columns
+
+    def _description_columns_json(
+        self, cols: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
         """
-            Prepares dict with col descriptions to be JSON serializable
+        Prepares dict with col descriptions to be JSON serializable
         """
         ret = {}
         cols = cols or []
@@ -1834,18 +2030,29 @@ class ModelRestApi(BaseModelApi):
             ret[key] = as_unicode(_(value).encode("UTF-8"))
         return ret
 
-    def _get_field_info(self, field, filter_rel_field, page=None, page_size=None):
+    def _get_field_info(
+        self,
+        field: Field,
+        filter_rel_field: Dict[str, Any],
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Dict[str, Any]:
         """
-            Return a dict with field details
-            ready to serve as a response
+        Return a dict with field details
+        ready to serve as a response
 
         :param field: marshmallow field
         :return: dict with field details
         """
-        ret = dict()
-        ret["name"] = field.name
-        ret["label"] = _(self.label_columns.get(field.name, ""))
-        ret["description"] = _(self.description_columns.get(field.name, ""))
+        ret = {
+            "name": field.name,
+            "label": _(self.label_columns.get(field.name, "")),
+            "description": _(self.description_columns.get(field.name, "")),
+            "type": field.__class__.__name__,
+            "required": field.required,
+            # When using custom marshmallow schemas fields don't have unique property
+            "unique": getattr(field, "unique", False),
+        }
         # Handles related fields
         if isinstance(field, Related) or isinstance(field, RelatedList):
             ret["count"], ret["values"] = self._get_list_related_field(
@@ -1855,16 +2062,18 @@ class ModelRestApi(BaseModelApi):
             ret["validate"] = [str(v) for v in field.validate]
         elif field.validate:
             ret["validate"] = [str(field.validate)]
-        ret["type"] = field.__class__.__name__
-        ret["required"] = field.required
-        # When using custom marshmallow schemas fields don't have unique property
-        ret["unique"] = getattr(field, "unique", False)
         return ret
 
-    def _get_fields_info(self, cols, model_schema, filter_rel_fields, **kwargs):
+    def _get_fields_info(
+        self,
+        cols: List[str],
+        model_schema: Schema,
+        filter_rel_fields: QueryRelatedFieldsFilters,
+        **kwargs: Any,
+    ) -> List[Dict[str, Any]]:
         """
-            Returns a dict with fields detail
-            from a marshmallow schema
+        Returns a dict with fields detail
+        from a marshmallow schema
 
         :param cols: list of columns to show info for
         :param model_schema: Marshmallow model schema
@@ -1873,7 +2082,7 @@ class ModelRestApi(BaseModelApi):
         :param kwargs: Receives all rison arguments for pagination
         :return: dict with all fields details
         """
-        ret = list()
+        ret = []
         for col in cols:
             page = page_size = None
             col_args = kwargs.get(col, {})
@@ -1891,18 +2100,24 @@ class ModelRestApi(BaseModelApi):
         return ret
 
     def _get_list_related_field(
-        self, field, filter_rel_field, page=None, page_size=None
-    ):
+        self,
+        field: Field,
+        filter_rel_field: List[Any],
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+    ) -> Tuple[int, List[Dict[str, Any]]]:
         """
-            Return a list of values for a related field
+        Return a list of values for a related field
 
         :param field: Marshmallow field
-        :param filter_rel_field: Filters for the related field
+        :param filter_rel_field: Filters for the related field,
+                expects [field_name, Type[BaseFilter], value]
         :param page: The page index
         :param page_size: The page size
-        :return: (int, list) total record count and list of dict with id and value
+        :return: Total record count and list of dict with id and value
         """
-        ret = list()
+        ret = []
+        count = 0
         if isinstance(field, Related) or isinstance(field, RelatedList):
             datamodel = self.datamodel.get_related_interface(field.name)
             filters = datamodel.get_filters(datamodel.get_search_columns_list())
@@ -1921,13 +2136,12 @@ class ModelRestApi(BaseModelApi):
                 ret.append({"id": datamodel.get_pk_value(value), "value": str(value)})
         return count, ret
 
-    def _merge_update_item(self, model_item, data):
+    def _merge_update_item(
+        self, model_item: Model, data: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """
-            Merge a model with a python data structure
-            This is useful to turn PUT method into a PATCH also
-        :param model_item: SQLA Model
-        :param data: python data structure
-        :return: python data structure
+        Merge a model with a python data structure
+        This is useful to turn PUT method into a PATCH also
         """
         data_item = self.edit_model_schema.dump(model_item, many=False)
         for _col in self.edit_columns:
@@ -1941,56 +2155,56 @@ class ModelRestApi(BaseModelApi):
     ------------------------------------------------
     """
 
-    def pre_update(self, item):
+    def pre_update(self, item: Model) -> None:
         """
-            Override this, this method is called before the update takes place.
+        Override this, this method is called before the update takes place.
         """
         pass
 
-    def post_update(self, item):
+    def post_update(self, item: Model) -> None:
         """
-            Override this, will be called after update
+        Override this, will be called after update
         """
         pass
 
-    def pre_add(self, item):
+    def pre_add(self, item: Model) -> None:
         """
-            Override this, will be called before add.
+        Override this, will be called before add.
         """
         pass
 
-    def post_add(self, item):
+    def post_add(self, item: Model) -> None:
         """
-            Override this, will be called after update
+        Override this, will be called after update
         """
         pass
 
-    def pre_delete(self, item):
+    def pre_delete(self, item: Model) -> None:
         """
-            Override this, will be called before delete
+        Override this, will be called before delete
         """
         pass
 
-    def post_delete(self, item):
+    def post_delete(self, item: Model) -> None:
         """
-            Override this, will be called after delete
+        Override this, will be called after delete
         """
         pass
 
-    def pre_get(self, data):
+    def pre_get(self, data: Dict[str, Any]) -> None:
         """
-            Override this, will be called before data is sent
-            to the requester on get item endpoint.
-            You can use it to mutate the response sent.
-            Note that any new field added will not be reflected on the OpenApi spec.
+        Override this, will be called before data is sent
+        to the requester on get item endpoint.
+        You can use it to mutate the response sent.
+        Note that any new field added will not be reflected on the OpenApi spec.
         """
         pass
 
-    def pre_get_list(self, data):
+    def pre_get_list(self, data: Dict[str, Any]) -> None:
         """
-            Override this, will be called before data is sent
-            to the requester on get list endpoint.
-            You can use it to mutate the response sent
-            Note that any new field added will not be reflected on the OpenApi spec.
+        Override this, will be called before data is sent
+        to the requester on get list endpoint.
+        You can use it to mutate the response sent
+        Note that any new field added will not be reflected on the OpenApi spec.
         """
         pass