Drop lodash & fastpath async APIs for performance

Author: pimterry

src/rules/matchers.ts

@@ -638,23 +638,31 @@ export const MatcherLookup = {
     'callback': CallbackMatcher,
 };
 
-export async function matchesAll(req: OngoingRequest, matchers: RequestMatcher[]): Promise<boolean> {
+export function matchesAll(req: OngoingRequest, matchers: RequestMatcher[]): MaybePromise<boolean> {
+    // Fast path: if all matchers return synchronously, avoid Promise overhead entirely.
+    // This is the common case (e.g. WildcardMatcher returns true synchronously).
+    const asyncResults: Array<Promise<boolean>> = [];
+
+    for (const matcher of matchers) {
+        const result = matcher.matches(req);
+        if (result === false) return false; // Sync mismatch — bail immediately
+        if (result !== true) asyncResults.push(result); // Got a Promise
+    }
+
+    if (asyncResults.length === 0) return true; // All sync true
+
+    // Async path: at least one matcher returned a Promise
     return new Promise<boolean>((resolve, reject) => {
-        const resultsPromises = matchers.map((matcher) => matcher.matches(req));
-
-        resultsPromises.forEach(async (maybePromiseResult) => {
-            try {
-                const result = await maybePromiseResult;
-                if (!result) resolve(false); // Resolve mismatches immediately
-            } catch (e) {
-                reject(e); // Resolve matcher failures immediately
-            }
-        });
+        for (const promise of asyncResults) {
+            promise.then(
+                (result) => { if (!result) resolve(false); },
+                (e) => reject(e)
+            );
+        }
 
-        // Otherwise resolve as normal: all true matches, exceptions reject.
-        Promise.all(resultsPromises)
-            .then((result) => resolve(_.every(result)))
-            .catch((e) => reject(e));
+        Promise.all(asyncResults)
+            .then((resolved) => resolve(resolved.every(Boolean)))
+            .catch(reject);
     });
 }
 

src/rules/passthrough-handling.ts

@@ -525,8 +525,8 @@ function shouldUseStrictHttps(
         skipHttpsErrors = true;
     } else if (Array.isArray(ignoreHostHttpsErrors) && (
         // if the whole hostname or host+port is whitelisted
-        _.includes(ignoreHostHttpsErrors, hostname) ||
-        _.includes(ignoreHostHttpsErrors, `${hostname}:${port}`)
+        ignoreHostHttpsErrors.includes(hostname) ||
+        ignoreHostHttpsErrors.includes(`${hostname}:${port}`)
     )) {
         skipHttpsErrors = true;
     }

src/server/mockttp-server.ts

@@ -1,5 +1,4 @@
 import { Buffer } from 'buffer';
-import * as stream from 'stream';
 import * as fs from 'fs';
 import * as net from "net";
 import * as tls from "tls";
@@ -18,21 +17,17 @@ import { Mutex } from 'async-mutex';
 import { ErrorLike, isErrorLike, UnreachableCheck } from '@httptoolkit/util';
 
 import {
-    Destination,
     InitiatedRequest,
     OngoingRequest,
     CompletedRequest,
     OngoingResponse,
     CompletedResponse,
     TlsHandshakeFailure,
     ClientError,
-    TimingEvents,
-    OngoingBody,
     WebSocketMessage,
     WebSocketClose,
     TlsPassthroughEvent,
     RuleEvent,
-    RawTrailers,
     RawPassthroughEvent,
     RawPassthroughDataEvent,
     RawHeaders,
@@ -51,17 +46,7 @@ import { RequestRule, RequestRuleData } from "../rules/requests/request-rule";
 import { ServerMockedEndpoint } from "./mocked-endpoint";
 import { createComboServer } from "./http-combo-server";
 import { filter } from "../util/promise";
-import { Mutable } from "../util/type-utils";
-import { makePropertyWritable } from "../util/util";
 
-import {
-    isAbsoluteUrl,
-    getPathFromAbsoluteUrl,
-    getHostFromAbsoluteUrl,
-    getDestination,
-    normalizeHost,
-} from "../util/url";
-import { isIP } from "../util/ip-utils";
 import {
     buildRawSocketEventData,
     buildTlsSocketEventData,
@@ -72,15 +57,12 @@ import {
 import {
     ClientErrorInProgress,
     LastHopEncrypted,
-    LastTunnelAddress,
     TlsSetupCompleted,
     SocketMetadata,
     TlsMetadata,
-    SocketTimingInfo
 } from '../util/socket-extensions';
 import { getSocketMetadataTags, getSocketMetadataFromProxyAuth } from '../util/socket-metadata'
 import {
-    parseRequestBody,
     waitForCompletedRequest,
     trackResponse,
     waitForCompletedResponse,
@@ -94,9 +76,7 @@ import {
 } from "../util/request-utils";
 import { asBuffer } from "../util/buffer-utils";
 import {
-    getHeaderValue,
     pairFlatRawHeaders,
-    rawHeadersToObject
 } from "../util/header-utils";
 import { AbortError } from "../rules/requests/request-step-impls";
 import { WebSocketRuleData, WebSocketRule } from "../rules/websockets/websocket-rule";
@@ -391,13 +371,9 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
 
         setImmediate(() => {
             const initiatedReq = buildInitiatedRequest(request);
-            emitter.emit('request-initiated', Object.assign(
-                initiatedReq,
-                {
-                    timingEvents: _.clone(initiatedReq.timingEvents),
-                    tags: _.clone(initiatedReq.tags)
-                }
-            ));
+            initiatedReq.timingEvents = { ...initiatedReq.timingEvents };
+            initiatedReq.tags = initiatedReq.tags.slice();
+            emitter.emit('request-initiated', initiatedReq);
         });
     }
 
@@ -407,13 +383,9 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
         waitForCompletedRequest(request)
         .then((completedReq: CompletedRequest) => {
             setImmediate(() => {
-                emitter.emit('request', Object.assign(
-                    completedReq,
-                    {
-                        timingEvents: _.clone(completedReq.timingEvents),
-                        tags: _.clone(completedReq.tags)
-                    }
-                ));
+                completedReq.timingEvents = { ...completedReq.timingEvents };
+                completedReq.tags = completedReq.tags.slice();
+                emitter.emit('request', completedReq);
             });
         })
         .catch(console.error);
@@ -424,13 +396,9 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
 
         setImmediate(() => {
             const initiatedRes = buildInitiatedResponse(response);
-            emitter.emit('response-initiated', Object.assign(
-                initiatedRes,
-                {
-                    timingEvents: _.clone(initiatedRes.timingEvents),
-                    tags: _.clone(initiatedRes.tags)
-                }
-            ));
+            initiatedRes.timingEvents = { ...initiatedRes.timingEvents };
+            initiatedRes.tags = initiatedRes.tags.slice();
+            emitter.emit('response-initiated', initiatedRes);
         });
     }
 
@@ -440,10 +408,9 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
         waitForCompletedResponse(response)
         .then((res: CompletedResponse) => {
             setImmediate(() => {
-                emitter.emit('response', Object.assign(res, {
-                    timingEvents: _.clone(res.timingEvents),
-                    tags: _.clone(res.tags)
-                }));
+                res.timingEvents = { ...res.timingEvents };
+                res.tags = res.tags.slice();
+                emitter.emit('response', res);
             });
         })
         .catch(console.error);
@@ -455,10 +422,9 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
         waitForCompletedRequest(request)
         .then((completedReq: CompletedRequest) => {
             setImmediate(() => {
-                emitter.emit('websocket-request', Object.assign(completedReq, {
-                    timingEvents: _.clone(completedReq.timingEvents),
-                    tags: _.clone(completedReq.tags)
-                }));
+                completedReq.timingEvents = { ...completedReq.timingEvents };
+                completedReq.tags = completedReq.tags.slice();
+                emitter.emit('websocket-request', completedReq);
             });
         })
         .catch(console.error);
@@ -470,8 +436,8 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
         setImmediate(() => {
             emitter.emit('websocket-accepted', {
                 ...response,
-                timingEvents: _.clone(response.timingEvents),
-                tags: _.clone(response.tags)
+                timingEvents: { ...response.timingEvents },
+                tags: response.tags.slice()
             });
         });
     }
@@ -603,9 +569,9 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
     private async announceAbortAsync(emitter: EventEmitter, request: OngoingRequest, abortError?: ErrorLike) {
         setImmediate(() => {
             const req = buildInitiatedRequest(request);
+            req.timingEvents = { ...req.timingEvents };
+            req.tags = req.tags.slice();
             emitter.emit('abort', Object.assign(req, {
-                timingEvents: _.clone(req.timingEvents),
-                tags: _.clone(req.tags),
                 error: abortError ? {
                     name: abortError.name,
                     code: abortError.code,
@@ -891,7 +857,8 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
             // There are no incomplete & matching rules! One last option: if the last matching rule is
             // maybe-incomplete (i.e. default completion status but has seen >0 requests) then it should
             // match anyway. This allows us to add rules and have the last repeat indefinitely.
-            const lastMatchingRule = _.last(await filter(rulesMatches, m => m.match))?.rule;
+            const matchingRules = await filter(rulesMatches, m => m.match);
+            const lastMatchingRule = matchingRules[matchingRules.length - 1]?.rule;
             if (!lastMatchingRule || lastMatchingRule.isComplete()) continue; // On to lower priority matches
             // Otherwise, must be a rule with isComplete === null, i.e. no specific completion check:
             else return lastMatchingRule;

src/util/header-utils.ts

@@ -60,7 +60,12 @@ export function pairFlatRawHeaders(flatRawHeaders: string[]): RawHeaders {
 }
 
 export function flattenPairedRawHeaders(rawHeaders: RawHeaders): string[] {
-    return rawHeaders.flat();
+    const result = new Array(rawHeaders.length * 2);
+    for (let i = 0; i < rawHeaders.length; i++) {
+        result[i * 2] = rawHeaders[i][0];
+        result[i * 2 + 1] = rawHeaders[i][1];
+    }
+    return result;
 }
 
 /**

src/util/request-utils.ts

@@ -488,21 +488,19 @@ export function preprocessRequest(req: ExtendedRawRequest, options: {
  */
 export function buildInitiatedRequest(request: OngoingRequest): InitiatedRequest {
     return {
-        ..._.pick(request,
-            'id',
-            'matchedRuleId',
-            'protocol',
-            'httpVersion',
-            'method',
-            'url',
-            'path',
-            'remoteIpAddress',
-            'remotePort',
-            'destination',
-            'headers',
-            'rawHeaders',
-            'tags'
-        ),
+        id: request.id,
+        matchedRuleId: request.matchedRuleId,
+        protocol: request.protocol,
+        httpVersion: request.httpVersion,
+        method: request.method,
+        url: request.url!,
+        path: request.path!,
+        remoteIpAddress: request.remoteIpAddress,
+        remotePort: request.remotePort,
+        destination: request.destination,
+        headers: request.headers,
+        rawHeaders: request.rawHeaders,
+        tags: request.tags,
         timingEvents: request.timingEvents
     };
 }
@@ -736,23 +734,17 @@ function emitBodyDataEvents(
  * that's just started.
  */
 export function buildInitiatedResponse(response: OngoingResponse): InitiatedResponse {
-    const initiatedResponse: InitiatedResponse = _(response).pick([
-        'id',
-        'statusCode',
-        'timingEvents',
-        'tags'
-    ]).assign({
-        statusMessage: '',
+    return {
+        id: response.id,
+        statusCode: response.statusCode,
+        statusMessage: (response instanceof http2.Http2ServerResponse)
+            ? '' // H2 has no status messages, and generates a warning if you look for one
+            : response.statusMessage,
         headers: response.getHeaders(),
         rawHeaders: response.getRawHeaders(),
-    }).valueOf();
-
-    if (!(response instanceof http2.Http2ServerResponse)) {
-        // H2 has no status messages, and generates a warning if you look for one
-        initiatedResponse.statusMessage = response.statusMessage;
-    }
-
-    return initiatedResponse;
+        timingEvents: response.timingEvents,
+        tags: response.tags
+    };
 }
 
 /**