The Angel framework for server-side Dart programming has officially been in 1.0 since early this year. Angel is still alive and kicking, and underwent several updates throughout June. More features are now available to help you complete projects with minimal headache and a short turnaround time, including:

Hot Reloading

Automatic (De)serialization

A declarative, source-generated PostgreSQL ORM

shelf integration

integration And much more…

Hot Reloading

This month, I published package:angel_hot , which adds hot-reloading capabilities to any Angel server. You can now edit application logic during development without having to manually restart your server after every file change.

The previous approach was to mount directory watchers on the system, and start/stop an entire process on each change. While this method worked, the new API affords much faster startup times, and ensures that the running version of your server is always an instance that is up-to-date.

Projects created with angel init include hot-reload configuration pre-written. Check out the angel-dart/hot repo: https://github.com/angel-dart/hot

Two Boilerplates

It used to be that projects created via angel init contained a tremendous amount of boilerplate logic that was mostly uncommented, and was hard to understand without prior Angel experience. In June, I went through and added comments to the entire project.

In addition, I created a second starter project, boilerplate_light , which is minimal and only contains the most commonly-used Angel packages. When creating a project with angel init , you now have the option to choose between this and the original boilerplate.

See the new boilerplate: https://github.com/angel-dart/boilerplate_light

Static Server, Dynamic Assets, and Ranges

Angel has a complete static server plug-in that supports caching; it now supports serving virtual assets. Version 1.2.0 introduces a simplistic FileTransformer API, somewhat reminiscent of gulp and package:build. There is also functionality available to build assets to disk. This isn’t intended to replace something like pub serve , but it can be useful for assets like Stylus stylesheets that must be compiled when requested.

Check it out: https://github.com/angel-dart/static

I was also able to write, test, and publish package:angel_range , which exposes a response handler (ideally used as a response finalizer) that processes Range headers and produces corresponding responses.

Try it out: https://pub.dartlang.org/packages/angel_range

Angel CLI

The Angel CLI no longer checks for updates every time you run it. Instead, run angel update to check for updates, and optionally download a new version.

See its repo: https://github.com/angel-dart/cli

Task Engine Upgrades

In July, Angel’s task engine was beefed up, and in addition to being able to schedule recurring and one-off tasks, can now communicate across isolates. You can use the AngelTaskClient to trigger tasks in remote isolates, and when combined with Angel’s dependency injection, you can even run tasks (and read their results) within route handlers and hooks. The AngelTaskScheduler will continue to work with Angel’s dependency injection system as well.

Find more documentation in its repo: https://github.com/angel-dart/task

Full Shelf Integration

Angel was already able to run shelf handlers (by means of dart:io ), but package:angel_shelf is now a full-fledged shelf adapter. embedShelf can still be used to wrap a handler into an Angel request handler, and will now run faster. supportShelf is a plug-in that patches an Angel instance to inject a shelf.Request into handlers, and allows you to return a shelf.Response from any handler, regardless of whether it is a shelf handler or not.

Check it out: https://github.com/angel-dart/shelf

There’s now an example out using the shelf integration to build a private pub server: https://github.com/thosakwe/angel_pub_server

Toggling Services

package:angel_toggle is a new package that allows you to choose between two services, depending on if your application is running in “test mode.” In short, it makes it easy to run against a database in production and development, but against an in-memory service while testing.

Check it out: https://pub.dartlang.org/packages/angel_toggle

Persistent File Services

package:angel_file_service exposes a single JsonFileService class that persists changes to a JSON file on-disk. This is nice for publishing tutorials, because you no longer have to expect end users to have a specific database installed on their system. This might also be useful for developers trying Angel for the first time.

Check it out: https://pub.dartlang.org/packages/angel_file_service

Awesome Angel

July also saw an “awesome list” being born for the Angel framework! Feel free to send a pull request, especially if you have a cool project using the framework!

Check it out: https://github.com/angel-dart/awesome-angel

Codelab

Work has begun on a codelab in which users build a code coverage SaaS with Angel as a backend. Ideally it will be published before the end of July.

You can track its progress here: https://github.com/angel-example/coverage_codelab

Much-Improved Serialization

Angel now ships with a package:source_gen -powered serialization library. package:angel_serialize works with Angel’s Model classes, and can replace a TypedService to provide cross-platform (de)serialization. It also supports nested model classes, Lists and Maps, and generates several constructors for your convenience.

Take a peek here: https://github.com/angel-dart/serialize

PostgreSQL ORM

Also under heavy development is package:angel_orm . This is powered by source_gen as well, and generates the following:

Strongly-typed query building (select, insert, etc.)

SQL migration scripts

Angel services (coming soon)

Track its progress here: https://github.com/angel-dart/orm

Coming Soon: In-Memory Caching

Planned for July-August is cherubim , an in-memory cache (a la Memcached) which developers will eventually be able to use to synchronize data, events, and services across multiple instances. cherubim will support isolates, TCP Sockets, WebSockets, and a REST API.

Check it out here, if you’re brave: https://github.com/angel-dart/cherubim