mononobi / pyrin Goto Github PK

add routes authorization structure and methods.

enable a latency, may be a config key, to start caching after some time of server startup, instead of immediate start.

implementing security package, permissions, hashing and encryption. the implementation must be abstract and unaware of database.
also consider implementing token generation, authorization and authentication packages.

should we move DEFAULT_COMPONENT_KEY to Component class form static.py setting?

implementing locale package and making gettext method globally accessible as _ without need to importing it.

implement migration package to support multi database using alembic.

implement request and response class attributes and businesses and assign a GUID to each request.

change implementation of get_file_path() service to be able to handle not loaded config stores and return their file path.

revise config_store.get() to let getting a key from active configuration without naming the section.

create template for every needed script and and command for creating project
(install, uninstall, install dependencies and ...)

add each new route into a list in api.swagger package to be able to generate api doc from it.
extract param names from args, and param types and keyword args from docs.
and register each api module as a dict key, and the values would be all api methods of that module with all info. this package must process the docs in after_packages_loaded() hook of packaging.

create scripts for code compilation and building the release.

Implement compression of request and response data using gzip.

add token type into payload and prevent using refresh token for any operation.

Implementing ID generators package for GUID and numbers.

implement a platform to be able to call services of current running app from terminal.
may be we could use the already available click plugin from flask and extend it.

implement caching package, for server, database and also HTTP caching.
also implement handlers for Memcached and simple cache to be used with decorators.

add a config key in api.config file to be prefixed to every registered route of app if provided.

implementing configuration reload hooks to let other packages refresh their needed configs.
for example Fernet encrypter key.

it could be implemented using file watchers to let configuration package knows about changes, and then configuration package fires appropriate hooks to inform other packages.

implementing hashing package with the ability to add extra algorithms in the future.

implementing authorization package.
implementation must be abstract and unaware of database.

create installation scripts for application daemon and configuration of nginx and uwsgi.

implementing logging package and configuring logger from logging.config file and setting flask default logger.

globalization.datetime package implementation.
it's also needed to change the usage of utils.datetime to this new package in request and response and other packages.

implementing database package, connection pool, base model, transaction management.

implement a base for download/upload mechanism.
may be we should extend the already available feature from flask itself.
or implementing a new feature considering the flask one.

implementing loading variables from dotenv. (inside application or configuration packages???)

implementing datatime handling using pytz.

add an optional input to @api decorator for providing doc value to be used in api doc generation.

create manage scripts for migrations using google.fire.

add response helper utils to generate error responses based on inputs.

self-containing handler into hash and encryption result and removing handler name from services.

implementing encryption package with the ability to provide extra algorithms in the future.

add request info into every log.
may be it's possible to use logging adapter.
or if not, logging in request and response and error handlers.
or may be implementing it in logger manager.

make hashing and encryption base64 aware, meaning that they return results always as base64 encoded string, and always handle values as base64 and decode them to bytes before usage.
implement it by adding a static callable attribute into base classes of handlers to make it possible to be overridden if needed.

implementing asymmetric and symmetric tokens and sub-classing them for HS256 and RS256.

implementing unit-tests infrastructure using pytest and implementing pyrin unit-tests.

implementing run script for application using a daemon.

implementing hooks for different packages as needed.

revise hooks implementation, maybe register them into a dict instead of list, to be able to replace them by different packages if needed? is it required? needs more investigation.

revise loading order of packages and sub-packages to prevent loading of sub-packages if main package is not loaded yet because of unsatisfied dependencies.

configure loggers for sqlalchemy loggers.

implement request info logging into all loggers.
it must be safe, meaning that if there is no request, no exception should be raised.

revise get_component() method to get custom key from request.
so on each request, custom_key should be injected into request from token.

add a new route handler which requires fresh tokens to be dispatched.
also consider modifying create route method to support this new route.
a validation must be done to prevent routes from being public but requiring fresh token in @api decorator.

implement a paging mechanism for queries with configurable params.

implementing authentication package.
the implementation must be abstract and unaware of database.

implement a caching mechanism to prevent generating an already requested sequence every time, instead get the already generated sequence each time.

implementing permissions package.

exceptions handling on encryption and decryption to raise meaning full exception.