Breaking changes to functions_framework (#177)

See the changelog for all of the details

tl;dr: enables future flexibility because we no longer require
const constructors

Author: kevmoo

functions_framework/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Changelog
 
-## 0.3.2-dev
+## 0.4.0-dev
+
+- **BREAKING** `RequestContext`: removed deprecated `headers` and `headersAll`
+  properties.
+- **BREAKING** `serve.dart`:
+  - Changed the signature for `serve` function accept
+    `FunctionTarget Function(String) nameToFunctionTarget` instead of
+    `Set<FunctionTarget> targets`. This will allow more flexibility in future
+    `FunctionTarget` implementations.
+  - `FunctionTarget` no longer has a `const` constructor. The `name` parameter
+    has also been removed.
 
 - Allow the latest versions of `args`, `http`, `http_parser`, and `shelf` 
   packages.

functions_framework/lib/serve.dart

@@ -35,9 +35,12 @@ export 'src/function_target.dart'
 /// If there are no configuration errors, this function will not return until
 /// the process has received signal [ProcessSignal.sigterm] or
 /// [ProcessSignal.sigint].
-Future<void> serve(List<String> args, Set<FunctionTarget> targets) async {
+Future<void> serve(
+  List<String> args,
+  FunctionTarget Function(String) nameToFunctionTarget,
+) async {
   try {
-    await _serve(args, targets);
+    await _serve(args, nameToFunctionTarget);
   } on BadConfigurationException catch (e) {
     stderr.writeln(red.wrap(e.message));
     if (e.details != null) {
@@ -47,21 +50,24 @@ Future<void> serve(List<String> args, Set<FunctionTarget> targets) async {
   }
 }
 
-Future<void> _serve(List<String> args, Set<FunctionTarget> targets) async {
+Future<void> _serve(
+  List<String> args,
+  FunctionTarget Function(String) nameToFunctionTarget,
+) async {
   final configFromEnvironment = FunctionConfig.fromEnv();
 
   final config = FunctionConfig.fromArgs(
     args,
     defaults: configFromEnvironment,
   );
 
-  final functionTarget = targets.singleWhere(
-    (target) => target.name == config.target,
-    orElse: () => throw BadConfigurationException(
+  final functionTarget = nameToFunctionTarget(config.target);
+  if (functionTarget == null) {
+    throw BadConfigurationException(
       'There is no handler configured for '
       '$environmentKeyFunctionTarget `${config.target}`.',
-    ),
-  );
+    );
+  }
 
   if (functionTarget.type == FunctionType.cloudevent &&
       config.functionType == FunctionType.http) {

functions_framework/lib/src/function_target.dart

@@ -24,27 +24,21 @@ import 'typedefs.dart';
 export 'targets/json_targets.dart';
 
 abstract class FunctionTarget {
-  final String name;
-
   FunctionType get type => FunctionType.http;
 
-  const FunctionTarget(this.name);
+  FunctionTarget();
 
-  const factory FunctionTarget.http(String target, Handler function) =
-      HttpFunctionTarget;
+  factory FunctionTarget.http(Handler function) = HttpFunctionTarget;
 
-  const factory FunctionTarget.httpWithLogger(
-    String target,
+  factory FunctionTarget.httpWithLogger(
     HandlerWithLogger function,
   ) = HttpWithLoggerFunctionTarget;
 
-  const factory FunctionTarget.cloudEvent(
-    String target,
+  factory FunctionTarget.cloudEvent(
     CloudEventHandler function,
   ) = CloudEventFunctionTarget;
 
-  const factory FunctionTarget.cloudEventWithContext(
-    String target,
+  factory FunctionTarget.cloudEventWithContext(
     CloudEventWithContextHandler function,
   ) = CloudEventWithContextFunctionTarget;
 

functions_framework/lib/src/request_context.dart

@@ -29,25 +29,6 @@ class RequestContext {
 
   final responseHeaders = <String, /* String | List<String> */ Object>{};
 
-  /// The HTTP headers with case-insensitive keys.
-  ///
-  /// If a header occurs more than once in the query string, they are mapped to
-  /// by concatenating them with a comma.
-  ///
-  /// The returned map is unmodifiable.
-  @Deprecated('Use request.headers instead')
-  Map<String, String> get headers => request.headers;
-
-  /// The HTTP headers with multiple values with case-insensitive keys.
-  ///
-  /// If a header occurs only once, its value is a singleton list.
-  /// If a header occurs with no value, the empty string is used as the value
-  /// for that occurrence.
-  ///
-  /// The returned map and the lists it contains are unmodifiable.
-  @Deprecated('Use request.headersAll instead')
-  Map<String, List<String>> get headersAll => request.headersAll;
-
   RequestContext._(this.request) : logger = loggerForRequest(request);
 }
 

functions_framework/lib/src/targets/cloud_event_targets.dart

@@ -32,16 +32,14 @@ class CloudEventFunctionTarget extends FunctionTarget {
 
   @override
   FutureOr<Response> handler(Request request) async {
-    final event = _requiredBinaryHeader.every(request.headers.containsKey)
-        ? await _decodeBinary(request)
-        : await _decodeStructured(request);
+    final event = await _eventFromRequest(request);
 
     await function(event);
 
     return Response.ok('');
   }
 
-  const CloudEventFunctionTarget(String target, this.function) : super(target);
+  CloudEventFunctionTarget(this.function);
 }
 
 class CloudEventWithContextFunctionTarget extends FunctionTarget {
@@ -52,20 +50,22 @@ class CloudEventWithContextFunctionTarget extends FunctionTarget {
 
   @override
   Future<Response> handler(Request request) async {
-    final event = _requiredBinaryHeader.every(request.headers.containsKey)
-        ? await _decodeBinary(request)
-        : await _decodeStructured(request);
+    final event = await _eventFromRequest(request);
 
     final context = contextForRequest(request);
     await function(event, context);
 
     return Response.ok('', headers: context.responseHeaders);
   }
 
-  const CloudEventWithContextFunctionTarget(String target, this.function)
-      : super(target);
+  CloudEventWithContextFunctionTarget(this.function);
 }
 
+Future<CloudEvent> _eventFromRequest(Request request) =>
+    _requiredBinaryHeader.every(request.headers.containsKey)
+        ? _decodeBinary(request)
+        : _decodeStructured(request);
+
 Future<CloudEvent> _decodeStructured(Request request) async {
   final type = mediaTypeFromRequest(request);
 
@@ -82,16 +82,20 @@ Future<CloudEvent> _decodeStructured(Request request) async {
   return _decodeValidCloudEvent(jsonObject, 'structured-mode message');
 }
 
-Future<CloudEvent> _decodeBinary(Request request) async {
-  final map = Map<String, dynamic>.fromEntries(request.headers.entries
-      .where((element) => element.key.startsWith('ce-'))
-      .map((e) => MapEntry(e.key.substring(3), e.value)));
+const _cloudEventPrefix = 'ce-';
+const _clientEventPrefixLength = _cloudEventPrefix.length;
 
+Future<CloudEvent> _decodeBinary(Request request) async {
   final type = mediaTypeFromRequest(request);
-
   mustBeJson(type);
-  map['datacontenttype'] = type.toString();
-  map['data'] = await decodeJson(request);
+
+  final map = <String, Object>{
+    for (var e in request.headers.entries
+        .where((element) => element.key.startsWith(_cloudEventPrefix)))
+      e.key.substring(_clientEventPrefixLength): e.value,
+    'datacontenttype': type.toString(),
+    'data': await decodeJson(request),
+  };
 
   return _decodeValidCloudEvent(map, 'binary-mode message');
 }

functions_framework/lib/src/targets/http_targets.dart

@@ -26,7 +26,7 @@ class HttpFunctionTarget extends FunctionTarget {
   @override
   FutureOr<Response> handler(Request request) => _function(request);
 
-  const HttpFunctionTarget(String target, this._function) : super(target);
+  HttpFunctionTarget(this._function);
 }
 
 class HttpWithLoggerFunctionTarget extends FunctionTarget {
@@ -36,6 +36,5 @@ class HttpWithLoggerFunctionTarget extends FunctionTarget {
   FutureOr<Response> handler(Request request) =>
       _function(request, loggerForRequest(request));
 
-  const HttpWithLoggerFunctionTarget(String target, this._function)
-      : super(target);
+  HttpWithLoggerFunctionTarget(this._function);
 }

functions_framework/lib/src/targets/json_targets.dart

@@ -25,10 +25,7 @@ import '../typedefs.dart';
 abstract class _JsonFunctionTargetBase<RequestType> extends FunctionTarget {
   final RequestType Function(Object) _fromJson;
 
-  const _JsonFunctionTargetBase(
-    String target,
-    this._fromJson,
-  ) : super(target);
+  _JsonFunctionTargetBase(this._fromJson);
 
   Future<RequestType> _toRequestType(Request request) async {
     final type = mediaTypeFromRequest(request);
@@ -42,32 +39,28 @@ abstract class JsonFunctionTarget<RequestType, ResponseType>
     extends _JsonFunctionTargetBase<RequestType> {
   final JsonHandler<RequestType, ResponseType> _function;
 
-  const JsonFunctionTarget._(
-    String target,
+  JsonFunctionTarget._(
     this._function,
     RequestType Function(Object) fromJson,
-  ) : super(target, fromJson);
+  ) : super(fromJson);
 
-  const factory JsonFunctionTarget(
-    String target,
+  factory JsonFunctionTarget(
     JsonHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
   ) = _JsonFunctionTarget<RequestType, ResponseType>;
 
-  const factory JsonFunctionTarget.voidResult(
-    String target,
+  factory JsonFunctionTarget.voidResult(
     JsonHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
   ) = _VoidJsonFunctionTarget<RequestType, ResponseType>;
 }
 
 class _JsonFunctionTarget<RequestType, ResponseType>
     extends JsonFunctionTarget<RequestType, ResponseType> {
-  const _JsonFunctionTarget(
-    String target,
+  _JsonFunctionTarget(
     JsonHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
-  ) : super._(target, function, fromJson);
+  ) : super._(function, fromJson);
 
   @override
   FutureOr<Response> handler(Request request) async {
@@ -84,11 +77,10 @@ class _JsonFunctionTarget<RequestType, ResponseType>
 
 class _VoidJsonFunctionTarget<RequestType, ResponseType>
     extends JsonFunctionTarget<RequestType, ResponseType> {
-  const _VoidJsonFunctionTarget(
-    String target,
+  _VoidJsonFunctionTarget(
     JsonHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
-  ) : super._(target, function, fromJson);
+  ) : super._(function, fromJson);
 
   @override
   FutureOr<Response> handler(Request request) async {
@@ -102,32 +94,28 @@ abstract class JsonWithContextFunctionTarget<RequestType, ResponseType>
     extends _JsonFunctionTargetBase<RequestType> {
   final JsonWithContextHandler<RequestType, ResponseType> _function;
 
-  const JsonWithContextFunctionTarget._(
-    String target,
+  JsonWithContextFunctionTarget._(
     this._function,
     RequestType Function(Object) fromJson,
-  ) : super(target, fromJson);
+  ) : super(fromJson);
 
-  const factory JsonWithContextFunctionTarget(
-    String target,
+  factory JsonWithContextFunctionTarget(
     JsonWithContextHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
   ) = _JsonWithContextFunctionTarget<RequestType, ResponseType>;
 
-  const factory JsonWithContextFunctionTarget.voidResult(
-    String target,
+  factory JsonWithContextFunctionTarget.voidResult(
     JsonWithContextHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
   ) = _VoidJsonWithContextFunctionTarget<RequestType, ResponseType>;
 }
 
 class _JsonWithContextFunctionTarget<RequestType, ResponseType>
     extends JsonWithContextFunctionTarget<RequestType, ResponseType> {
-  const _JsonWithContextFunctionTarget(
-    String target,
+  _JsonWithContextFunctionTarget(
     JsonWithContextHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
-  ) : super._(target, function, fromJson);
+  ) : super._(function, fromJson);
 
   @override
   FutureOr<Response> handler(Request request) async {
@@ -150,11 +138,10 @@ class _JsonWithContextFunctionTarget<RequestType, ResponseType>
 
 class _VoidJsonWithContextFunctionTarget<RequestType, ResponseType>
     extends JsonWithContextFunctionTarget<RequestType, ResponseType> {
-  const _VoidJsonWithContextFunctionTarget(
-    String target,
+  _VoidJsonWithContextFunctionTarget(
     JsonWithContextHandler<RequestType, ResponseType> function,
     RequestType Function(Object) fromJson,
-  ) : super._(target, function, fromJson);
+  ) : super._(function, fromJson);
 
   @override
   FutureOr<Response> handler(Request request) async {

functions_framework/pubspec.yaml

@@ -1,5 +1,5 @@
 name: functions_framework
-version: 0.3.2-dev
+version: 0.4.0-dev
 description: >-
   FaaS (Function as a service) framework for writing portable Dart functions
 repository: https://github.com/GoogleCloudPlatform/functions-framework-dart

functions_framework_builder/CHANGELOG.md

@@ -1,7 +1,8 @@
 # Changelog
 
-## 0.3.2-dev
+## 0.4.0-dev
 
+- Support the latest `package:functions_framework` version.
 - Allow the latest version `package:shelf`.
 
 ## 0.3.1

functions_framework_builder/lib/builder.dart

@@ -85,15 +85,9 @@ class _FunctionsFrameworkBuilder implements Builder {
       entries[targetName] = invokeExpression;
     }
 
-    final functions = <String>[];
-    final factories = <String>[];
-    for (var e in entries.values) {
-      final factory = e.createFactory(functions.length);
-      if (factory != null) {
-        factories.add(factory);
-      }
-      functions.add('  ${e.createReference(functions.length)},');
-    }
+    final cases = [
+      for (var e in entries.values) '  case ${e.name}:return ${e.expression};',
+    ];
 
     var output = '''
 // GENERATED CODE - DO NOT MODIFY BY HAND
@@ -115,17 +109,23 @@ import 'package:functions_framework/serve.dart';
 import '${input.uri}' as $functionsLibraryPrefix;
 
 Future<void> main(List<String> args) async {
-  await serve(args, _functionTargets);
+  await serve(args, _nameToFunctionTarget);
 }
 
-const _functionTargets = <FunctionTarget>{
-${functions.join('\n')}
-};
-
-${factories.join('\n')}
+FunctionTarget _nameToFunctionTarget(String name) {
+  switch (name) {
+${cases.join('\n')}
+    default:
+      return null;
+  }
+}
 ''';
 
-    output = DartFormatter().format(output);
+    try {
+      output = DartFormatter().format(output);
+    } on FormatterException catch (e, stack) {
+      log.warning('Could not format output.', e, stack);
+    }
 
     await buildStep.writeAsString(
       AssetId(