Should be easy

1. Angel routing API needs to kick butt (done)
2. Client needs to kick butt (done)
3. WebSockets need to kick butt
4. Deployment needs to kick butt
5. Passing params to services needs to kick butt (done)

Need to add a fix for this...

A simple Map will do...

Add to buffer instead.

/// Sends a download as a response.
  download(File file, {String filename}) {
    header("Content-Disposition",
        'Content-Disposition: attachment; filename="${filename ?? file.path}"');
    header(HttpHeaders.CONTENT_TYPE, lookupMimeType(file.path));
    header(HttpHeaders.CONTENT_LENGTH, file.lengthSync().toString());
    responseData.add(file.readAsBytesSync());
  }

Content-Disposition header should start with "attachment", not "Content-Disposition"

Explain it skips finalizers

@Hooks(const [myHook])
class MyService extends Service {
  @Hooks(const [auth.ownerOnly])
  modify(id, data, [params]) {}
}

This should be processed in the HookedService constructor.

https://github.com/angel-dart/angel_framework/blob/master/lib/src/http/server.dart#L335

doesn't use the provided paths...

This really should integrate with Nero at some point, things like req.io look better than 'underlyingRequest', etc.

Current:

startServer(InternetAddress address, int port) async {
  var server =
  await _serverGenerator(address ?? InternetAddress.LOOPBACK_IP_V4, port);
  this.httpServer = server;

  server.listen(handleRequest);

  return server;
}

Want:

Future<HttpServer> startServer([InternetAddress address, int port]);

Turns out the http_server package already has file upload support. I'm wondering, either drop my own body_parser, or somehow integrate theirs into mine.

Having one of these would be very nice. The goal would be to make it only build a request handler once, so we wouldn't have to call dart:mirrors on every request.

Controllers already search req.properties for parameters, so we could just use this that way.

class RequestContext {
  void inject(String name, dependency) {
    properties[name] = dependency;  
  }
}

A base DependencyInjector class could be included in the framework. This is just a hyped-up middleware.

class DependencyInjector {
 /// Determines whether the given dependency should be automatically injected into the given request.
  Future<bool> shouldInject(RequestContext req) async => true;

  /// Load necessary resources
  Future inject(Angel app, RequestContext req, ResponseContext res) {}

  Future call(Angel app) async {
    app.before.add((RequestContext req, res) async {
      if (await shouldInject(req))
        await inject(app, req, res);
      return true;
    });
  }
}

For example, you can use this to easily create a singleton instance.

class SingletonInjector extends DependencyInjector {
  Map foo = {"bar": "baz"};

  @override
  inject(app, req, res) {
    req.inject("FOO", foo);
    return super.inject(app, req, res);
  }
}

@Expose("/news")
class MyController {

  @Expose("/:id")
  read(String id, Map FOO) async {
    // FOO auto-injected
    return "The news of the day is $FOO.";
  }
}

This means demon can optionally drop in io deps

Should be able to cleanly execute a route, also maybe route.join or similar path-like functions. Might also extend from Pattern?

Would be useful for streaming large files, such as videos. There is probably some functionality in dart:async for this

Probably make a better API for sending to client, so there is only one method that writes to a response

That way you only have to parse the body if it's really necessary

Maybe just include this in multiserver

https://github.com/angel-dart/framework/blob/master/lib/src/http/server.dart#L238

Need to use the perfected flatten to get this working...

1. They are verbose
2. They are ugly
3. They are disorganized
4. They do not test everything

Just a list of requesthandlers

Have a void configureRoutes(Router router)

Inject it too

To get headers