@stuntman/server 0.1.5 → 0.1.7

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,140 +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 = 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();
         });
@@ -308,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');
         }
@@ -369,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]!;
 };

package/src/rules/index.ts

@@ -3,19 +3,19 @@ import glob from 'glob';
 import * as tsImport from 'ts-import';
 import { catchAllRule } from './catchAll';
 import { echoRule } from './echo';
-import { serverConfig, logger } from '@stuntman/shared';
+import { stuntmanConfig, logger } from '@stuntman/shared';
 import type * as Stuntman from '@stuntman/shared';
 
 export const DEFAULT_RULES: Stuntman.DeployedRule[] = [catchAllRule, echoRule];
 export const CUSTOM_RULES: Stuntman.DeployedRule[] = [];
 
 const loadAdditionalRules = () => {
-    if (!serverConfig.mock.rulesPath || !fs.existsSync(serverConfig.mock.rulesPath)) {
-        logger.debug({ rulesPath: serverConfig.mock.rulesPath }, `additional rules directory not found`);
+    if (!stuntmanConfig.mock.rulesPath || !fs.existsSync(stuntmanConfig.mock.rulesPath)) {
+        logger.debug({ rulesPath: stuntmanConfig.mock.rulesPath }, `additional rules directory not found`);
         return;
     }
-    logger.debug({ rulesPath: serverConfig.mock.rulesPath }, `loading additional rules`);
-    const filePaths = glob.sync('*.[tj]s', { absolute: true, cwd: serverConfig.mock.rulesPath });
+    logger.debug({ rulesPath: stuntmanConfig.mock.rulesPath }, `loading additional rules`);
+    const filePaths = glob.sync('*.[tj]s', { absolute: true, cwd: stuntmanConfig.mock.rulesPath });
     for (const filePath of filePaths) {
         // TODO add .ts rule support
         try {

package/src/storage.ts

@@ -28,12 +28,12 @@ export const getTrafficStore = (key: string, options?: Stuntman.StorageConfig) =
             sizeCalculation: (value) => sizeof(value),
         });
     }
-    return trafficStoreInstances[key];
+    return trafficStoreInstances[key]!;
 };
 
 export const getDnsResolutionCache = (key: string) => {
     if (!(key in dnsResolutionCacheInstances)) {
         dnsResolutionCacheInstances[key] = new LRUCache<string, string>(DNS_CACHE_OPTIONS);
     }
-    return dnsResolutionCacheInstances[key];
+    return dnsResolutionCacheInstances[key]!;
 };

package/dist/api/api.d.ts

@@ -1,22 +0,0 @@
-/// <reference types="node" />
-import http from 'http';
-import { NextFunction, Request, Response, Express as ExpressServer } from 'express';
-import type * as Stuntman from '@stuntman/shared';
-import LRUCache from 'lru-cache';
-type ApiOptions = Stuntman.ApiConfig & {
-    mockUuid: string;
-};
-export declare class API {
-    protected options: Required<ApiOptions>;
-    protected apiApp: ExpressServer;
-    trafficStore: LRUCache<string, Stuntman.LogEntry>;
-    server: http.Server | 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);
-    private initWebGui;
-    start(): void;
-    stop(): void;
-}
-export {};

package/dist/api/api.js

