Changed the the entity_type kwarg to table_name joegasewicz#111

Author: kousikmitra

CHANGELOG.md

@@ -0,0 +1,3 @@
+**Unreleased**
+ - Changed the the `entity_type` kwarg to `table_name` in the public method `register_entity` 
+   [Ref issue #111](https://github.com/joegasewicz/Flask-JWT-Router/issues/111)

README.md

@@ -103,7 +103,7 @@ app.config["WHITE_LIST_ROUTES"] = [
 def register():
     """I'm registering a new user & returning a token!"""
     return jsonify({
-        "token": jwt_routes.register_entity(entity_id=1, entity_type='users')
+        "token": jwt_routes.register_entity(entity_id=1, table_name='users')
     })
 
 @app.route("/login", methods=["POST"])
@@ -114,7 +114,7 @@ def login():
     })
 ```
 
-*Warning: The `entity_type` must be the same as your tablename or `__tablename__` attribute's value.
+*Warning: The `table_name` must be the same as your tablename or `__tablename__` attribute's value.
 (With SqlAlchemy, you can define a `__tablename__` attribute directly or else
 the name is derived from your entity’s database table name).
 
@@ -129,7 +129,7 @@ Create a new entity & return a new token
             user.create_user() # your entity creation logic
 
             # Here we pass the id as a kwarg to `register_entity`
-            token: str = jwt_routes.register_entity(entity_id=user.id, entity_type="users")
+            token: str = jwt_routes.register_entity(entity_id=user.id, table_name="users")
 
             # Now we can return a new token!
             return {
@@ -169,7 +169,7 @@ If you are handling a request with a token in the headers you can call::
 If you are handling a request without a token in the headers you can call::
 
 ```python
