handle method

Future<ServerResponse> handle(
  1. ServerRequest request
)

Implementation

Future<ServerResponse> handle(ServerRequest request) async {
  if (request.method != 'POST') {
    return _json(405, {'error': 'method_not_allowed'}, {'Allow': 'POST'});
  }
  final now = (clock?.call() ?? DateTime.now()).toUtc();
  if (request.bodyBytes.length > maxBodyBytes) {
    return _json(413, {'error': 'payload_too_large'});
  }
  final timestamp = request.header('x-metamantle-timestamp');
  final eventId = request.header('x-metamantle-event-id');
  final signature = request.header('x-metamantle-signature');
  final seconds = int.tryParse(timestamp ?? '');
  if (timestamp == null ||
      seconds == null ||
      eventId == null ||
      !RegExp(r'^[A-Za-z0-9_-]{1,48}$').hasMatch(eventId) ||
      signature == null) {
    return _json(401, {'error': 'invalid_signature_headers'});
  }
  final signedAt = DateTime.fromMillisecondsSinceEpoch(
    seconds * 1000,
    isUtc: true,
  );
  if (now.difference(signedAt).abs() > maxClockSkew) {
    return _json(401, {'error': 'expired_signature'});
  }
  late final String body;
  try {
    body = request.bodyText;
  } on FormatException {
    return _json(400, {'error': 'invalid_payload'});
  }
  final canonical = '$timestamp\n$eventId\n$tenantId\n$body';
  final expected = Hmac(sha256, secret).convert(utf8.encode(canonical)).bytes;
  final suppliedHex = signature.startsWith('sha256=')
      ? signature.substring(7)
      : signature;
  final supplied = _decodeHex(suppliedHex);
  if (supplied == null || !_constantTimeEquals(expected, supplied)) {
    return _json(401, {'error': 'invalid_signature'});
  }
  if (!rateLimiter.allow(tenantId, now)) {
    return _json(429, {'error': 'rate_limited'});
  }

  Map<String, Object?> payload;
  try {
    payload = Map<String, Object?>.from(jsonDecode(body) as Map);
  } on Object {
    return _json(400, {'error': 'invalid_payload'});
  }
  if (payload['tenantId'] != tenantId) {
    return _json(403, {'error': 'tenant_mismatch'});
  }
  final path = payload['path'];
  final tag = payload['tag'];
  final routeId = payload['routeId'];
  if ([path, tag, routeId].where((value) => value != null).length != 1 ||
      (path != null && path is! String) ||
      (tag != null && tag is! String) ||
      (routeId != null && routeId is! String)) {
    return _json(400, {'error': 'invalid_selector'});
  }

  final replayExpires = now.add(maxClockSkew);
  final claimed = await replayStore.claim(eventId, replayExpires, now);
  if (!claimed) return _json(409, {'error': 'replayed_event'});
  try {
    final report = path is String
        ? await scheduler.revalidatePath(path, eventId: eventId)
        : tag is String
        ? await scheduler.revalidateTag(tag, eventId: eventId)
        : await scheduler.revalidateRoute(
            routeId as String,
            eventId: eventId,
          );
    return _json(202, {
      'jobIds': report.jobIds,
      'scheduled': report.jobs.length,
    });
  } on FormatException {
    await replayStore.release(eventId);
    return _json(400, {'error': 'invalid_selector'});
  } on Object {
    await replayStore.release(eventId);
    return _json(500, {'error': 'revalidation_unavailable'});
  }
}