I think this could be useful if it fits in just right. Would this be designed to sort of fit in as a JAMstack utility tool? Would want more details.

A couple links you might be interested in:

Netlify Forms - any JAMstack site hosted on Netlify has exactly what you described built it. They will find forms in your site with the data-netlify attribute and automatically start collecting its submissions in your dashboard for you. You can set them up to post to any webhook on all submissions so you can do whatever you need with the data after that.

October CMS - A newish php framework, built on top of Laravel. A big feature is that it makes the development experience almost trivially easy for common use cases of web server development, especially in building backend forms. It is amazingly powerful, while being incredibly easy to work with complex data and DB relations. Most forms, even really complex forms with many fields and related resources, can be implemented almost entirely in declarative code models and YAML config files.

I don't trust generated code either in most cases. It's too easy for scaffolds to fall out of date or require a lot of work to make the generated code do the additional stuff you need.

However, Java's annotation processing API is really nice for compile time code generation, so you know it is always up to date and works exactly as it should. Code generation that gets destroyed and recreated continually can be quite invaluable.

In my opinion, code generation can work but it shouldn't be static generation, only done once. It should be part of your build process.

Probably something you're not thinking about is the UX.

Too often websites mirror their database in terms of "here is a CRUD form that maps around a table in our db". That's the way it is for a lot of websites but a lot of research is showing how it's poor UX

Have a read about task based UIs. Rarely does someone want to read a form and edit one field, or two fields. They want to perform a meaningful business action which should have a specific form for it.

The reason I mention this is that it probably doesn't fit too well in your model. Not to discourage you! You're right that a lot of websites are how you describe, but it would be great it if we could move away from that!

Slight nitpick

some middleware to do business/database

"Middleware" generally should not be doing any business logic. I would not expect my middleware to be responsible for saving the form entries into databases.

Good luck!

I'd need an easy and transparent way to access the generated API myself - for those sudden special requirements that don't work with defaults and weren't planned in - without damaging readability.
Otherwise the framework would prove too inflexible for productive use and would fail fast

It's always interesting to have code generation tools. I was thinking the other day about that. To connect to a database and generate UX and basic code. Lots of mistakes could be avoided. Did it in other languages before but for my own usage. Problem with what I've seen in the market is that they force you to use some functions of their own. I'd love to see what you come up with.

I've been making web forms and calculators for my clients for quite a while now. I think such a tool would be great. I would also be willing to chip in if possible.

However, many clients require web forms that don't interface with a back-end, an example of this would be pricing calculators.

Do you think your tool would be of help in such a case?

Seems strange and a little overly complicated to define your front end code and have your back end code generated from it instead of vise versa.

This is especially the case when things like GraphQL or SimpleSchema allow you to define how your data should look on the backend and packages like uniforms take that definition and create your forms from that.

The closest implementation I've seen to solving this type of challenge was utilizing Django + Django Rest Framework.

After defining your models (docs.djangoproject.com/en/2.1/topi...) you can utilize the Django admin interface (docs.djangoproject.com/en/2.1/ref/...) for handling CRUD type behavior.

On the API side you can rely on your previously generated models to build out a CRUD API.
(django-rest-framework.org/api-guid...)

You can also generate your web forms from the models as well.
(docs.djangoproject.com/en/2.1/topi...)

I'm not too familiar with Spring Boot, but code-gen would make the compilation step take longer, not the server startup. Java code generation libraries (such as Dagger and Butterknife which are common on Android) actually dramatically increase application startup times, because all the hard work has been done at compile-time.

Taking Dagger as an example (dependency injection), the generated code doesn't require Reflection as a runtime-library would. It looks for @Inject annotations in your code, finds the @Modules which provide those dependencies, and writes new Java source files to create the object for you. Super fast, no reflection required. Spring Boot does runtime injection, and so uses Reflection to find the @Inject/@Autowired annotations, and then uses Reflection to call the constructor or set the fields as necessary, which is known to be slow. This is in addition to the many other things Spring is doing on server startup (classloading, resolving routes, connecting to databases, etc.).

Maybe I've spent too much time in the Java world with Spring and Hibernate, but I don't mind generated code. The main thing is to always be able to regenerate it, imho. Never modify it, and don't ask it to do anything it isn't designed for

Thanks everyone for commenting, I really appreciate all the different perspectives and suggestions.