lib/src/common_server_proto.dart - dart-services - Git at Google

 // Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 library services.common_server_proto;

 import 'dart:async';
 import 'dart:convert';

 import 'package:meta/meta.dart';
 import 'package:protobuf/protobuf.dart';
 import 'package:shelf/shelf.dart';
 import 'package:shelf_router/shelf_router.dart';

 import 'api_classes.dart' as api;
 import 'common_server_impl.dart' show CommonServerImpl, BadRequest;
 import 'protos/dart_services.pb.dart' as proto;

 export 'common_server_impl.dart' show log, ServerContainer;

 part 'common_server_proto.g.dart'; // generated with 'pub run build_runner build'

 const PROTOBUF_CONTENT_TYPE = 'application/x-protobuf';
 const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
 const PROTO_API_URL_PREFIX = '/api/dartservices/v2';

 class CommonServerProto {
   final CommonServerImpl _impl;

   CommonServerProto(this._impl);

   @Route.post('$PROTO_API_URL_PREFIX/analyze')
   Future<Response> analyze(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.SourceRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
       transform: _analyze);

   Future<proto.AnalysisResults> _analyze(proto.SourceRequest request) async {
     if (!request.hasSource()) {
       throw BadRequest('Missing parameter: \'source\'');
     }

     final apiRequest = api.SourceRequest()
       ..source = request.source
       ..offset = request.offset;
     final apiResponse = await _impl.analyze(apiRequest);

     return proto.AnalysisResults()
       ..packageImports.addAll(apiResponse.packageImports)
       ..issues.addAll(
         apiResponse.issues.map(
           (issue) => proto.AnalysisIssue()
             ..kind = issue.kind
             ..line = issue.line
             ..message = issue.message
             ..sourceName = issue.sourceName
             ..hasFixes = issue.hasFixes
             ..charStart = issue.charStart
             ..charLength = issue.charLength,
         ),
       );
   }

   @Route.post('$PROTO_API_URL_PREFIX/compile')
   Future<Response> compile(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.CompileRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.CompileRequest.fromBuffer(bytes),
       transform: _compile);

   Future<proto.CompileResponse> _compile(proto.CompileRequest request) async {
     final apiRequest = api.CompileRequest()
       ..source = request.source
       ..returnSourceMap = request.returnSourceMap;
     final apiResponse = await _impl.compile(apiRequest);
     final response = proto.CompileResponse()..result = apiResponse.result;
     if (apiResponse.sourceMap != null) {
       response.sourceMap = apiResponse.sourceMap;
     }
     return response;
   }

   @Route.post('$PROTO_API_URL_PREFIX/compileDDC')
   Future<Response> compileDDC(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.CompileRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.CompileRequest.fromBuffer(bytes),
       transform: _compileDDC);

   Future<proto.CompileDDCResponse> _compileDDC(
       proto.CompileRequest request) async {
     final apiRequest = api.CompileRequest()
       ..source = request.source
       ..returnSourceMap = request.returnSourceMap;
     final apiResponse = await _impl.compileDDC(apiRequest);

     return proto.CompileDDCResponse()
       ..result = apiResponse.result
       ..modulesBaseUrl = apiResponse.modulesBaseUrl;
   }

   @Route.post('$PROTO_API_URL_PREFIX/complete')
   Future<Response> complete(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.SourceRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
       transform: _complete);

   Future<proto.CompleteResponse> _complete(proto.SourceRequest request) async {
     if (!request.hasSource()) {
       throw BadRequest('Missing parameter: \'source\'');
     }
     if (!request.hasOffset()) {
       throw BadRequest('Missing parameter: \'offset\'');
     }

     final apiRequest = api.SourceRequest()
       ..offset = request.offset
       ..source = request.source;
     final apiResponse = await _impl.complete(apiRequest);

     return proto.CompleteResponse()
       ..replacementOffset = apiResponse.replacementOffset
       ..replacementLength = apiResponse.replacementLength
       ..completions.addAll(
         apiResponse.completions.map(
           (completion) => proto.Completion()..completion.addAll(completion),
         ),
       );
   }

   @Route.post('$PROTO_API_URL_PREFIX/fixes')
   Future<Response> fixes(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.SourceRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
       transform: _fixes);

   Future<proto.FixesResponse> _fixes(proto.SourceRequest request) async {
     if (!request.hasSource()) {
       throw BadRequest('Missing parameter: \'source\'');
     }
     if (!request.hasOffset()) {
       throw BadRequest('Missing parameter: \'offset\'');
     }

     final apiRequest = api.SourceRequest()
       ..offset = request.offset
       ..source = request.source;
     final apiResponse = await _impl.fixes(apiRequest);

     return proto.FixesResponse()
       ..fixes.addAll(
         apiResponse.fixes.map(
           (apiFix) => proto.ProblemAndFixes()
             ..problemMessage = apiFix.problemMessage
             ..offset = apiFix.offset
             ..length = apiFix.length
             ..fixes.addAll(
               apiFix.fixes.map(_transformCandidateFix),
             ),
         ),
       );
   }

   @Route.post('$PROTO_API_URL_PREFIX/assists')
   Future<Response> assists(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.SourceRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
       transform: _assists);

   Future<proto.AssistsResponse> _assists(proto.SourceRequest request) async {
     if (!request.hasSource()) {
       throw BadRequest('Missing parameter: \'source\'');
     }
     if (!request.hasOffset()) {
       throw BadRequest('Missing parameter: \'offset\'');
     }

     final apiRequest = api.SourceRequest()
       ..offset = request.offset
       ..source = request.source;
     final apiResponse = await _impl.assists(apiRequest);

     return proto.AssistsResponse()
       ..assists.addAll(
         apiResponse.assists.map(_transformCandidateFix),
       );
   }

   @Route.post('$PROTO_API_URL_PREFIX/format')
   Future<Response> format(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.SourceRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
       transform: _format);

   Future<proto.FormatResponse> _format(proto.SourceRequest request) async {
     if (!request.hasSource()) {
       throw BadRequest('Missing parameter: \'source\'');
     }

     final apiRequest = api.SourceRequest()
       ..offset = request.offset
       ..source = request.source;
     final apiResponse = await _impl.format(apiRequest);

     return proto.FormatResponse()
       ..newString = apiResponse.newString
       ..offset = apiResponse.offset;
   }

   @Route.post('$PROTO_API_URL_PREFIX/document')
   Future<Response> document(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.SourceRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
       transform: _document);

   Future<proto.DocumentResponse> _document(proto.SourceRequest request) async {
     if (!request.hasSource()) {
       throw BadRequest('Missing parameter: \'source\'');
     }
     if (!request.hasOffset()) {
       throw BadRequest('Missing parameter: \'offset\'');
     }

     final apiRequest = api.SourceRequest()
       ..offset = request.offset
       ..source = request.source;
     final apiResponse = await _impl.document(apiRequest);

     return proto.DocumentResponse()..info.addAll(apiResponse.info);
   }

   @Route.post('$PROTO_API_URL_PREFIX/version')
   Future<Response> versionPost(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.VersionRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.VersionRequest.fromBuffer(bytes),
       transform: _version);

   @Route.get('$PROTO_API_URL_PREFIX/version')
   Future<Response> versionGet(Request request) => _processRequest(request,
       decodeFromJSON: (json) =>
           proto.VersionRequest.create()..mergeFromProto3Json(json),
       decodeFromProto: (bytes) => proto.VersionRequest.fromBuffer(bytes),
       transform: _version);

   Future<proto.VersionResponse> _version(proto.VersionRequest request) async {
     final apiResponse = await _impl.version();

     return proto.VersionResponse()
       ..sdkVersion = apiResponse.sdkVersion
       ..sdkVersionFull = apiResponse.sdkVersionFull
       ..runtimeVersion = apiResponse.runtimeVersion
       ..appEngineVersion = apiResponse.appEngineVersion
       ..servicesVersion = apiResponse.servicesVersion
       ..flutterDartVersion = apiResponse.flutterDartVersion
       ..flutterDartVersionFull = apiResponse.flutterDartVersionFull
       ..flutterVersion = apiResponse.flutterVersion;
   }

   proto.CandidateFix _transformCandidateFix(api.CandidateFix candidateFix) {
     final result = proto.CandidateFix()..message = candidateFix.message;
     if (candidateFix.edits != null) {
       result.edits.addAll(
         candidateFix.edits.map(
           (edit) => proto.SourceEdit()
             ..offset = edit.offset
             ..length = edit.length
             ..replacement = edit.replacement,
         ),
       );
     }
     if (candidateFix.linkedEditGroups != null) {
       result.linkedEditGroups.addAll(
         candidateFix.linkedEditGroups.map(
           (group) => proto.LinkedEditGroup()
             ..positions.addAll(group.positions)
             ..length = group.length
             ..suggestions.addAll(
               group.suggestions.map(
                 (suggestion) => proto.LinkedEditSuggestion()
                   ..value = suggestion.value
                   ..kind = suggestion.kind,
               ),
             ),
         ),
       );
     }
     if (candidateFix.selectionOffset != null) {
       result.selectionOffset = candidateFix.selectionOffset;
     }
     return result;
   }

   Router get router => _$CommonServerProtoRouter(this);

   // We are serving requests that are arriving in both Protobuf binary encoding,
   // and Protobuf JSON encoding. To handle this we need the ability to decode
   // the requests and encode the responses. We also need to know how to do the
   // work the request is requesting.

   Future<Response> _processRequest<I, O extends GeneratedMessage>(
     Request request, {
     @required I Function(List<int> bytes) decodeFromProto,
     @required I Function(Object json) decodeFromJSON,
     @required Future<O> Function(I input) transform,
   }) async {
     if (request.mimeType == PROTOBUF_CONTENT_TYPE) {
       // Dealing with binary Protobufs
       final body = <int>[];
       await for (final chunk in request.read()) {
         body.addAll(chunk);
       }
       try {
         final response = await transform(decodeFromProto(body));
         return Response.ok(
           response.writeToBuffer(),
           headers: _PROTOBUF_HEADERS,
         );
       } on BadRequest catch (e) {
         return Response(400,
             headers: _PROTOBUF_HEADERS,
             body: (proto.BadRequest.create()
                   ..error = (proto.ErrorMessage.create()..message = e.cause))
                 .writeToBuffer());
       }
     } else {
       // Dealing with JSON encoded Protobufs
       final body = await request.readAsString();
       try {
         final response = await transform(
             decodeFromJSON(body.isNotEmpty ? json.decode(body) : {}));
         return Response.ok(
           _jsonEncoder.convert(response.toProto3Json()),
           encoding: utf8,
           headers: _JSON_HEADERS,
         );
       } on BadRequest catch (e) {
         return Response(400,
             headers: _JSON_HEADERS,
             encoding: utf8,
             body: _jsonEncoder.convert((proto.BadRequest.create()
                   ..error = (proto.ErrorMessage.create()..message = e.cause))
                 .toProto3Json()));
       }
     }
   }

   final JsonEncoder _jsonEncoder = JsonEncoder.withIndent(' ');

   static const _JSON_HEADERS = {
     'Access-Control-Allow-Origin': '*',
     'Content-Type': JSON_CONTENT_TYPE
   };

   static const _PROTOBUF_HEADERS = {
     'Access-Control-Allow-Origin': '*',
     'Content-Type': PROTOBUF_CONTENT_TYPE
   };
 }
	// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	library services.common_server_proto;

	import 'dart:async';
	import 'dart:convert';

	import 'package:meta/meta.dart';
	import 'package:protobuf/protobuf.dart';
	import 'package:shelf/shelf.dart';
	import 'package:shelf_router/shelf_router.dart';

	import 'api_classes.dart' as api;
	import 'common_server_impl.dart' show CommonServerImpl, BadRequest;
	import 'protos/dart_services.pb.dart' as proto;

	export 'common_server_impl.dart' show log, ServerContainer;

	part 'common_server_proto.g.dart'; // generated with 'pub run build_runner build'

	const PROTOBUF_CONTENT_TYPE = 'application/x-protobuf';
	const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
	const PROTO_API_URL_PREFIX = '/api/dartservices/v2';

	class CommonServerProto {
	final CommonServerImpl _impl;

	CommonServerProto(this._impl);

	@Route.post('$PROTO_API_URL_PREFIX/analyze')
	Future<Response> analyze(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.SourceRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
	transform: _analyze);

	Future<proto.AnalysisResults> _analyze(proto.SourceRequest request) async {
	if (!request.hasSource()) {
	throw BadRequest('Missing parameter: \'source\'');
	}

	final apiRequest = api.SourceRequest()
	..source = request.source
	..offset = request.offset;
	final apiResponse = await _impl.analyze(apiRequest);

	return proto.AnalysisResults()
	..packageImports.addAll(apiResponse.packageImports)
	..issues.addAll(
	apiResponse.issues.map(
	(issue) => proto.AnalysisIssue()
	..kind = issue.kind
	..line = issue.line
	..message = issue.message
	..sourceName = issue.sourceName
	..hasFixes = issue.hasFixes
	..charStart = issue.charStart
	..charLength = issue.charLength,
	),
	);
	}

	@Route.post('$PROTO_API_URL_PREFIX/compile')
	Future<Response> compile(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.CompileRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.CompileRequest.fromBuffer(bytes),
	transform: _compile);

	Future<proto.CompileResponse> _compile(proto.CompileRequest request) async {
	final apiRequest = api.CompileRequest()
	..source = request.source
	..returnSourceMap = request.returnSourceMap;
	final apiResponse = await _impl.compile(apiRequest);
	final response = proto.CompileResponse()..result = apiResponse.result;
	if (apiResponse.sourceMap != null) {
	response.sourceMap = apiResponse.sourceMap;
	}
	return response;
	}

	@Route.post('$PROTO_API_URL_PREFIX/compileDDC')
	Future<Response> compileDDC(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.CompileRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.CompileRequest.fromBuffer(bytes),
	transform: _compileDDC);

	Future<proto.CompileDDCResponse> _compileDDC(
	proto.CompileRequest request) async {
	final apiRequest = api.CompileRequest()
	..source = request.source
	..returnSourceMap = request.returnSourceMap;
	final apiResponse = await _impl.compileDDC(apiRequest);

	return proto.CompileDDCResponse()
	..result = apiResponse.result
	..modulesBaseUrl = apiResponse.modulesBaseUrl;
	}

	@Route.post('$PROTO_API_URL_PREFIX/complete')
	Future<Response> complete(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.SourceRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
	transform: _complete);

	Future<proto.CompleteResponse> _complete(proto.SourceRequest request) async {
	if (!request.hasSource()) {
	throw BadRequest('Missing parameter: \'source\'');
	}
	if (!request.hasOffset()) {
	throw BadRequest('Missing parameter: \'offset\'');
	}

	final apiRequest = api.SourceRequest()
	..offset = request.offset
	..source = request.source;
	final apiResponse = await _impl.complete(apiRequest);

	return proto.CompleteResponse()
	..replacementOffset = apiResponse.replacementOffset
	..replacementLength = apiResponse.replacementLength
	..completions.addAll(
	apiResponse.completions.map(
	(completion) => proto.Completion()..completion.addAll(completion),
	),
	);
	}

	@Route.post('$PROTO_API_URL_PREFIX/fixes')
	Future<Response> fixes(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.SourceRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
	transform: _fixes);

	Future<proto.FixesResponse> _fixes(proto.SourceRequest request) async {
	if (!request.hasSource()) {
	throw BadRequest('Missing parameter: \'source\'');
	}
	if (!request.hasOffset()) {
	throw BadRequest('Missing parameter: \'offset\'');
	}

	final apiRequest = api.SourceRequest()
	..offset = request.offset
	..source = request.source;
	final apiResponse = await _impl.fixes(apiRequest);

	return proto.FixesResponse()
	..fixes.addAll(
	apiResponse.fixes.map(
	(apiFix) => proto.ProblemAndFixes()
	..problemMessage = apiFix.problemMessage
	..offset = apiFix.offset
	..length = apiFix.length
	..fixes.addAll(
	apiFix.fixes.map(_transformCandidateFix),
	),
	),
	);
	}

	@Route.post('$PROTO_API_URL_PREFIX/assists')
	Future<Response> assists(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.SourceRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
	transform: _assists);

	Future<proto.AssistsResponse> _assists(proto.SourceRequest request) async {
	if (!request.hasSource()) {
	throw BadRequest('Missing parameter: \'source\'');
	}
	if (!request.hasOffset()) {
	throw BadRequest('Missing parameter: \'offset\'');
	}

	final apiRequest = api.SourceRequest()
	..offset = request.offset
	..source = request.source;
	final apiResponse = await _impl.assists(apiRequest);

	return proto.AssistsResponse()
	..assists.addAll(
	apiResponse.assists.map(_transformCandidateFix),
	);
	}

	@Route.post('$PROTO_API_URL_PREFIX/format')
	Future<Response> format(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.SourceRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
	transform: _format);

	Future<proto.FormatResponse> _format(proto.SourceRequest request) async {
	if (!request.hasSource()) {
	throw BadRequest('Missing parameter: \'source\'');
	}

	final apiRequest = api.SourceRequest()
	..offset = request.offset
	..source = request.source;
	final apiResponse = await _impl.format(apiRequest);

	return proto.FormatResponse()
	..newString = apiResponse.newString
	..offset = apiResponse.offset;
	}

	@Route.post('$PROTO_API_URL_PREFIX/document')
	Future<Response> document(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.SourceRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.SourceRequest.fromBuffer(bytes),
	transform: _document);

	Future<proto.DocumentResponse> _document(proto.SourceRequest request) async {
	if (!request.hasSource()) {
	throw BadRequest('Missing parameter: \'source\'');
	}
	if (!request.hasOffset()) {
	throw BadRequest('Missing parameter: \'offset\'');
	}

	final apiRequest = api.SourceRequest()
	..offset = request.offset
	..source = request.source;
	final apiResponse = await _impl.document(apiRequest);

	return proto.DocumentResponse()..info.addAll(apiResponse.info);
	}

	@Route.post('$PROTO_API_URL_PREFIX/version')
	Future<Response> versionPost(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.VersionRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.VersionRequest.fromBuffer(bytes),
	transform: _version);

	@Route.get('$PROTO_API_URL_PREFIX/version')
	Future<Response> versionGet(Request request) => _processRequest(request,
	decodeFromJSON: (json) =>
	proto.VersionRequest.create()..mergeFromProto3Json(json),
	decodeFromProto: (bytes) => proto.VersionRequest.fromBuffer(bytes),
	transform: _version);

	Future<proto.VersionResponse> _version(proto.VersionRequest request) async {
	final apiResponse = await _impl.version();

	return proto.VersionResponse()
	..sdkVersion = apiResponse.sdkVersion
	..sdkVersionFull = apiResponse.sdkVersionFull
	..runtimeVersion = apiResponse.runtimeVersion
	..appEngineVersion = apiResponse.appEngineVersion
	..servicesVersion = apiResponse.servicesVersion
	..flutterDartVersion = apiResponse.flutterDartVersion
	..flutterDartVersionFull = apiResponse.flutterDartVersionFull
	..flutterVersion = apiResponse.flutterVersion;
	}

	proto.CandidateFix _transformCandidateFix(api.CandidateFix candidateFix) {
	final result = proto.CandidateFix()..message = candidateFix.message;
	if (candidateFix.edits != null) {
	result.edits.addAll(
	candidateFix.edits.map(
	(edit) => proto.SourceEdit()
	..offset = edit.offset
	..length = edit.length
	..replacement = edit.replacement,
	),
	);
	}
	if (candidateFix.linkedEditGroups != null) {
	result.linkedEditGroups.addAll(
	candidateFix.linkedEditGroups.map(
	(group) => proto.LinkedEditGroup()
	..positions.addAll(group.positions)
	..length = group.length
	..suggestions.addAll(
	group.suggestions.map(
	(suggestion) => proto.LinkedEditSuggestion()
	..value = suggestion.value
	..kind = suggestion.kind,
	),
	),
	),
	);
	}
	if (candidateFix.selectionOffset != null) {
	result.selectionOffset = candidateFix.selectionOffset;
	}
	return result;
	}

	Router get router => _$CommonServerProtoRouter(this);

	// We are serving requests that are arriving in both Protobuf binary encoding,
	// and Protobuf JSON encoding. To handle this we need the ability to decode
	// the requests and encode the responses. We also need to know how to do the
	// work the request is requesting.

	Future<Response> _processRequest<I, O extends GeneratedMessage>(
	Request request, {
	@required I Function(List<int> bytes) decodeFromProto,
	@required I Function(Object json) decodeFromJSON,
	@required Future<O> Function(I input) transform,
	}) async {
	if (request.mimeType == PROTOBUF_CONTENT_TYPE) {
	// Dealing with binary Protobufs
	final body = <int>[];
	await for (final chunk in request.read()) {
	body.addAll(chunk);
	}
	try {
	final response = await transform(decodeFromProto(body));
	return Response.ok(
	response.writeToBuffer(),
	headers: _PROTOBUF_HEADERS,
	);
	} on BadRequest catch (e) {
	return Response(400,
	headers: _PROTOBUF_HEADERS,
	body: (proto.BadRequest.create()
	..error = (proto.ErrorMessage.create()..message = e.cause))
	.writeToBuffer());
	}
	} else {
	// Dealing with JSON encoded Protobufs
	final body = await request.readAsString();
	try {
	final response = await transform(
	decodeFromJSON(body.isNotEmpty ? json.decode(body) : {}));
	return Response.ok(
	_jsonEncoder.convert(response.toProto3Json()),
	encoding: utf8,
	headers: _JSON_HEADERS,
	);
	} on BadRequest catch (e) {
	return Response(400,
	headers: _JSON_HEADERS,
	encoding: utf8,
	body: _jsonEncoder.convert((proto.BadRequest.create()
	..error = (proto.ErrorMessage.create()..message = e.cause))
	.toProto3Json()));
	}
	}
	}

	final JsonEncoder _jsonEncoder = JsonEncoder.withIndent(' ');

	static const _JSON_HEADERS = {
	'Access-Control-Allow-Origin': '*',
	'Content-Type': JSON_CONTENT_TYPE
	};

	static const _PROTOBUF_HEADERS = {
	'Access-Control-Allow-Origin': '*',
	'Content-Type': PROTOBUF_CONTENT_TYPE
	};
	}