-    jwt_routes.register_entity(entity_id=user_data.id, entity_type="users")
+    jwt_routes.register_entity(entity_id=user_data.id, table_name="users")
 ```
 
 

flask_jwt_router/_authentication.py

@@ -34,11 +34,11 @@ def register_entity(self, extensions: Config, exp: int, **kwargs):
         pass
 
     @abstractmethod
-    def update_entity(self, extensions: Config, exp: int, entity_type, **kwarg):
+    def update_entity(self, extensions: Config, exp: int, table_name, **kwarg):
         # pylint:disable=missing-function-docstring
         pass
 
-    def encode_token(self, extensions: Config, entity_id: Any, exp: int, entity_type: str):
+    def encode_token(self, extensions: Config, entity_id: Any, exp: int, table_name: str):
         # pylint:disable=missing-function-docstring
         pass
 
@@ -62,19 +62,19 @@ def __init__(self):
         # pylint:disable=useless-super-delegation
         super(JWTAuthStrategy, self).__init__()
 
-    def encode_token(self, extensions: Config, entity_id: Any, exp: int, entity_type) -> str:
+    def encode_token(self, extensions: Config, entity_id: Any, exp: int, table_name) -> str:
         """
         :param extensions: See :class:`~flask_jwt_router._extensions`
         :param entity_id: Normally the primary key `id` or `user_id`
         :param exp: The expiry duration set when encoding a new token
-        :param entity_type: The Model Entity `__tablename__`
+        :param table_name: The Model Entity `__tablename__`
         :return: str
         """
         self.entity_key = extensions.entity_key
         self.secret_key = extensions.secret_key
         # pylint: disable=line-too-long
         encoded = jwt.encode({
-            "entity_type": entity_type,
+            "table_name": table_name,
             self.entity_key: entity_id,
             # pylint: disable=no-member
             "exp": datetime.utcnow() + relativedelta(days=+exp)
@@ -85,28 +85,28 @@ def register_entity(self, extensions: Config, exp: int, **kwargs) -> str:
         """
         kwargs:
             - entity_id: Represents the entity's primary key
-            - entity_type: The table name of the entity
+            - table_name: The table name of the entity
         :param extensions: See :class:`~flask_jwt_router._extensions`
         :param exp: The expiry duration set when encoding a new token
         :param kwargs:
         :return: Union[str, None]
         """
         self.entity_id = kwargs.get("entity_id", None)
-        entity_type = kwargs.get("entity_type", None)
-        return self.encode_token(extensions, self.entity_id, exp, entity_type)
+        table_name = kwargs.get("table_name", None)
+        return self.encode_token(extensions, self.entity_id, exp, table_name)
 
     def update_entity(self,
                       extensions: Config,
                       exp: int,
-                      entity_type: str,
+                      table_name: str,
                       **kwargs,
                       ) -> str:
         """
         :param extensions:
         :param exp:
-        :param entity_type:
+        :param table_name:
         :param kwargs:
         :return: Union[str, None]
         """
         self.entity_id = kwargs.get("entity_id", None)
-        return self.encode_token(extensions, self.entity_id, exp, entity_type)
+        return self.encode_token(extensions, self.entity_id, exp, table_name)

flask_jwt_router/_entity.py

@@ -12,7 +12,7 @@
 class BaseEntity(ABC):
     # pylint:disable=missing-class-docstring
     @abstractmethod
-    def get_attr_name(self, entity_type: str = None) -> str:
+    def get_attr_name(self, table_name: str = None) -> str:
         # pylint:disable=missing-function-docstring
         pass
 
@@ -22,7 +22,7 @@ def get_entity_from_token(self, decoded_token: str) -> str:
         pass
 
     @abstractmethod
-    def get_entity_from_ext(self, entity_type: str = None) -> _ORMType:
+    def get_entity_from_ext(self, table_name: str = None) -> _ORMType:
         # pylint:disable=missing-function-docstring
         pass
 
@@ -44,7 +44,7 @@ class Entity(BaseEntity):
     def __init__(self, extensions: ClassVar):
         self.extensions = extensions
 
-    def get_attr_name(self, entity_type: str = None) -> str:
+    def get_attr_name(self, table_name: str = None) -> str:
         """
         If SQLAlchemy is the ORM then expect there to be a
         __mapper__.primary_key path. This returns a list
@@ -53,11 +53,11 @@ def get_attr_name(self, entity_type: str = None) -> str:
         existing option of specifying a primary key name directly
         for scenarios when not using SqlAlchemy etc & also assigns
         a default primary key to `id`.
-        :param entity_type:
+        :param table_name:
         :return:
         """
         if not self.auth_model:
-            self.auth_model = self.get_entity_from_ext(entity_type)
+            self.auth_model = self.get_entity_from_ext(table_name)
         if hasattr(self.auth_model, "__mapper__"):
             # SqlAlchemy is the ORM being used
             return self.auth_model.__mapper__.primary_key[0].name
@@ -72,26 +72,26 @@ def _get_from_model(self, entity_id: int) -> _ORMType:
         result = self.auth_model.query.filter_by(**{entity_key: entity_id}).one()
         return result
 
-    def get_entity_from_ext(self, entity_type: str = None) -> _ORMType:
+    def get_entity_from_ext(self, table_name: str = None) -> _ORMType:
         """
         Exception raised if SQLAlchemy ORM not being used
         (SQLAlchemy will throw if `__tablename__` doesn't exist
         or it can't create the name from the db engine's table object.
         :return: {_ORMType}
         """
-        if not entity_type:
-            # In case `update_entity()` is called, `entity_type` is in the token
-            entity_type = self.decoded_token.get("entity_type")
+        if not table_name:
+            # In case `update_entity()` is called, `table_name` is in the token
+            table_name = self.decoded_token.get("table_name")
         auth_model = None
 
         for model in self.extensions.entity_models:
             if hasattr(model, "__tablename__"):
-                if entity_type == model.__tablename__:
+                if table_name == model.__tablename__:
                     auth_model = model
             else:
                 raise Exception(
                     "[FLASK-JWT-ROUTER ERROR]: Your Entity model must have a `__tablename__` that"
-                    " is equal to the entity_type specified in register_entity()."
+                    " is equal to the table_name specified in register_entity()."
                     "For details visit:\n"
                     # pylint:disable=line-too-long
                     "https://flask-jwt-router.readthedocs.io/en/latest/jwt_routes.html#authorization-tokens"

flask_jwt_router/_jwt_router.py

@@ -2,6 +2,7 @@
     The super class for Flask-JWT-Router
 """
 import logging
+from warnings import warn
 
 from ._extensions import BaseExtension, Extensions, Config
 from ._entity import BaseEntity, Entity
@@ -102,10 +103,14 @@ def register_entity(self, **kwargs) -> str:
         :param kwargs:
         :return: str
         """
-        if 'entity_type' not in kwargs:
-            raise KeyError("register_entity() missing 1 required argument: entity_type")
-        entity_type = kwargs.get("entity_type")
-        self.extensions.entity_key = self.entity.get_attr_name(entity_type)
+        if 'entity_type' in kwargs:
+            warn(("'entity_type' argument name has been deprecated and will be replaced"
+                  "in the next release. Use 'table_name' instead"))
+            kwargs['table_name'] = kwargs['entity_type']
+        if 'table_name' not in kwargs:
+            raise KeyError("register_entity() missing 1 required argument: table_name")
+        table_name = kwargs.get("table_name")
+        self.extensions.entity_key = self.entity.get_attr_name(table_name)
         return self.auth.register_entity(self.extensions, self.exp, **kwargs)
 
     def update_entity(self, **kwargs) -> str:
@@ -114,14 +119,14 @@ def update_entity(self, **kwargs) -> str:
         :return: str
         """
         self.extensions.entity_key = self.entity.get_attr_name()
-        entity_type = self.entity.get_entity_from_ext().__tablename__
-        return self.auth.update_entity(self.extensions, self.exp, entity_type, **kwargs)
+        table_name = self.entity.get_entity_from_ext().__tablename__
+        return self.auth.update_entity(self.extensions, self.exp, table_name, **kwargs)
 
     def encode_token(self, entity_id) -> str:
         """
         :param entity_id:
         :return:
         """
         self.extensions.entity_key = self.entity.get_attr_name()
-        entity_type = self.entity.get_entity_from_ext().__tablename__
-        return self.auth.encode_token(self.extensions, entity_id, self.exp, entity_type)
+        table_name = self.entity.get_entity_from_ext().__tablename__
+        return self.auth.encode_token(self.extensions, entity_id, self.exp, table_name)

flask_jwt_router/_jwt_routes.py

@@ -112,7 +112,7 @@ def register():
                 user.create_user() # your entity creation logic
 
                 # Here we pass the id as a kwarg to `register_entity`
-                token: str = jwt_routes.register_entity(entity_id=user.id, entity_type="user")
+                token: str = jwt_routes.register_entity(entity_id=user.id, table_name="user")
 
                 # Now we can return a new token!
                 return {
@@ -137,7 +137,7 @@ def login():
                        }, 401
             return {
                 "data": user_dumped,
-                "token": jwt_routes.register_entity(entity_id=user_data.id, entity_type="user"),
+                "token": jwt_routes.register_entity(entity_id=user_data.id, table_name="user"),
             }, 200
 
     If you are handling a request with a token in the headers you can call::
@@ -146,7 +146,7 @@ def login():
 
     If you are handling a request without a token in the headers you can call::
 
-    jwt_routes.register_entity(entity_id=user_data.id, entity_type="user")
+    jwt_routes.register_entity(entity_id=user_data.id, table_name="user")
 
 """
 from ._authentication import JWTAuthStrategy

tests/fixtures/main_fixture.py

@@ -43,7 +43,7 @@ def test_entity():
     from tests.fixtures.models import TeacherModel
     teacher = TeacherModel(name="joe")
     teacher.save()
-    token = jwt_routes.register_entity(entity_id=1, entity_type="teachers")
+    token = jwt_routes.register_entity(entity_id=1, table_name="teachers")
     return jsonify({
         "token": token,
     })

tests/fixtures/token_fixture.py

@@ -5,7 +5,7 @@
 
 
 new_token = jwt.encode({
-            "entity_type": "test_entities",
+            "table_name": "test_entities",
             "id": 1,
             "exp": datetime.utcnow() + relativedelta(days=+30)
         },
@@ -29,7 +29,7 @@ def mock_decoded_token():
 
 
 new_token_two = jwt.encode({
-            "entity_type": "test_two_entities",
+            "table_name": "test_two_entities",
             "id": 1,
             "exp": datetime.utcnow() + relativedelta(days=+30)
         },
@@ -53,7 +53,7 @@ def mock_decoded_token_two():
 
 
 new_token_three = jwt.encode({
-            "entity_type": "test_3_entities",
+            "table_name": "test_3_entities",
             "teacher_id": 1,
             "exp": datetime.utcnow() + relativedelta(days=+30)
         },

tests/test_entity.py

@@ -90,7 +90,7 @@ def test_get_attr_name(self, test_client):
                 algorithms="HS256"
             )
 
-        assert decoded_token["entity_type"] == "teachers"
+        assert decoded_token["table_name"] == "teachers"
 
         headers = {
             "Content-Type": "application/json",
@@ -110,5 +110,5 @@ def test_get_attr_name(self, test_client):
                 algorithms="HS256"
             )
 
-        assert decoded_token_two["entity_type"] == "teachers"
+        assert decoded_token_two["table_name"] == "teachers"