Roadmap
Discover and vote on upcoming features
Upcoming
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.
13
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.
29
Spring HATEOAS option
»Add an option to enable Spring HATEOAS for the endpoints, linking resources to each other.
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.
Additional Enum fields
»Currently Enums can only be created with their value. This setup could be extended to define additional fields and their type, so that they will already be available in the generated code. Example: enum Salutation { MR("001"), MS("002") ... }
Provide Dockerfile
»With a new option a Dockerfile can be added to the source code, providing a lightweight configuration for building and running the container.
Add Notes tab
»Provide a new menu item in the navigation, which opens a textarea to add custom notes about your project. They will be included as notes.md in the generated project, so more documentation or next steps are immediately available.
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.
Done
Spring Security with Keycloak
»Add the option to protect your application with Keycloak, including integration tests / Testcontainers support.
24
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.
11
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
»Htmx is a smart, minimalistic frontend library to improve backend integration by simple HTML attributes - without the need to write JavaScript as a developer. With a new checkbox this could already be prepared by Bootify.
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
»When using the frontend-stack with direct integration of Bootstrap, currently the JavaScript and CSS libraries are loaded from a CDN. While this gives a speed advantage, in many cases it's desirable to make the application available without internet access. By switching to WebJar, the frontend libraries can be provided internally with a Maven dependency.
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.
Provide Readme.md
»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.
16
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.
Support MongoDB
»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.
15
Application.properties option
»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.
Pagination option
»Add an option for pagination to the generated REST API. Provide a minimal Page class for the response which reflects the current pagination information.
Include Kotlin
»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.
Domain-driven packages
»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.
12
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.
11
In Progress
Submit missing feature
Are you missing a particular feature? Let us know!
