reviewLocalProxyMiddleware function

Handler Function(Handler ) reviewLocalProxyMiddleware({
  1. ReviewConfig? config,
})

Creates a shelf-compatible middleware (Handler Function(Handler)) that forwards same-origin /__dash_review/api/* requests to ReviewConfig.serverOrigin.

Implementation

Handler Function(Handler) reviewLocalProxyMiddleware({ReviewConfig? config}) {
  final effectiveConfig = config ?? ReviewConfig.environment;

  return (Handler innerHandler) {
    return (Request request) async {
      final reqPath = request.requestedUri.path;
      if (!reqPath.startsWith('$reviewProxyPathPrefix/api/')) {
        return innerHandler(request);
      }

      if (!effectiveConfig.isEnabled ||
          effectiveConfig.mode != 'local' ||
          effectiveConfig.serverOrigin.isEmpty) {
        return _jsonResponse(HttpStatus.notFound, {
          'ok': false,
          'error': 'Local review proxy is not active.',
        });
      }

      // Block cross-site CSRF / data exfiltration attempts while allowing
      // legitimate same-origin requests from localhost, VS Code tunnels, or
      // Cloudtop web preview hostnames.
      final secFetchSite = request.headers['sec-fetch-site']?.trim();
      if (secFetchSite == 'cross-site') {
        return _jsonResponse(HttpStatus.forbidden, {
          'ok': false,
          'error': 'Cross-site requests to local review proxy are forbidden.',
        });
      }

      final originHeader = request.headers['origin']?.trim();
      if (originHeader != null && originHeader.isNotEmpty) {
        final originUri = Uri.tryParse(originHeader);
        if (originUri == null ||
            originUri.host.toLowerCase() !=
                request.requestedUri.host.toLowerCase()) {
          return _jsonResponse(HttpStatus.forbidden, {
            'ok': false,
            'error': 'Origin mismatch on local review proxy.',
          });
        }
      }

      if (request.method == 'OPTIONS') {
        return Response(
          HttpStatus.noContent,
          headers: const {'cache-control': 'no-store'},
        );
      }

      final upstreamSubpath = reqPath.substring(reviewProxyPathPrefix.length);
      final querySuffix = request.requestedUri.hasQuery
          ? '?${request.requestedUri.query}'
          : '';
      final targetUri = Uri.parse(
        '${effectiveConfig.serverOrigin}$upstreamSubpath$querySuffix',
      );

      final client = HttpClient()
        ..connectionTimeout = const Duration(seconds: 3);
      try {
        final bodyBuilder = BytesBuilder(copy: false);
        await for (final chunk in request.read()) {
          if (bodyBuilder.length + chunk.length > _maxProxyRequestBodyBytes) {
            return _jsonResponse(HttpStatus.badRequest, {
              'ok': false,
              'error': 'Request body exceeds maximum size.',
            });
          }
          bodyBuilder.add(chunk);
        }
        final bodyBytes = bodyBuilder.takeBytes();

        final upstreamReq = await client.openUrl(request.method, targetUri);
        upstreamReq.headers.set(HttpHeaders.acceptHeader, 'application/json');
        if (request.headers['content-type'] case final String contentType
            when contentType.isNotEmpty) {
          upstreamReq.headers.set(HttpHeaders.contentTypeHeader, contentType);
        }
        if (bodyBytes.isNotEmpty) {
          upstreamReq.contentLength = bodyBytes.length;
          upstreamReq.add(bodyBytes);
        }

        final upstreamRes = await upstreamReq.close().timeout(
          const Duration(seconds: 5),
        );
        final resBuilder = BytesBuilder(copy: false);
        await for (final chunk in upstreamRes) {
          resBuilder.add(chunk);
        }

        return Response(
          upstreamRes.statusCode,
          body: resBuilder.takeBytes(),
          headers: const {
            'content-type': 'application/json; charset=utf-8',
            'cache-control': 'no-store',
          },
        );
      } on Object catch (error) {
        return _jsonResponse(HttpStatus.badGateway, {
          'ok': false,
          'error':
              'Local review sync server unreachable at '
              '${effectiveConfig.serverOrigin}: $error',
        });
      } finally {
        client.close(force: true);
      }
    };
  };
}