Discover and vote on upcoming features
Add TypeScript option for Webpack
Spring Session support
»Add a dropdown for configuring Spring Session with Redis or the currently configured database.
Support multiple Security Methods
»Instead of allowing only a single security type, multiple methods should be configurable. First you can add one or more user sources, connecting to a certain table or defining an in-memory user. Second you can add one or more security methods, connect them to a user source and select on which endpoints they should apply to.
»The form-based login can be enhanced with a dropdown for supporting remember-me cookies: they can either be fully disabled, always active or active when the user enabled a checkbox.
Prepare Spring Native
»Spring Native is still work in progress, but already showing great benefits in startup time and memory consumption. With a new option the code base can be extended to enable this feature.
Support list and map types at entities
»List and map types should be selectable as a field type for entities. Although not all databases support them natively, they can be enabled with the proper library as JSON.
Playwright frontend testing
»If a frontend has been selected, Playwright should be available as a testing option. It'll open the frontend in a browser and provide high-level tests in a similar fashion to the REST API integration tests.
Read-only page for frontend
»Currently "viewing" the details of an entity is contained in the edit page. With a new option it should be possible to have a separate page for only reading the entity details.
Import of OpenAPI spec
»Similar to the SQL import, an OpenAPI Specification could be imported in the Controllers tab. The would generate all the REST controllers defined in the specification, with all the features supported by Bootify.
Domain driven with technical subpackages
»Currently there is the choice between a technical or domain driven package structure. A third option can be added, splitting up the packages by domain, but further dividing them by technical subpackages (service, model, ...).
Database naming schema
»More database naming schemas should be selectable, giving the option to follow corporate naming conventions.
»At the moment, the plural is formed by appending an 's'. By using a suitable library, the generated code is more readable and usable.
Option for mapped superclass
»Any entity can be marked as a @MappedSuperclass and is then available for inheritence by all other entities, taking over their properties without beeing a table themself. For Mongodb they are just an abstract class.
Support Actuator configuration
»Spring Boot Actuator is a useful library for running an application in production. This can be supported with an additional option and basic configuration options.
Spring HATEOAS option
»Add an option to enable Spring HATEOAS for the endpoints, linking resources to each other.
Docker Compose option
»A new option adds the spring-boot-docker-compose dependency as well as a preconfigured docker-compose.yml, so the devlopment environment is available at once.
Spring Security with Keycloak
»Add the option to protect your application with Keycloak, including integration tests / Testcontainers support.
Allow unidirectional relationships
»In certain use cases you may want to have an unidirectional relationship between two entities, so navigation is limited to one side. This option should be available for all types except Many-to-many.
Provide frontend datepicker
»When the frontend contains a form with a date type, a datepicker should be available to make the user experience more convinient.
Provide section for working with the code
»Developers often have similar questions when extending the generated code. A new section 'Next Steps' will give practical tipps and explainations when starting the development.
Enrich frontend with htmx
Add CRUD search filter
»When you have large datasets, you need better tools for finding a searched entry. A new search filter for the CRUD frontend and REST API would help out here – in a first, simple version only the ID field would be searched.
Use WebJar for direct Bootstrap integration
Custom modules for multi module option
»If multi module is enabled for a project, it should be possible to add custom modules via a text field. They are empty by default, but the structure and setup is already prepared.
»With the new frontend options, a readme on how to start development would make life easier.
Spring Security with form based login
»JWT is a good choice for a REST API, however a Spring MVC frontend or a mixed app can be protected with a classical form based login.
CRUD frontend generation
»Generate a simple frontend for selected entities, allowing CRUD operations (list, create, update, delete) in the browser. First version is based on Thymeleaf with a basic styling and could be used for an admin backend as well.
Query parameters for custom endpoints
»Sometimes it makes sense to access a REST API with query parameters. This can be for example a custom filter or a search, where no fixed resource is returned. Query parameters should be supported for the custom endpoints of the Professional plan.
Add RegistrationController to JWT
»Currently the JWT Security Feature comes without a RegistrationController, because it may look different depending on the project requirements. However Bootify can still provide an option to add a registration endpoint, which doesn't require authentication and does a proper password hashing.
»Add support for MongoDB as a document-oriented database. The schema migration should be done with Mongock, as this is the most mature solution at the moment.
»Many developers prefer application.properties over application.yml. This should be selectable with an option.
Support MapStruct for DTO mapping
»Currently the mapping from a JPA entity to a DTO is done in the service class manually. While this gives a lot of flexibility, with the new option for MapStruct the code is getting shorter and more descriptive.
Upgrade to Java 17
»As Java 17 is officially released and also a Long-Term-Support (LTS) Version, this should be the third option next to Java 8 and 11.
»Add an option for pagination to the generated REST API. Provide a minimal Page class for the response which reflects the current pagination information.
»Add MariaDB to the list of supported Databases.
»Add a possibility to select between Java or Kotlin as the preferred programming language. Use the Kotlin DSL in case of a Gradle build and hide the Lombok option for Kotlin projects.
Separate service and service interface
»The services generated for the CRUD controllers should have a separated interface and a service implementing it. This can be configurable with a dedicated option.
»Add an option for organizing the classes in a more domain-driven way, organizing the classes around the entity.
Use ResponseEntity at controllers
»Most developers prefer to use the ResponseEntity class in RestController methods, keeping the body and HTTP status together.
Add Many-to-many relation type
»In most cases it's preferable to create an intermediate table together with two Many-to-one relations, as this gives more flexibility in the long run. However a Many-to-many relation can be useful for simple assignments with a composite primary key.
Spring Security with JWT
»Add support for protecting the REST API with JWT, backed by Spring Security. Users can be loaded from the database.
Add integration tests
»Generate IT tests based on the controllers of the project (CRUD as well as custom controllers). A containerized instance of the database can be used based on Testcontainers.
Add Angular as a frontend option
»For certain web apps, it is a better idea to use Angular instead of Thymeleaf. This should be available as an additional option for the frontend.
Submit missing feature
Are you missing a particular feature? Let us know!