platform/lib/src/http/routable.dart

165 lines
5.4 KiB
Dart
Raw Normal View History

library angel_framework.http.routable;
import 'dart:async';
2016-10-22 20:41:36 +00:00
import 'package:angel_route/angel_route.dart';
import 'package:meta/meta.dart';
import '../util.dart';
import 'angel_base.dart';
import 'controller.dart';
import 'hooked_service.dart';
import 'metadata.dart';
import 'request_context.dart';
import 'response_context.dart';
import 'service.dart';
2016-12-10 14:05:40 +00:00
2016-11-28 00:49:27 +00:00
final RegExp _straySlashes = new RegExp(r'(^/+)|(/+$)');
2016-02-28 13:11:17 +00:00
/// A function that intercepts a request and determines whether handling of it should continue.
typedef Future<bool> RequestMiddleware(RequestContext req, ResponseContext res);
/// A function that receives an incoming [RequestContext] and responds to it.
typedef Future RequestHandler(RequestContext req, ResponseContext res);
2017-03-28 23:29:22 +00:00
/// Sequentially runs a list of [handlers] of middleware, and returns early if any does not
2017-01-14 00:36:38 +00:00
/// return `true`. Works well with [Router].chain.
RequestMiddleware waterfall(List handlers) {
2017-03-28 23:29:22 +00:00
return (RequestContext req, res) async {
2017-01-14 00:36:38 +00:00
for (var handler in handlers) {
2017-03-28 23:29:22 +00:00
var result = await req.app.executeHandler(handler, req, res);
2017-01-14 00:36:38 +00:00
if (result != true) return result;
}
return true;
};
}
2016-02-28 13:11:17 +00:00
/// A routable server that can handle dynamic requests.
2016-10-22 20:41:36 +00:00
class Routable extends Router {
2016-11-28 00:49:27 +00:00
final Map<Pattern, Controller> _controllers = {};
2016-10-22 20:41:36 +00:00
final Map<Pattern, Service> _services = {};
final Map properties = {};
2016-10-22 20:41:36 +00:00
Routable({bool debug: false}) : super(debug: debug);
2016-02-28 13:11:17 +00:00
2016-10-22 20:41:36 +00:00
/// Additional filters to be run on designated requests.
@override
final Map<String, RequestMiddleware> requestMiddleware = {};
2016-04-18 03:27:23 +00:00
/// A set of [Service] objects that have been mapped into routes.
2016-11-23 09:10:47 +00:00
Map<Pattern, Service> get services => _services;
2016-04-18 03:27:23 +00:00
2016-06-27 00:20:42 +00:00
/// A set of [Controller] objects that have been loaded into the application.
2016-11-28 00:49:27 +00:00
Map<Pattern, Controller> get controllers => _controllers;
2016-06-27 00:20:42 +00:00
2016-10-22 20:41:36 +00:00
StreamController<Service> _onService =
new StreamController<Service>.broadcast();
2016-07-05 22:11:54 +00:00
/// Fired whenever a service is added to this instance.
///
/// **NOTE**: This is a broadcast stream.
Stream<Service> get onService => _onService.stream;
2016-04-18 03:27:23 +00:00
/// Assigns a middleware to a name for convenience.
2016-10-22 20:41:36 +00:00
@override
registerMiddleware(String name, @checked RequestHandler middleware) =>
2016-10-22 20:41:36 +00:00
super.registerMiddleware(name, middleware);
2016-04-18 03:27:23 +00:00
/// Retrieves the service assigned to the given path.
2017-01-28 03:47:00 +00:00
Service service(Pattern path) =>
_services[path] ??
_services[path.toString().replaceAll(_straySlashes, '')];
2016-04-18 03:27:23 +00:00
2016-06-27 00:20:42 +00:00
/// Retrieves the controller with the given name.
Controller controller(String name) => controllers[name];
2016-10-22 20:41:36 +00:00
@override
Route addRoute(String method, Pattern path, Object handler,
2016-11-23 09:10:47 +00:00
{List middleware: const []}) {
2016-10-22 20:41:36 +00:00
final List handlers = [];
// Merge @Middleware declaration, if any
Middleware middlewareDeclaration = getAnnotation(handler, Middleware);
if (middlewareDeclaration != null) {
handlers.addAll(middlewareDeclaration.handlers);
}
2016-11-23 09:10:47 +00:00
final List handlerSequence = [];
handlerSequence.addAll(middleware ?? []);
handlerSequence.addAll(handlers);
return super.addRoute(method, path, handler, middleware: handlerSequence);
2016-10-22 20:41:36 +00:00
}
2017-09-22 04:48:22 +00:00
/// Mounts the given [router] on this instance.
///
/// The [router] may only omitted when called via
/// an [Angel] instance.
///
/// Returns either a [Route] or a [Service] (if one was mounted).
use(Pattern path, [Router router, String namespace = null]) {
2016-10-22 20:41:36 +00:00
Router _router = router;
Service service;
2016-06-21 04:19:43 +00:00
// If we need to hook this service, do it here. It has to be first, or
// else all routes will point to the old service.
2016-10-22 20:41:36 +00:00
if (router is Service) {
2017-09-22 04:48:22 +00:00
_router = service = new HookedService(router);
2016-10-22 20:41:36 +00:00
_services[path
.toString()
.trim()
.replaceAll(new RegExp(r'(^/+)|(/+$)'), '')] = service;
2016-11-23 09:10:47 +00:00
service.addRoutes();
2017-02-23 00:37:15 +00:00
if (_router is HookedService && _router != router)
router.onHooked(_router);
2016-06-21 04:19:43 +00:00
}
2016-10-22 20:41:36 +00:00
final handlers = [];
2016-11-23 09:10:47 +00:00
2016-10-22 20:41:36 +00:00
if (_router is AngelBase) {
handlers.add((RequestContext req, ResponseContext res) async {
req.app = _router;
res.app = _router;
return true;
});
}
// Let's copy middleware, heeding the optional middleware namespace.
2016-10-22 20:41:36 +00:00
String middlewarePrefix = namespace != null ? "$namespace." : "";
2016-10-22 20:41:36 +00:00
Map copiedMiddleware = new Map.from(router.requestMiddleware);
for (String middlewareName in copiedMiddleware.keys) {
2017-06-06 12:42:33 +00:00
requestMiddleware.putIfAbsent("$middlewarePrefix$middlewareName",
() => copiedMiddleware[middlewareName]);
}
// Also copy properties...
if (router is Routable) {
Map copiedProperties = new Map.from(router.properties);
for (String propertyName in copiedProperties.keys) {
properties.putIfAbsent("$middlewarePrefix$propertyName",
2017-09-22 04:48:22 +00:00
() => copiedMiddleware[propertyName]);
}
}
2016-11-23 09:10:47 +00:00
// _router.dumpTree(header: 'Mounting on "$path":');
// root.child(path, debug: debug, handlers: handlers).addChild(router.root);
2017-09-22 04:48:22 +00:00
var mounted = mount(path, _router);
2016-04-18 03:27:23 +00:00
if (_router is Routable) {
2016-10-22 20:41:36 +00:00
// Copy services, too. :)
for (Pattern servicePath in _router._services.keys) {
String newServicePath =
path.toString().trim().replaceAll(new RegExp(r'(^/+)|(/+$)'), '') +
'/$servicePath';
_services[newServicePath] = _router._services[servicePath];
}
}
if (service != null) {
if (_onService.hasListener) _onService.add(service);
}
2017-09-22 04:48:22 +00:00
return service ?? mounted;
}
2016-10-22 20:41:36 +00:00
}