Add request/response-body-data to track body streaming events

Author: pimterry

src/admin/mockttp-admin-model.ts

@@ -30,8 +30,10 @@ import { SubscribableEvent } from "../main";
 
 const graphqlSubscriptionPairs = Object.entries({
     'requestInitiated': 'request-initiated',
+    'requestBodyData': 'request-body-data',
     'requestReceived': 'request',
     'responseInitiated': 'response-initiated',
+    'responseBodyData': 'response-body-data',
     'responseCompleted': 'response',
     'webSocketRequest': 'websocket-request',
     'webSocketAccepted': 'websocket-accepted',

src/admin/mockttp-schema.ts

@@ -19,8 +19,10 @@ export const MockttpSchema = gql`
 
     extend type Subscription {
         requestInitiated: InitiatedRequest!
+        requestBodyData: BodyData!
         requestReceived: Request!
         responseInitiated: InitiatedResponse!
+        responseBodyData: BodyData!
         responseCompleted: Response!
         webSocketRequest: Request!
         webSocketAccepted: Response!
@@ -137,6 +139,13 @@ export const MockttpSchema = gql`
         eventData: Raw!
     }
 
+    type BodyData {
+        id: String!
+        content: Buffer!
+        eventTimestamp: Float!
+        isEnded: Boolean!
+    }
+
     type InitiatedRequest {
         id: ID!
         timingEvents: Json!

src/client/mockttp-admin-request-builder.ts

@@ -215,6 +215,14 @@ export class MockttpAdminRequestBuilder {
                     tags
                 }
             }`,
+            'request-body-data': gql`subscription OnRequestBodyData {
+                requestBodyData {
+                    id
+                    content
+                    eventTimestamp
+                    isEnded
+                }
+            }`,
             request: gql`subscription OnRequest {
                 requestReceived {
                     id
@@ -254,6 +262,14 @@ export class MockttpAdminRequestBuilder {
                     tags
                 }
             }`,
+            'response-body-data': gql`subscription OnResponseBodyData {
+                responseBodyData {
+                    id
+                    content
+                    eventTimestamp
+                    isEnded
+                }
+            }`,
             response: gql`subscription OnResponse {
                 responseCompleted {
                     id
@@ -528,7 +544,11 @@ export class MockttpAdminRequestBuilder {
                     }
                 } else if (event === 'websocket-message-received' || event === 'websocket-message-sent') {
                     normalizeWebSocketMessage(data);
-                } else if (event === 'raw-passthrough-data') {
+                } else if (
+                    event === 'raw-passthrough-data' ||
+                    event === 'request-body-data' ||
+                    event === 'response-body-data'
+                ) {
                     data.content = Buffer.from(data.content, 'base64');
                 } else if (event === 'abort') {
                     normalizeHttpMessage(data, event);

src/mockttp.ts

@@ -23,7 +23,8 @@ import {
     RuleEvent,
     RawPassthroughEvent,
     RawPassthroughDataEvent,
-    InitiatedResponse
+    InitiatedResponse,
+    BodyData
 } from "./types";
 import type { RequestRuleData } from "./rules/requests/request-rule";
 import type { WebSocketRuleData } from "./rules/websockets/websocket-rule";
@@ -355,6 +356,22 @@ export interface Mockttp {
      */
     on(event: 'request-initiated', callback: (req: InitiatedRequest) => void): Promise<void>;
 
+    /**
+     * Subscribe to hear about request body data live, streaming in progressive
+     * chunks as it's received (listen for `request` if you just want to receive
+     * the complete body once it's done).
+     *
+     * This is only useful in some niche use cases, such as logging all requests seen
+     * by the server independently of the rules defined.
+     *
+     * The callback will be called asynchronously from request handling. This function
+     * returns a promise, and the callback is not guaranteed to be registered until
+     * the promise is resolved.
+     *
+     * @category Events
+     */
+    on(event: 'request-body-data', callback: (req: BodyData) => void): Promise<void>;
+
     /**
      * Subscribe to hear about request details once the request is fully received.
      *
@@ -384,6 +401,22 @@ export interface Mockttp {
      */
     on(event: 'response-initiated', callback: (req: InitiatedResponse) => void): Promise<void>;
 
+    /**
+     * Subscribe to hear about response body data live, streaming in progressive
+     * chunks as it's received (listen for `response` if you just want to receive
+     * the complete body once it's done).
+     *
+     * This is only useful in some niche use cases, such as logging all requests seen
+     * by the server independently of the rules defined.
+     *
+     * The callback will be called asynchronously from request handling. This function
+     * returns a promise, and the callback is not guaranteed to be registered until
+     * the promise is resolved.
+     *
+     * @category Events
+     */
+    on(event: 'response-body-data', callback: (req: BodyData) => void): Promise<void>;
+
     /**
      * Subscribe to hear about response details when the response is completed.
      *
@@ -915,8 +948,10 @@ export interface MockttpOptions {
 
 export type SubscribableEvent =
     | 'request-initiated'
+    | 'request-body-data'
     | 'request'
     | 'response-initiated'
+    | 'response-body-data'
     | 'response'
     | 'websocket-request'
     | 'websocket-accepted'