Drop lots of very old backward compatibility & deprecated features:

* Lots of internal API compat for old clients/servers, which shouldn't
  affect any external usage at all unless you hit the internal GraphQL
  remote client API manually.
* Dropped some type aliases exposed for backward compat: TlsRequest,
  HttpsOptions, HttpsPathOptions (now TlsHandshakeFailure,
  CertDataOptions, CertPathOptions)
* Dropped ECONNRESET-only passthrough error simulation. Whether upstream
  connection errors are simulated downstream is now controlled
  exclusively by the simulateConnectionErrors passthrough rule option.
* Dropped 'status' option on callback results - use statusCode instead.
* Dropped deprecated 'trustAdditionalCAs' alias for 'additionalTrustedCAs'
* Dropped deprecated string format in proxySetting.trustedCAs array.

Everything dropped has been deprecated/backward-compat-only for 3+ years
now, so this is unlikely to affect most users in practice.

Author: pimterry

src/admin/admin-server.ts

@@ -181,22 +181,7 @@ export class AdminServer<Plugins extends { [key: string]: AdminPlugin<any, any>
         this.app.post('/start', async (req, res) => {
             try {
                 const rawConfig = req.body;
-
-                // New clients send: "{ plugins: { http: {...}, webrtc: {...} } }" etc. Old clients just send
-                // the HTTP options bare with no wrapper, so we wrap them for backward compat.
-                const isPluginAwareClient = ('plugins' in rawConfig);
-
-                const providedPluginStartParams = (!isPluginAwareClient
-                    ? { // Backward compat: this means the client is not plugin-aware, and so all options are Mockttp options
-                        http: {
-                            options: _.cloneDeep(rawConfig),
-                            port: (typeof req.query.port === 'string')
-                                ? JSON.parse(req.query.port)
-                                : undefined
-                        }
-                    }
-                    : rawConfig.plugins
-                ) as PluginStartParamsMap<Plugins>;
+                const providedPluginStartParams = rawConfig.plugins as PluginStartParamsMap<Plugins>;
 
                 // For each plugin that was specified, we pull default params into their start params.
                 const pluginStartParams = _.mapValues((providedPluginStartParams), (params, pluginId) => {
@@ -205,15 +190,6 @@ export class AdminServer<Plugins extends { [key: string]: AdminPlugin<any, any>
 
                 if (this.debug) console.log('Admin server starting mock session with config', pluginStartParams);
 
-                // Backward compat: do an explicit check for HTTP port conflicts
-                const httpPort = (pluginStartParams as { http?: { port: number } }).http?.port;
-                if (_.isNumber(httpPort) && this.sessions[httpPort] != null) {
-                    res.status(409).json({
-                        error: `Cannot start: mock server is already running on port ${httpPort}`
-                    });
-                    return;
-                }
-
                 const missingPluginId = Object.keys(pluginStartParams).find(pluginId => !(pluginId in this.adminPlugins));
                 if (missingPluginId) {
                     res.status(400).json({
@@ -233,28 +209,15 @@ export class AdminServer<Plugins extends { [key: string]: AdminPlugin<any, any>
                     )
                 );
 
-                // More backward compat: old clients assume that the port is also the management id.
-                const sessionId = isPluginAwareClient
-                    ? uuid()
-                    : (sessionPlugins as any as {
-                        'http': MockttpAdminPlugin
-                    }).http.getMockServer().port.toString();
-
+                const sessionId = uuid();
                 await this.startSessionManagementAPI(sessionId, sessionPlugins);
 
-                if (isPluginAwareClient) {
-                    res.json({
-                        id: sessionId,
-                        pluginData: _.mapValues(pluginStartResults, (r: unknown) =>
-                            r ?? {} // Always return _something_, even if the plugin returns null/undefined.
-                        )
-                    });
-                } else {
-                    res.json({
-                        id: sessionId,
-                        ...(pluginStartResults['http']!)
-                    });
-                }
+                res.json({
+                    id: sessionId,
+                    pluginData: _.mapValues(pluginStartResults, (r: unknown) =>
+                        r ?? {} // Always return _something_, even if the plugin returns null/undefined.
+                    )
+                });
             } catch (e) {
                 res.status(500).json({ error: `Failed to start mock session: ${
                     (isErrorLike(e) && e.message) || e
@@ -290,7 +253,6 @@ export class AdminServer<Plugins extends { [key: string]: AdminPlugin<any, any>
         }
 
         this.app.use('/session/:id/', sessionRequest);
-        this.app.use('/server/:id/', sessionRequest); // Old URL for backward compat
     }
 
     async resetAdminServer() {

src/admin/mockttp-admin-model.ts

@@ -103,14 +103,6 @@ export function buildAdminServerModel(
                     deserializeRuleData(rule, stream, ruleParameters)
                 ));
             },
-            setFallbackRule: async (__: any, { input }: { input: Serialized<RequestRuleData> }) => {
-                // Deprecated endpoint, but preserved for API backward compat
-                const ruleData = deserializeRuleData(input, stream, ruleParameters);
-                return mockServer.addRequestRules({
-                    ...ruleData,
-                    priority: 0
-                }).then((rules) => rules[0]);
-            },
 
             addWebSocketRule: async (__: any, { input }: { input: Serialized<WebSocketRuleData> }) => {
                 return mockServer.addWebSocketRule(deserializeWebSocketRuleData(input, stream, ruleParameters));

src/admin/mockttp-schema.ts

@@ -11,7 +11,6 @@ export const MockttpSchema = gql`
         addRule(input: MockRule!): MockedEndpoint!
         addRules(input: [MockRule!]!): [MockedEndpoint!]!
         setRules(input: [MockRule!]!): [MockedEndpoint!]!
-        setFallbackRule(input: MockRule!): MockedEndpoint!
 
         addWebSocketRule(input: WebSocketMockRule!): MockedEndpoint!
         addWebSocketRules(input: [WebSocketMockRule!]!): [MockedEndpoint!]!
@@ -85,17 +84,6 @@ export const MockttpSchema = gql`
         tlsMetadata: Json!
     }
 
-    # Old name for TlsHandshakeFailure, kept for backward compat
-    type TlsRequest {
-        failureCause: String!
-
-        hostname: String
-        remoteIpAddress: String
-        remotePort: Int
-        tags: [String!]!
-        timingEvents: Json!
-    }
-
     type ClientError {
         errorCode: String
         request: ClientErrorRequest!

src/client/admin-client.ts

@@ -149,7 +149,7 @@ async function requestFromAdminServer<T>(serverUrl: string, path: string, option
             jsonBody = JSON.parse(body);
         } catch (e) { }
 
-        if (jsonBody && jsonBody.error) {
+        if (jsonBody?.error) {
             throw new RequestError(
                 jsonBody.error,
                 response
@@ -442,8 +442,7 @@ export class AdminClient<Plugins extends { [key: string]: AdminPlugin<any, any>
 
             const path = portConfig ? `/start?port=${JSON.stringify(portConfig)}` : '/start';
             const adminServerResponse = await requestFromAdminServer<
-                | { port: number, mockRoot: string } // Backward compat for old servers
-                | { id: string, pluginData: PluginClientResponsesMap<Plugins> } // New plugin-aware servers
+                { id: string, pluginData: PluginClientResponsesMap<Plugins> } // New plugin-aware servers
             >(
                 this.adminClientOptions.adminServerUrl,
                 path,
@@ -453,23 +452,13 @@ export class AdminClient<Plugins extends { [key: string]: AdminPlugin<any, any>
                         'Content-Type': 'application/json'
                     }),
                     body: JSON.stringify({
-                        plugins: pluginStartParams,
-                        // Include all the Mockttp params at the root too, for backward compat with old admin servers:
-                        ...(pluginStartParams.http?.options as MockttpOptions | undefined)
+                        plugins: pluginStartParams
                     })
                 }, this.adminClientOptions.requestOptions)
             );
 
-            // Backward compat for old servers
-            const isPluginAwareServer = 'id' in adminServerResponse;
-
-            const sessionId = isPluginAwareServer
-                ? adminServerResponse.id
-                : adminServerResponse.port.toString();
-
-            const adminSessionBaseUrl = `${this.adminClientOptions.adminServerUrl}/${
-                isPluginAwareServer ? 'session' : 'server'
-            }/${sessionId}`
+            const sessionId = adminServerResponse.id;
+            const adminSessionBaseUrl = `${this.adminClientOptions.adminServerUrl}/session/${sessionId}`
 
             // Also open a stream connection, for 2-way communication we might need later.
             const adminServerStream = await this.openStreamToMockServer(adminSessionBaseUrl);
@@ -496,14 +485,8 @@ export class AdminClient<Plugins extends { [key: string]: AdminPlugin<any, any>
 
             if (this.debug) console.log('Started remote mock server');
 
-            const serverMetadata =
-                this.adminServerMetadata = // Set field before we resolve the promise
-                    'pluginData' in adminServerResponse
-                        ? adminServerResponse.pluginData
-                        : {
-                            // Backward compat - convert old always-HTTP data into per-plugin format:
-                            http: adminServerResponse
-                        } as unknown as PluginClientResponsesMap<Plugins>;
+            // Set field before we resolve the promise:
+            const serverMetadata = this.adminServerMetadata = adminServerResponse.pluginData;
 
             startPromise.resolve(true);
             return serverMetadata;

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

@@ -32,10 +32,6 @@ function normalizeHttpMessage(message: any, event?: SubscribableEvent) {
         // We use raw headers where possible to derive headers, instead of using any pre-derived
         // header data, for maximum accuracy (and to avoid any need to query for both).
         message.headers = rawHeadersToObject(message.rawHeaders);
-    } else if (message.headers) {
-        // Backward compat for older servers:
-        message.headers = JSON.parse(message.headers);
-        message.rawHeaders = objectHeadersToRaw(message.headers);
     }
 
     if (message.rawTrailers) {
@@ -236,19 +232,16 @@ export class MockttpAdminRequestBuilder {
 
                     ${this.schema.asOptionalField('InitiatedRequest', 'destination', 'destination { hostname, port }')}
 
-                    ${this.schema.typeHasField('InitiatedRequest', 'rawHeaders')
-                        ? 'rawHeaders'
-                        : 'headers'
-                    }
+                    rawHeaders
                     timingEvents
                     httpVersion
-                    ${this.schema.asOptionalField('InitiatedRequest', 'tags')}
+                    tags
                 }
             }`,
             request: gql`subscription OnRequest {
                 requestReceived {
                     id
-                    ${this.schema.asOptionalField('Request', 'matchedRuleId')}
+                    matchedRuleId
                     protocol
                     method
                     url
@@ -258,17 +251,13 @@ export class MockttpAdminRequestBuilder {
 
                     ${this.schema.asOptionalField('Request', 'destination', 'destination { hostname, port }')}
 
-                    ${this.schema.typeHasField('Request', 'rawHeaders')
-                        ? 'rawHeaders'
-                        : 'headers'
-                    }
-
+                    rawHeaders
                     body
                     ${this.schema.asOptionalField('Request', 'rawTrailers')}
 
-                    ${this.schema.asOptionalField('Request', 'timingEvents')}
-                    ${this.schema.asOptionalField('Request', 'httpVersion')}
-                    ${this.schema.asOptionalField('Request', 'tags')}
+                    timingEvents
+                    httpVersion
+                    tags
                 }
             }`,
             response: gql`subscription OnResponse {
@@ -277,16 +266,12 @@ export class MockttpAdminRequestBuilder {
                     statusCode
                     statusMessage
 
-                    ${this.schema.typeHasField('Response', 'rawHeaders')
-                        ? 'rawHeaders'
-                        : 'headers'
-                    }
-
+                    rawHeaders
                     body
                     ${this.schema.asOptionalField('Response', 'rawTrailers')}
 
-                    ${this.schema.asOptionalField('Response', 'timingEvents')}
-                    ${this.schema.asOptionalField('Response', 'tags')}
+                    timingEvents
+                    tags
                 }
             }`,
             'websocket-request': gql`subscription OnWebSocketRequest {
@@ -370,14 +355,12 @@ export class MockttpAdminRequestBuilder {
 
                     ${this.schema.asOptionalField('AbortedRequest', 'destination', 'destination { hostname, port }')}
 
-                    ${this.schema.typeHasField('Request', 'rawHeaders')
-                        ? 'rawHeaders'
-                        : 'headers'
-                    }
+                    rawHeaders
+
+                    timingEvents
+                    tags
 
-                    ${this.schema.asOptionalField('Request', 'timingEvents')}
-                    ${this.schema.asOptionalField('Request', 'tags')}
-                    ${this.schema.asOptionalField('AbortedRequest', 'error')}
+                    error
                 }
             }`,
             'tls-passthrough-opened': gql`subscription OnTlsPassthroughOpened {
@@ -397,7 +380,7 @@ export class MockttpAdminRequestBuilder {
                     remotePort
                     tags
                     timingEvents
-                    ${this.schema.asOptionalField('TlsPassthroughEvent', 'tlsMetadata')}
+                    tlsMetadata
                 }
             }`,
             'tls-passthrough-closed': gql`subscription OnTlsPassthroughClosed {
@@ -417,18 +400,18 @@ export class MockttpAdminRequestBuilder {
                     remotePort
                     tags
                     timingEvents
-                    ${this.schema.asOptionalField('TlsPassthroughEvent', 'tlsMetadata')}
+                    tlsMetadata
                 }
             }`,
             'tls-client-error': gql`subscription OnTlsClientError {
                 failedTlsRequest {
                     failureCause
                     hostname
                     remoteIpAddress
-                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'remotePort')}
-                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'tags')}
-                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'timingEvents')}
-                    ${this.schema.asOptionalField(['TlsHandshakeFailure', 'TlsRequest'], 'tlsMetadata')}
+                    remotePort
+                    tags
+                    timingEvents
+                    tlsMetadata
                 }
             }`,
             'client-error': gql`subscription OnClientError {
@@ -444,10 +427,7 @@ export class MockttpAdminRequestBuilder {
                         url
                         path
 
-                        ${this.schema.typeHasField('ClientErrorRequest', 'rawHeaders')
-                            ? 'rawHeaders'
-                            : 'headers'
-                        }
+                        rawHeaders
 
                         ${this.schema.asOptionalField('ClientErrorRequest', 'remoteIpAddress')}
                         ${this.schema.asOptionalField('ClientErrorRequest', 'remotePort')}
@@ -460,10 +440,7 @@ export class MockttpAdminRequestBuilder {
                         statusCode
                         statusMessage
 
-                        ${this.schema.typeHasField('Response', 'rawHeaders')
-                            ? 'rawHeaders'
-                            : 'headers'
-                        }
+                        rawHeaders
 
                         body
                         ${this.schema.asOptionalField('Response', 'rawTrailers')}
@@ -567,16 +544,13 @@ export class MockttpAdminRequestBuilder {
                                 path,
                                 hostname
 
-                                ${this.schema.typeHasField('Request', 'rawHeaders')
-                                    ? 'rawHeaders'
-                                    : 'headers'
-                                }
+                                rawHeaders
 
                                 body,
-                                ${this.schema.asOptionalField('Request', 'timingEvents')}
-                                ${this.schema.asOptionalField('Request', 'httpVersion')}
+                                timingEvents
+                                httpVersion
                             }
-                            ${this.schema.asOptionalField('MockedEndpoint', 'isPending')}
+                            isPending
                         }
                     }
                 `,

src/main.ts

@@ -24,14 +24,6 @@ export type {
     SocksServerOptions
 };
 
-// Export now-renamed types with the old aliases to provide backward compat and
-// avoid unnecessary type breakage:
-export type { TlsHandshakeFailure as TlsRequest } from './types';
-export type {
-    CertDataOptions as HttpsOptions,
-    CertPathOptions as HttpsPathOptions
-} from './util/tls';
-
 // Export rule data builders & type definitions:
 import * as matchers from './rules/matchers';
 import * as requestHandlers from './rules/requests/request-handlers';