@stuntman/server 0.1.6 → 0.1.8

package/src/api/api.ts

@@ -19,67 +19,81 @@ const API_KEY_HEADER = 'x-api-key';
 
 export class API {
     protected options: Required<ApiOptions>;
-    protected apiApp: ExpressServer;
+    protected webGuiOptions: Stuntman.WebGuiConfig;
+    protected apiApp: ExpressServer | null = null;
     trafficStore: LRUCache<string, Stuntman.LogEntry>;
     server: http.Server | null = null;
-    auth: (req: Request, type: 'read' | 'write') => void;
-    authReadOnly: (req: Request, res: Response, next: NextFunction) => void;
-    authReadWrite: (req: Request, res: Response, next: NextFunction) => void;
 
-    constructor(options: ApiOptions, webGuiOptions?: Stuntman.WebGuiConfig) {
+    constructor(options: ApiOptions, webGuiOptions: Stuntman.WebGuiConfig = { disabled: false }) {
         if (!options.apiKeyReadOnly !== !options.apiKeyReadWrite) {
             throw new Error('apiKeyReadOnly and apiKeyReadWrite options need to be set either both or none');
         }
         this.options = options;
+        this.webGuiOptions = webGuiOptions;
 
         this.trafficStore = getTrafficStore(this.options.mockUuid);
-        this.apiApp = express();
-
-        this.apiApp.use(express.json());
-        this.apiApp.use(express.text());
+        this.auth = this.auth.bind(this);
+        this.authReadOnly = this.authReadOnly.bind(this);
+        this.authReadWrite = this.authReadWrite.bind(this);
+    }
 
-        this.auth = (req: Request, type: 'read' | 'write'): void => {
-            if (!this.options.apiKeyReadOnly && !this.options.apiKeyReadWrite) {
-                return;
-            }
-            const hasValidReadKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadOnly;
-            const hasValidWriteKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadWrite;
-            const hasValidKey = type === 'read' ? hasValidReadKey || hasValidWriteKey : hasValidWriteKey;
-            if (!hasValidKey) {
-                throw new AppError({ httpCode: HttpCode.UNAUTHORIZED, message: 'unauthorized' });
-            }
+    private auth(req: Request, type: 'read' | 'write'): void {
+        if (!this.options.apiKeyReadOnly && !this.options.apiKeyReadWrite) {
             return;
-        };
+        }
+        const hasValidReadKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadOnly;
+        const hasValidWriteKey = req.header(API_KEY_HEADER) === this.options.apiKeyReadWrite;
+        const hasValidKey = type === 'read' ? hasValidReadKey || hasValidWriteKey : hasValidWriteKey;
+        if (!hasValidKey) {
+            throw new AppError({ httpCode: HttpCode.UNAUTHORIZED, message: 'unauthorized' });
+        }
+        return;
+    }
 
-        this.authReadOnly = (req: Request, res: Response, next: NextFunction): void => {
-            this.auth(req, 'read');
-            next();
-        };
+    protected authReadOnly(req: Request, _res: Response, next: NextFunction): void {
+        this.auth(req, 'read');
+        next();
+    }
 
-        this.authReadWrite = (req: Request, res: Response, next: NextFunction): void => {
-            this.auth(req, 'write');
-            next();
-        };
+    protected authReadWrite(req: Request, _res: Response, next: NextFunction): void {
+        this.auth(req, 'write');
+        next();
+    }
+
+    private initApi() {
+        this.apiApp = express();
 
-        this.apiApp.use((req: Request, res: Response, next: NextFunction) => {
+        this.apiApp.use(express.json());
+        this.apiApp.use(express.text());
+
+        this.apiApp.use((req: Request, _res: Response, next: NextFunction) => {
             RequestContext.bind(req, this.options.mockUuid);
             next();
         });
 
-        this.apiApp.get('/rule', this.authReadOnly, async (req, res) => {
+        this.apiApp.get('/rule', this.authReadOnly.bind, async (_req, res) => {
             res.send(stringify(await getRuleExecutor(this.options.mockUuid).getRules()));
         });
 
         this.apiApp.get('/rule/:ruleId', this.authReadOnly, async (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             res.send(stringify(await getRuleExecutor(this.options.mockUuid).getRule(req.params.ruleId)));
         });
 
         this.apiApp.get('/rule/:ruleId/disable', this.authReadWrite, (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             getRuleExecutor(this.options.mockUuid).disableRule(req.params.ruleId);
             res.send();
         });
 
         this.apiApp.get('/rule/:ruleId/enable', this.authReadWrite, (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             getRuleExecutor(this.options.mockUuid).enableRule(req.params.ruleId);
             res.send();
         });
@@ -98,11 +112,14 @@ export class API {
         );
 
         this.apiApp.get('/rule/:ruleId/remove', this.authReadWrite, async (req, res) => {
+            if (!req.params.ruleId) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleId' });
+            }
             await getRuleExecutor(this.options.mockUuid).removeRule(req.params.ruleId);
             res.send();
         });
 
-        this.apiApp.get('/traffic', this.authReadOnly, (req, res) => {
+        this.apiApp.get('/traffic', this.authReadOnly, (_req, res) => {
             const serializedTraffic: Stuntman.LogEntry[] = [];
             for (const value of this.trafficStore.values()) {
                 serializedTraffic.push(value);
@@ -111,6 +128,9 @@ export class API {
         });
 
         this.apiApp.get('/traffic/:ruleIdOrLabel', this.authReadOnly, (req, res) => {
+            if (!req.params.ruleIdOrLabel) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'missing ruleIdOrLabel' });
+            }
             const serializedTraffic: Stuntman.LogEntry[] = [];
             for (const value of this.trafficStore.values()) {
                 if (value.mockRuleId === req.params.ruleIdOrLabel || (value.labels || []).includes(req.params.ruleIdOrLabel)) {
@@ -120,13 +140,13 @@ export class API {
             res.json(serializedTraffic);
         });
 
-        if (!webGuiOptions?.disabled) {
+        if (!this.webGuiOptions.disabled) {
             this.apiApp.set('views', __dirname + '/webgui');
             this.apiApp.set('view engine', 'pug');
             this.initWebGui();
         }
 
-        this.apiApp.all(/.*/, (req: Request, res: Response) => res.status(404).send());
+        this.apiApp.all(/.*/, (_req: Request, res: Response) => res.status(404).send());
 
         this.apiApp.use((error: Error | AppError, req: Request, res: Response) => {
             const ctx: RequestContext | null = RequestContext.get(req);
@@ -152,7 +172,10 @@ export class API {
     }
 
     private initWebGui() {
-        this.apiApp.get('/webgui/rules', this.authReadOnly, async (req, res) => {
+        if (!this.apiApp) {
+            throw new Error('initialization error');
+        }
+        this.apiApp.get('/webgui/rules', this.authReadOnly, async (_req, res) => {
             const rules: Record<string, string> = {};
             for (const rule of await getRuleExecutor(this.options.mockUuid).getRules()) {
                 rules[rule.id] = serializeJavascript(liveRuleToRule(rule), { unsafe: true });
@@ -160,7 +183,7 @@ export class API {
             res.render('rules', { rules: escapedSerialize(rules), INDEX_DTS, ruleKeys: Object.keys(rules) });
         });
 
-        this.apiApp.get('/webgui/traffic', this.authReadOnly, async (req, res) => {
+        this.apiApp.get('/webgui/traffic', this.authReadOnly, async (_req, res) => {
             const serializedTraffic: Stuntman.LogEntry[] = [];
             for (const value of this.trafficStore.values()) {
                 serializedTraffic.push(value);
@@ -208,6 +231,10 @@ export class API {
         if (this.server) {
             throw new Error('mock server already started');
         }
+        this.initApi();
+        if (!this.apiApp) {
+            throw new Error('initialization error');
+        }
         this.server = this.apiApp.listen(this.options.port, () => {
             logger.info(`API listening on ${this.options.port}`);
         });

package/src/api/webgui/rules.pug

@@ -22,6 +22,7 @@ html
             div(style='margin-left: 240px')
                 #container(style='height: 400px')
                     script.
+                        /* eslint no-undef: 0 */
                         const uuidv4 = () => {
                             function getRandomSymbol(symbol) {
                                 var array;
@@ -72,7 +73,6 @@ html
                             }
                             const editor = monaco.editor.create(document.getElementById('container'), {
                                 theme: 'vs-dark',
-                                autoIndent: true,
                                 formatOnPaste: true,
                                 formatOnType: true,
                                 automaticLayout: true,
@@ -135,7 +135,7 @@ html
 
                             window.newRule = () => {
                                 const ruleId = uuidv4();
-                                const emptyRule = `import type * as Stuntman from \'stuntman\';\n\nvar STUNTMAN_RULE: Stuntman.Rule = { id: '${ruleId}', matches: (req: Stuntman.Request) => true, ttlSeconds: 600, actions: { mockResponse: { status: '200', body: '${ruleId}' }} };`;
+                                const emptyRule = `import type * as Stuntman from 'stuntman';\n\nvar STUNTMAN_RULE: Stuntman.Rule = { id: '${ruleId}', matches: (req: Stuntman.Request) => true, ttlSeconds: 600, actions: { mockResponse: { status: '200', body: '${ruleId}' }} };`;
                                 models[ruleId] = monaco.editor.createModel(emptyRule, 'typescript', `file:///${ruleId}.ts`);
                                 const ruleKeyNode = document.getElementById('ruleKeys').firstChild;
                                 const ruleKeyNodeClone = ruleKeyNode.cloneNode(true);

package/src/api/webgui/style.css

@@ -21,8 +21,8 @@ button.rule {
 }
 
 ul.no-bullets {
-    list-style-type: none; /* Remove bullets */
-    padding: 0; /* Remove padding */
-    margin: 0; /* Remove margins */
+    list-style-type: none;
+    padding: 0;
+    margin: 0;
     text-align: left;
 }

package/src/api/webgui/traffic.pug

@@ -12,6 +12,7 @@ html
             div(style='margin-left: 220px')
                 #container(style='height: 800px')
                     script.
+                        /* eslint no-undef: 0 */
                         require.config({
                             paths: {
                                 vs: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.35.0/min/vs',

package/src/bin/stuntman.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import { Mock } from '../mock';
-import { serverConfig } from '@stuntman/shared';
+import { stuntmanConfig } from '@stuntman/shared';
 
-const mock = new Mock(serverConfig);
+const mock = new Mock(stuntmanConfig);
 
 mock.start();

package/src/ipUtils.ts

@@ -55,7 +55,7 @@ export class IPUtils {
                     return;
                 }
                 logger.debug({ ip: addresses, hostname }, 'resolved hostname');
-                resolve([addresses[0], ...addresses.slice(1)]);
+                resolve([addresses[0]!, ...addresses.slice(1)]);
             };
             if (options?.useExternalDns) {
                 if (!this.externalDns) {

package/src/mock.ts

@@ -6,7 +6,7 @@ import express from 'express';
 import { v4 as uuidv4 } from 'uuid';
 import { getRuleExecutor } from './ruleExecutor';
 import { getTrafficStore } from './storage';
-import { RawHeaders, logger, HttpCode } from '@stuntman/shared';
+import { RawHeaders, logger, HttpCode, naiveGQLParser, escapeStringRegexp } from '@stuntman/shared';
 import RequestContext from './requestContext';
 import type * as Stuntman from '@stuntman/shared';
 import { IPUtils } from './ipUtils';
@@ -17,42 +17,12 @@ type WithRequiredProperty<Type, Key extends keyof Type> = Type & {
     [Property in Key]-?: Type[Property];
 };
 
-const naiveGQLParser = (body: Buffer | string): Stuntman.GQLRequestBody | undefined => {
-    try {
-        let json: Stuntman.GQLRequestBody | undefined = undefined;
-        try {
-            json = JSON.parse(Buffer.isBuffer(body) ? body.toString('utf-8') : body);
-        } catch (kiss) {
-            // and swallow
-        }
-        if (!json?.query && !json?.operationName) {
-            return;
-        }
-        const lines = json.query
-            .split('\n')
-            .map((l) => l.replace(/^\s+/g, '').trim())
-            .filter((l) => !!l);
-        if (/^query /.test(lines[0])) {
-            json.type = 'query';
-        } else if (/^mutation /.test(lines[0])) {
-            json.type = 'mutation';
-        } else {
-            throw new Error(`Unable to resolve query type of ${lines[0]}`);
-        }
-        json.methodName = lines[json.operationName ? 1 : 0].split('(')[0].split('{')[0];
-        return json;
-    } catch (error) {
-        logger.debug(error, 'unable to parse GQL');
-    }
-    return undefined;
-};
-
 // TODO add proper web proxy mode
 
 export class Mock {
     public readonly mockUuid: string;
-    protected options: Stuntman.ServerConfig;
-    protected mockApp: express.Express;
+    protected options: Stuntman.Config;
+    protected mockApp: express.Express | null = null;
     protected MOCK_DOMAIN_REGEX: RegExp;
     protected URL_PORT_REGEX: RegExp;
     protected server: http.Server | null = null;
@@ -60,7 +30,6 @@ export class Mock {
     protected trafficStore: LRUCache<string, Stuntman.LogEntry>;
     protected ipUtils: IPUtils | null = null;
     private _api: API | null = null;
-    private requestHandler: (req: express.Request, res: express.Response) => Promise<void>;
 
     get apiServer() {
         if (this.options.api.disabled) {
@@ -76,7 +45,7 @@ export class Mock {
         return getRuleExecutor(this.mockUuid);
     }
 
-    constructor(options: Stuntman.ServerConfig) {
+    constructor(options: Stuntman.Config) {
         this.mockUuid = uuidv4();
         this.options = options;
         if (this.options.mock.httpsPort && (!this.options.mock.httpsKey || !this.options.mock.httpsCert)) {
@@ -101,147 +70,151 @@ export class Mock {
                 ? null
                 : new IPUtils({ mockUuid: this.mockUuid, externalDns: this.options.mock.externalDns });
 
-        this.requestHandler = async (req: express.Request, res: express.Response): Promise<void> => {
-            const ctx: RequestContext | null = RequestContext.get(req);
-            const requestUuid = ctx?.uuid || uuidv4();
-            const timestamp = Date.now();
-            const originalHostname = req.headers.host || req.hostname;
-            const unproxiedHostname = req.hostname.replace(this.MOCK_DOMAIN_REGEX, '');
-            const isProxiedHostname = originalHostname !== unproxiedHostname;
-            const originalRequest = {
+        this.requestHandler = this.requestHandler.bind(this);
+    }
+
+    private async requestHandler(req: express.Request, res: express.Response): Promise<void> {
+        const ctx: RequestContext | null = RequestContext.get(req);
+        const requestUuid = ctx?.uuid || uuidv4();
+        const timestamp = Date.now();
+        const originalHostname = req.headers.host || req.hostname;
+        const unproxiedHostname = req.hostname.replace(this.MOCK_DOMAIN_REGEX, '');
+        const isProxiedHostname = originalHostname !== unproxiedHostname;
+        const originalRequest = {
+            id: requestUuid,
+            timestamp,
+            url: `${req.protocol}://${req.hostname}${req.originalUrl}`,
+            method: req.method,
+            rawHeaders: new RawHeaders(...req.rawHeaders),
+            ...((Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }) ||
+                (typeof req.body === 'string' && { body: req.body })),
+        };
+        logger.debug(originalRequest, 'processing request');
+        const logContext: Record<string, any> = {
+            requestId: originalRequest.id,
+        };
+        const mockEntry: WithRequiredProperty<Stuntman.LogEntry, 'modifiedRequest'> = {
+            originalRequest,
+            modifiedRequest: {
+                ...this.unproxyRequest(req),
                 id: requestUuid,
                 timestamp,
-                url: `${req.protocol}://${req.hostname}${req.originalUrl}`,
-                method: req.method,
-                rawHeaders: new RawHeaders(...req.rawHeaders),
-                ...((Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }) ||
-                    (typeof req.body === 'string' && { body: req.body })),
-            };
-            logger.debug(originalRequest, 'processing request');
-            const logContext: Record<string, any> = {
-                requestId: originalRequest.id,
-            };
-            const mockEntry: WithRequiredProperty<Stuntman.LogEntry, 'modifiedRequest'> = {
-                originalRequest,
-                modifiedRequest: {
-                    ...this.unproxyRequest(req),
-                    id: requestUuid,
-                    timestamp,
-                    ...(originalRequest.body && { gqlBody: naiveGQLParser(originalRequest.body) }),
-                },
-            };
-            if (!isProxiedHostname) {
-                this.removeProxyPort(mockEntry.modifiedRequest);
-            }
-            const matchingRule = await getRuleExecutor(this.mockUuid).findMatchingRule(mockEntry.modifiedRequest);
-            if (matchingRule) {
-                mockEntry.mockRuleId = matchingRule.id;
-                mockEntry.labels = matchingRule.labels;
-                if (matchingRule.actions.mockResponse) {
-                    const staticResponse =
-                        typeof matchingRule.actions.mockResponse === 'function'
-                            ? matchingRule.actions.mockResponse(mockEntry.modifiedRequest)
-                            : matchingRule.actions.mockResponse;
-                    mockEntry.modifiedResponse = staticResponse;
-                    logger.debug({ ...logContext, staticResponse }, 'replying with mocked response');
-                    if (matchingRule.storeTraffic) {
-                        this.trafficStore.set(requestUuid, mockEntry);
-                    }
-                    if (staticResponse.rawHeaders) {
-                        for (const header of staticResponse.rawHeaders.toHeaderPairs()) {
-                            res.setHeader(header[0], header[1]);
-                        }
-                    }
-                    res.status(staticResponse.status || 200);
-                    res.send(staticResponse.body);
-                    // static response blocks any further processing
-                    return;
+                ...(originalRequest.body && { gqlBody: naiveGQLParser(originalRequest.body) }),
+            },
+        };
+        if (!isProxiedHostname) {
+            this.removeProxyPort(mockEntry.modifiedRequest);
+        }
+        const matchingRule = await getRuleExecutor(this.mockUuid).findMatchingRule(mockEntry.modifiedRequest);
+        if (matchingRule) {
+            mockEntry.mockRuleId = matchingRule.id;
+            mockEntry.labels = matchingRule.labels;
+            if (matchingRule.actions.mockResponse) {
+                const staticResponse =
+                    typeof matchingRule.actions.mockResponse === 'function'
+                        ? matchingRule.actions.mockResponse(mockEntry.modifiedRequest)
+                        : matchingRule.actions.mockResponse;
+                mockEntry.modifiedResponse = staticResponse;
+                logger.debug({ ...logContext, staticResponse }, 'replying with mocked response');
+                if (matchingRule.storeTraffic) {
+                    this.trafficStore.set(requestUuid, mockEntry);
                 }
-                if (matchingRule.actions.modifyRequest) {
-                    mockEntry.modifiedRequest = matchingRule.actions.modifyRequest(mockEntry.modifiedRequest);
-                    logger.debug({ ...logContext, modifiedRequest: mockEntry.modifiedRequest }, 'modified original request');
+                if (staticResponse.rawHeaders) {
+                    for (const header of staticResponse.rawHeaders.toHeaderPairs()) {
+                        res.setHeader(header[0], header[1]);
+                    }
                 }
+                res.status(staticResponse.status || 200);
+                res.send(staticResponse.body);
+                // static response blocks any further processing
+                return;
             }
-            if (this.ipUtils && !isProxiedHostname && !this.ipUtils.isIP(originalHostname)) {
-                const hostname = originalHostname.split(':')[0];
-                try {
-                    const internalIPs = await this.ipUtils.resolveIP(hostname);
-                    if (this.ipUtils.isLocalhostIP(internalIPs) && this.options.mock.externalDns.length) {
-                        const externalIPs = await this.ipUtils.resolveIP(hostname, { useExternalDns: true });
-                        logger.debug({ ...logContext, hostname, externalIPs, internalIPs }, 'switched to external IP');
-                        mockEntry.modifiedRequest.url = mockEntry.modifiedRequest.url.replace(
-                            /^(https?:\/\/)[^:/]+/i,
-                            `$1${externalIPs}`
-                        );
-                    }
-                } catch (error) {
-                    // swallow the exeception, don't think much can be done at this point
-                    logger.warn({ ...logContext, error }, `error trying to resolve IP for "${hostname}"`);
+            if (matchingRule.actions.modifyRequest) {
+                mockEntry.modifiedRequest = matchingRule.actions.modifyRequest(mockEntry.modifiedRequest);
+                logger.debug({ ...logContext, modifiedRequest: mockEntry.modifiedRequest }, 'modified original request');
+            }
+        }
+        if (this.ipUtils && !isProxiedHostname && !this.ipUtils.isIP(originalHostname)) {
+            const hostname = originalHostname.split(':')[0]!;
+            try {
+                const internalIPs = await this.ipUtils.resolveIP(hostname);
+                if (this.ipUtils.isLocalhostIP(internalIPs) && this.options.mock.externalDns.length) {
+                    const externalIPs = await this.ipUtils.resolveIP(hostname, { useExternalDns: true });
+                    logger.debug({ ...logContext, hostname, externalIPs, internalIPs }, 'switched to external IP');
+                    mockEntry.modifiedRequest.url = mockEntry.modifiedRequest.url.replace(
+                        /^(https?:\/\/)[^:/]+/i,
+                        `$1${externalIPs}`
+                    );
                 }
+            } catch (error) {
+                // swallow the exeception, don't think much can be done at this point
+                logger.warn({ ...logContext, error }, `error trying to resolve IP for "${hostname}"`);
             }
+        }
 
-            const originalResponse: Required<Stuntman.Response> = this.options.mock.disableProxy
-                ? {
-                      timestamp: Date.now(),
-                      body: undefined,
-                      rawHeaders: new RawHeaders(),
-                      status: 404,
-                  }
-                : await this.proxyRequest(req, mockEntry, logContext);
+        const originalResponse: Required<Stuntman.Response> = this.options.mock.disableProxy
+            ? {
+                  timestamp: Date.now(),
+                  body: undefined,
+                  rawHeaders: new RawHeaders(),
+                  status: 404,
+              }
+            : await this.proxyRequest(req, mockEntry, logContext);
 
-            logger.debug({ ...logContext, originalResponse }, 'received response');
-            mockEntry.originalResponse = originalResponse;
-            let modifedResponse: Stuntman.Response = {
-                ...originalResponse,
-                rawHeaders: new RawHeaders(
-                    ...Array.from(originalResponse.rawHeaders.toHeaderPairs()).flatMap(([key, value]) => {
-                        // TODO this replace may be too aggressive and doesn't handle protocol (won't be necessary with a trusted cert and mock serving http+https)
-                        return [
-                            key,
-                            isProxiedHostname
-                                ? value
-                                : value.replace(
-                                      new RegExp(`(?:^|\\b)(${unproxiedHostname.replace('.', '\\.')})(?:\\b|$)`, 'igm'),
-                                      originalHostname
-                                  ),
-                        ];
-                    })
-                ),
-            };
-            if (matchingRule?.actions.modifyResponse) {
-                modifedResponse = matchingRule?.actions.modifyResponse(mockEntry.modifiedRequest, originalResponse);
-                logger.debug({ ...logContext, modifedResponse }, 'modified response');
-            }
+        logger.debug({ ...logContext, originalResponse }, 'received response');
+        mockEntry.originalResponse = originalResponse;
+        let modifedResponse: Stuntman.Response = {
+            ...originalResponse,
+            rawHeaders: new RawHeaders(
+                ...Array.from(originalResponse.rawHeaders.toHeaderPairs()).flatMap(([key, value]) => {
+                    // TODO this replace may be too aggressive and doesn't handle protocol (won't be necessary with a trusted cert and mock serving http+https)
+                    return [
+                        key,
+                        isProxiedHostname
+                            ? value
+                            : value.replace(
+                                  new RegExp(`(?:^|\\b)(${escapeStringRegexp(unproxiedHostname)})(?:\\b|$)`, 'igm'),
+                                  originalHostname
+                              ),
+                    ];
+                })
+            ),
+        };
+        if (matchingRule?.actions.modifyResponse) {
+            modifedResponse = matchingRule?.actions.modifyResponse(mockEntry.modifiedRequest, originalResponse);
+            logger.debug({ ...logContext, modifedResponse }, 'modified response');
+        }
 
-            mockEntry.modifiedResponse = modifedResponse;
-            if (matchingRule?.storeTraffic) {
-                this.trafficStore.set(requestUuid, mockEntry);
-            }
+        mockEntry.modifiedResponse = modifedResponse;
+        if (matchingRule?.storeTraffic) {
+            this.trafficStore.set(requestUuid, mockEntry);
+        }
 
-            if (modifedResponse.status) {
-                res.status(modifedResponse.status);
-            }
-            if (modifedResponse.rawHeaders) {
-                for (const header of modifedResponse.rawHeaders.toHeaderPairs()) {
-                    // since fetch decompresses responses we need to get rid of some headers
-                    // TODO maybe could be handled better than just skipping, although express should add these back for new body
-                    // if (/^content-(?:length|encoding)$/i.test(header[0])) {
-                    //     continue;
-                    // }
-                    res.setHeader(
-                        header[0],
-                        isProxiedHostname ? header[1].replace(unproxiedHostname, originalHostname) : header[1]
-                    );
-                }
+        if (modifedResponse.status) {
+            res.status(modifedResponse.status);
+        }
+        if (modifedResponse.rawHeaders) {
+            for (const header of modifedResponse.rawHeaders.toHeaderPairs()) {
+                // since fetch decompresses responses we need to get rid of some headers
+                // TODO maybe could be handled better than just skipping, although express should add these back for new body
+                // if (/^content-(?:length|encoding)$/i.test(header[0])) {
+                //     continue;
+                // }
+                res.setHeader(header[0], isProxiedHostname ? header[1].replace(unproxiedHostname, originalHostname) : header[1]);
             }
-            res.end(Buffer.from(modifedResponse.body, 'binary'));
-        };
+        }
+        res.end(Buffer.from(modifedResponse.body, 'binary'));
+    }
 
+    init() {
+        if (this.mockApp) {
+            return;
+        }
         this.mockApp = express();
         // TODO for now request body is just a buffer passed further, not inflated
         this.mockApp.use(express.raw({ type: '*/*' }));
 
-        this.mockApp.use((req: express.Request, res: express.Response, next: express.NextFunction) => {
+        this.mockApp.use((req: express.Request, _res: express.Response, next: express.NextFunction) => {
             RequestContext.bind(req, this.mockUuid);
             next();
         });
@@ -315,6 +288,10 @@ export class Mock {
     }
 
     public start() {
+        this.init();
+        if (!this.mockApp) {
+            throw new Error('initialization error');
+        }
         if (this.server) {
             throw new Error('mock server already started');
         }
@@ -376,7 +353,7 @@ export class Mock {
             host.endsWith(`:${this.options.mock.port}`) ||
             (this.options.mock.httpsPort && host.endsWith(`:${this.options.mock.httpsPort}`))
         ) {
-            req.rawHeaders.set('host', host.split(':')[0]);
+            req.rawHeaders.set('host', host.split(':')[0]!);
         }
     }
 }

package/src/ruleExecutor.ts

@@ -136,6 +136,7 @@ class RuleExecutor implements Stuntman.RuleExecutorInterface {
             } catch (error) {
                 logger.error({ ...logContext, ruleId: rule?.id, error }, 'error in rule match function');
             }
+            return undefined;
         });
         if (!matchingRule) {
             logger.debug(logContext, 'no matching rule found');
@@ -207,5 +208,5 @@ export const getRuleExecutor = (mockUuid: string): RuleExecutor => {
             [...DEFAULT_RULES, ...CUSTOM_RULES].map((r) => ({ ...r, ttlSeconds: Infinity }))
         );
     }
-    return ruleExecutors[mockUuid];
+    return ruleExecutors[mockUuid]!;
 };