I'm happy to announce the next version of Diamond MVC.
Release: https://github.com/DiamondMVC/Diamond/releases/tag/v2.8.0
This is a breaking change to the cookie API, since it implements
cookie consent and not in a backward compatible way to make sure
it's enforced.
This release also contains backup functionality, which allows you
to implement backup services that can backup files, data etc.
By default there is a backup file service which can be used to
backup files, but it's possible to implement your own backup
services that can backup databases etc.
It was something I saw as necessary for Diamond to be used as an
enterprise framework, since backups are vital.
Diamond now supports vibe.d 0.8.3 and mysql-native 2.2.1
---
If you wonder what other features Diamond has, here are some of
the key features:
* Full control over requests / responses when wanted.
* "Websettings" file that lets you control requests / responses
for:
* Before a request is handled.
* After a request has been handled.
* When an error occurres.
* When a page or controller action wasn't found.
* When a static file has been requested.
* Multiple static file paths
* Let's you bind to multiple ip addresses and ports.
* Let's you control default headers for each type of request
(default, static files, errors, not found etc.)
* Uses vibe.d for backend, so it's very powerful and all vibe.d
features can be used with Diamond
* Easy control over the application's type using *static if*
constructs.
* isWeb (true for both web-servers and web-apis.)
* isWebServer (true for web-servers)
* isWebApi (true for web-apis)
* isWeb, isWebServer and isWebApi will be false for standalone.
* ACL & Authentication tied to it
* Separate authentication that can be used either with or without
the ACL
* CSRF Protection
* Easy integrated cookie/session API.
* The network can be restricted to specific ips.
* Transactions
* Unittesting
* Logging
* i18n
* Version-control
* Route rewriting
* Database Integration & Object Relational Mapping
* Websockets
* Specialized Routes (Can fetch resources external internal or
local)
* Views are parsed at compile-time, thus rendering of views are
super fast
* Views can have layout views
* Views have a metadata section that lets you change view
configurations such as its controller, model, layout, route and
placeholders.
* Views have placeholders and layout view's can access the render
view's placeholders.
* Views can encode their data
* Has a rich syntax that allows for complex and innovative
rendering.
* Easy access to the current request / response using the
properties: *httpRequest* and *httpResponse*
* Can render other views within itself
* Any type of D code can be written within views.
* Allows for sections, which is useful to only render a part of
the view. (Very useful for responsive designs)
* Can be passed to controllers by their base view
* Layout views can be changed dynamically
* Expensive views can be cached.
* Flash-messages
* Controller actions are mapped through attributes. (By default
the route name will be the name of the function.)
* If wanted actions can be mapped manually, but that's a legacy
feature.
* Controller actions can easily control how the response is
handled, as they require a status returned
* Status.success (Will continue to handle the request.)
* Status.end (Will end the request; useful for json responses
etc. *Note: using the json() function already does it for you.)*
* Status.notFound (Will issue a 404 status for the response.)
* Can map mandatory actions that are executed on every requests.
(Useful for authentication etc.)
* Easy integrated authentication (Can be combined with ACL)
* RESTful
* Specific actions can be restricted to specific ips.
Github: https://github.com/DiamondMVC/Diamond
DUB: https://code.dlang.org/packages/diamond
You can find the last release here:
https://forum.dlang.org/post/mjueykdyfbeajaofq...@forum.dlang.org
Thank you all!
