load method

  1. @override
Future<DataProviderResult<T>> load(
  1. RouteDataContext context
)
override

Loads typed data for the given context.

Implementation

@override
Future<DataProviderResult<T>> load(RouteDataContext context) async {
  final targetUrl = urlBuilder(context);
  final uri = Uri.parse(targetUrl);

  // 1. Validate URI against SSRF boundaries before any network request
  await ssrfGuard.validateUri(uri);

  http.Response? response;
  Exception? lastException;

  for (var attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      final request = http.Request('GET', uri)
        ..headers.addAll({
          'Accept': 'application/json',
          'User-Agent': 'MetaMantle-SSR/0.1.0',
          ...headers,
        });

      final streamed = await _sendFollowingValidatedRedirects(request);

      // Check Content-Length header early
      if (streamed.contentLength != null &&
          streamed.contentLength! > maxResponseSizeBytes) {
        throw StateError(
          'REST API response Content-Length (${streamed.contentLength}) exceeded maximum allowed size of $maxResponseSizeBytes bytes.',
        );
      }

      // Stream accumulation with immediate abort on size limit breach
      final byteBuilder = BytesBuilder(copy: false);
      await for (final chunk in streamed.stream.timeout(timeout)) {
        byteBuilder.add(chunk);
        if (byteBuilder.length > maxResponseSizeBytes) {
          throw StateError(
            'REST API response stream exceeded maximum allowed size of $maxResponseSizeBytes bytes.',
          );
        }
      }

      final bodyBytes = byteBuilder.takeBytes();
      response = http.Response.bytes(
        bodyBytes,
        streamed.statusCode,
        headers: streamed.headers,
        request: streamed.request,
        isRedirect: streamed.isRedirect,
        persistentConnection: streamed.persistentConnection,
        reasonPhrase: streamed.reasonPhrase,
      );

      if (response.statusCode >= 500 && attempt < maxRetries) {
        // Idempotent GET retry on server error
        await Future<void>.delayed(
          Duration(milliseconds: 100 * (attempt + 1)),
        );
        continue;
      }
      break;
    } on SecurityException {
      rethrow;
    } on Exception catch (e) {
      lastException = e;
      if (attempt >= maxRetries) rethrow;
      await Future<void>.delayed(Duration(milliseconds: 100 * (attempt + 1)));
    }
  }

  if (response == null) {
    throw lastException ?? StateError('Failed to communicate with REST API.');
  }

  if (response.statusCode == 404) {
    return DataProviderResult<T>.notFound(cacheTags: [entityTag]);
  }

  if (response.statusCode == 410) {
    return DataProviderResult<T>.gone(cacheTags: [entityTag]);
  }

  if (response.statusCode < 200 || response.statusCode >= 300) {
    throw http.ClientException(
      'REST API returned unexpected status code: ${response.statusCode}',
      uri,
    );
  }

  final decoded = json.decode(utf8.decode(response.bodyBytes));
  final entity = mapper(decoded);

  DateTime? lastModified;
  final lastModHeader =
      response.headers['last-modified'] ?? response.headers['Last-Modified'];
  if (lastModHeader != null) {
    try {
      lastModified = DateTime.tryParse(lastModHeader);
    } catch (_) {}
  }

  final etag =
      response.headers['etag'] ??
      response.headers['ETag'] ??
      response.headers['Etag'];

  return DataProviderResult<T>.found(
    entity,
    lastModified: lastModified,
    etag: etag,
    cacheTags: [entityTag, '$entityTag:${context.path}'],
  );
}