@@ -1,188 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.API = void 0;
-const express_1 = __importDefault(require("express"));
-const uuid_1 = require("uuid");
-const storage_1 = require("../storage");
-const ruleExecutor_1 = require("../ruleExecutor");
-const shared_1 = require("@stuntman/shared");
-const requestContext_1 = __importDefault(require("../requestContext"));
-const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
-const validators_1 = require("./validators");
-const utils_1 = require("./utils");
-const API_KEY_HEADER = 'x-api-key';
-class API {
-    constructor(options, webGuiOptions) {
-        this.server = null;
-        if (!options.apiKeyReadOnly !== !options.apiKeyReadWrite) {
-            throw new Error('apiKeyReadOnly and apiKeyReadWrite options need to be set either both or none');
-        }
-        this.options = options;
-        this.trafficStore = (0, storage_1.getTrafficStore)(this.options.mockUuid);
-        this.apiApp = (0, express_1.default)();
-        this.apiApp.use(express_1.default.json());
-        this.apiApp.use(express_1.default.text());
-        this.auth = (req, type) => {
-            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 shared_1.AppError({ httpCode: shared_1.HttpCode.UNAUTHORIZED, message: 'unauthorized' });
-            }
-            return;
-        };
-        this.authReadOnly = (req, res, next) => {
-            this.auth(req, 'read');
-            next();
-        };
-        this.authReadWrite = (req, res, next) => {
-            this.auth(req, 'write');
-            next();
-        };
-        this.apiApp.use((req, res, next) => {
-            requestContext_1.default.bind(req, this.options.mockUuid);
-            next();
-        });
-        this.apiApp.get('/rule', this.authReadOnly, async (req, res) => {
-            res.send((0, shared_1.stringify)(await (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).getRules()));
-        });
-        this.apiApp.get('/rule/:ruleId', this.authReadOnly, async (req, res) => {
-            res.send((0, shared_1.stringify)(await (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).getRule(req.params.ruleId)));
-        });
-        this.apiApp.get('/rule/:ruleId/disable', this.authReadWrite, (req, res) => {
-            (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).disableRule(req.params.ruleId);
-            res.send();
-        });
-        this.apiApp.get('/rule/:ruleId/enable', this.authReadWrite, (req, res) => {
-            (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).enableRule(req.params.ruleId);
-            res.send();
-        });
-        this.apiApp.post('/rule', this.authReadWrite, async (req, res) => {
-            const deserializedRule = (0, utils_1.deserializeRule)(req.body);
-            (0, validators_1.validateDeserializedRule)(deserializedRule);
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            const rule = await (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).addRule(deserializedRule);
-            res.send((0, shared_1.stringify)(rule));
-        });
-        this.apiApp.get('/rule/:ruleId/remove', this.authReadWrite, async (req, res) => {
-            await (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).removeRule(req.params.ruleId);
-            res.send();
-        });
-        this.apiApp.get('/traffic', this.authReadOnly, (req, res) => {
-            const serializedTraffic = {};
-            for (const [key, value] of this.trafficStore.entries()) {
-                serializedTraffic[key] = value;
-            }
-            res.json(serializedTraffic);
-        });
-        this.apiApp.get('/traffic/:ruleIdOrLabel', this.authReadOnly, (req, res) => {
-            const serializedTraffic = {};
-            for (const [key, value] of this.trafficStore.entries()) {
-                if (value.mockRuleId === req.params.ruleIdOrLabel || (value.labels || []).includes(req.params.ruleIdOrLabel)) {
-                    serializedTraffic[key] = value;
-                }
-            }
-            res.json(serializedTraffic);
-        });
-        if (!(webGuiOptions === null || webGuiOptions === void 0 ? void 0 : webGuiOptions.disabled)) {
-            this.apiApp.set('views', __dirname + '/webgui');
-            this.apiApp.set('view engine', 'pug');
-            this.initWebGui();
-        }
-        this.apiApp.all(/.*/, (req, res) => res.status(404).send());
-        this.apiApp.use((error, req, res) => {
-            const ctx = requestContext_1.default.get(req);
-            const uuid = (ctx === null || ctx === void 0 ? void 0 : ctx.uuid) || (0, uuid_1.v4)();
-            if (error instanceof shared_1.AppError && error.isOperational && res) {
-                shared_1.logger.error(error);
-                res.status(error.httpCode).json({
-                    error: { message: error.message, httpCode: error.httpCode, stack: error.stack },
-                });
-                return;
-            }
-            shared_1.logger.error({ message: error.message, stack: error.stack, name: error.name, uuid }, 'unexpected error');
-            if (res) {
-                res.status(shared_1.HttpCode.INTERNAL_SERVER_ERROR).json({
-                    error: { message: error.message, httpCode: shared_1.HttpCode.INTERNAL_SERVER_ERROR, uuid },
-                });
-                return;
-            }
-            // eslint-disable-next-line no-console
-            console.log('API server encountered a critical error. Exiting');
-            process.exit(1);
-        });
-    }
-    initWebGui() {
-        this.apiApp.get('/webgui/rules', this.authReadOnly, async (req, res) => {
-            const rules = {};
-            for (const rule of await (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).getRules()) {
-                rules[rule.id] = (0, serialize_javascript_1.default)((0, utils_1.liveRuleToRule)(rule), { unsafe: true });
-            }
-            res.render('rules', { rules: (0, utils_1.escapedSerialize)(rules), INDEX_DTS: shared_1.INDEX_DTS, ruleKeys: Object.keys(rules) });
-        });
-        this.apiApp.get('/webgui/traffic', this.authReadOnly, async (req, res) => {
-            const serializedTraffic = [];
-            for (const value of this.trafficStore.values()) {
-                serializedTraffic.push(value);
-            }
-            res.render('traffic', {
-                traffic: JSON.stringify(serializedTraffic.sort((a, b) => b.originalRequest.timestamp - a.originalRequest.timestamp)),
-            });
-        });
-        // TODO make webui way better and safer, nicer formatting, eslint/prettier, blackjack and hookers
-        this.apiApp.post('/webgui/rules/unsafesave', this.authReadWrite, async (req, res) => {
-            const rule = new Function(req.body)();
-            if (!rule ||
-                !rule.id ||
-                typeof rule.matches !== 'function' ||
-                typeof rule.ttlSeconds !== 'number' ||
-                rule.ttlSeconds > shared_1.MAX_RULE_TTL_SECONDS) {
-                throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'Invalid rule' });
-            }
-            await (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).addRule({
-                id: rule.id,
-                matches: rule.matches,
-                ttlSeconds: rule.ttlSeconds,
-                ...(rule.actions && {
-                    actions: {
-                        ...(rule.actions.mockResponse
-                            ? { mockResponse: rule.actions.mockResponse }
-                            : { modifyRequest: rule.actions.modifyRequest, modifyResponse: rule.actions.modifyResponse }),
-                    },
-                }),
-                ...(rule.disableAfterUse !== undefined && { disableAfterUse: rule.disableAfterUse }),
-                ...(rule.isEnabled !== undefined && { isEnabled: rule.isEnabled }),
-                ...(rule.labels !== undefined && { labels: rule.labels }),
-                ...(rule.priority !== undefined && { priority: rule.priority }),
-                ...(rule.removeAfterUse !== undefined && { removeAfterUse: rule.removeAfterUse }),
-                ...(rule.storeTraffic !== undefined && { storeTraffic: rule.storeTraffic }),
-            }, true);
-            res.send();
-        });
-    }
-    start() {
-        if (this.server) {
-            throw new Error('mock server already started');
-        }
-        this.server = this.apiApp.listen(this.options.port, () => {
-            shared_1.logger.info(`API listening on ${this.options.port}`);
-        });
-    }
-    stop() {
-        if (!this.server) {
-            throw new Error('mock server not started');
-        }
-        this.server.close((error) => {
-            shared_1.logger.warn(error, 'problem closing server');
-            this.server = null;
-        });
-    }
-}
-exports.API = API;

package/dist/api/utils.d.ts

@@ -1,4 +0,0 @@
-import type * as Stuntman from '@stuntman/shared';
-export declare const deserializeRule: (serializedRule: Stuntman.SerializedRule) => Stuntman.Rule;
-export declare const escapedSerialize: (obj: any) => string;
-export declare const liveRuleToRule: (liveRule: Stuntman.LiveRule) => Stuntman.Rule;