@stuntman/server 0.1.3 → 0.1.5

package/dist/api/api.js

@@ -26,6 +26,9 @@ class API {
         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;
@@ -104,7 +107,7 @@ class API {
                 });
                 return;
             }
-            shared_1.logger.error({ ...error, uuid }, 'Unexpected error');
+            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 },

package/dist/mock.d.ts

@@ -18,11 +18,11 @@ export declare class Mock {
     protected trafficStore: LRUCache<string, Stuntman.LogEntry>;
     protected ipUtils: IPUtils | null;
     private _api;
+    private requestHandler;
     get apiServer(): API | null;
     get ruleExecutor(): Stuntman.RuleExecutorInterface;
     constructor(options: Stuntman.ServerConfig);
     private proxyRequest;
-    private requestHandler;
     start(): void;
     stop(): void;
     protected unproxyRequest(req: express.Request): Stuntman.BaseRequest;

package/dist/mock.js

@@ -78,6 +78,120 @@ class Mock {
             !this.options.mock.externalDns || this.options.mock.externalDns.length === 0
                 ? null
                 : new ipUtils_1.IPUtils({ mockUuid: this.mockUuid, externalDns: this.options.mock.externalDns });
+        this.requestHandler = async (req, res) => {
+            var _a, _b, _c, _d, _e;
+            const ctx = requestContext_1.default.get(req);
+            const requestUuid = (ctx === null || ctx === void 0 ? void 0 : ctx.uuid) || (0, uuid_1.v4)();
+            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 shared_1.RawHeaders(...req.rawHeaders),
+                ...((Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }) ||
+                    (typeof req.body === 'string' && { body: req.body })),
+            };
+            shared_1.logger.debug(originalRequest, 'processing request');
+            const logContext = {
+                requestId: originalRequest.id,
+            };
+            const mockEntry = {
+                originalRequest,
+                modifiedRequest: {
+                    ...this.unproxyRequest(req),
+                    id: requestUuid,
+                    timestamp,
+                    ...(originalRequest.body && { gqlBody: naiveGQLParser(originalRequest.body) }),
+                },
+            };
+            if (!isProxiedHostname) {
+                this.removeProxyPort(mockEntry.modifiedRequest);
+            }
+            const matchingRule = await (0, ruleExecutor_1.getRuleExecutor)(this.mockUuid).findMatchingRule(mockEntry.modifiedRequest);
+            if (matchingRule) {
+                mockEntry.mockRuleId = matchingRule.id;
+                mockEntry.labels = matchingRule.labels;
+                if ((_a = matchingRule.actions) === null || _a === void 0 ? void 0 : _a.mockResponse) {
+                    const staticResponse = typeof matchingRule.actions.mockResponse === 'function'
+                        ? matchingRule.actions.mockResponse(mockEntry.modifiedRequest)
+                        : matchingRule.actions.mockResponse;
+                    mockEntry.modifiedResponse = staticResponse;
+                    shared_1.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;
+                }
+                if ((_b = matchingRule.actions) === null || _b === void 0 ? void 0 : _b.modifyRequest) {
+                    mockEntry.modifiedRequest = (_c = matchingRule.actions) === null || _c === void 0 ? void 0 : _c.modifyRequest(mockEntry.modifiedRequest);
+                    shared_1.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 });
+                        shared_1.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
+                    shared_1.logger.warn({ ...logContext, error }, `error trying to resolve IP for "${hostname}"`);
+                }
+            }
+            const originalResponse = await this.proxyRequest(req, mockEntry, logContext);
+            shared_1.logger.debug({ ...logContext, originalResponse }, 'received response');
+            mockEntry.originalResponse = originalResponse;
+            let modifedResponse = {
+                ...originalResponse,
+                rawHeaders: new shared_1.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 ((_d = matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions) === null || _d === void 0 ? void 0 : _d.modifyResponse) {
+                modifedResponse = (_e = matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions) === null || _e === void 0 ? void 0 : _e.modifyResponse(mockEntry.modifiedRequest, originalResponse);
+                shared_1.logger.debug({ ...logContext, modifedResponse }, 'modified response');
+            }
+            mockEntry.modifiedResponse = modifedResponse;
+            if (matchingRule === null || matchingRule === void 0 ? void 0 : 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]);
+                }
+            }
+            res.end(Buffer.from(modifedResponse.body, 'binary'));
+        };
         this.mockApp = (0, express_1.default)();
         // TODO for now request body is just a buffer passed further, not inflated
         this.mockApp.use(express_1.default.raw({ type: '*/*' }));
@@ -89,7 +203,7 @@ class Mock {
         this.mockApp.use((error, req, res, _next) => {
             const ctx = requestContext_1.default.get(req);
             const uuid = (ctx === null || ctx === void 0 ? void 0 : ctx.uuid) || (0, uuid_1.v4)();
-            shared_1.logger.error({ ...error, uuid }, 'Unexpected error');
+            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 },
@@ -145,120 +259,6 @@ class Mock {
             rawHeaders: shared_1.RawHeaders.fromHeadersRecord(targetResponse.headers),
         };
     }
-    async requestHandler(req, res) {
-        var _a, _b, _c, _d, _e;
-        const ctx = requestContext_1.default.get(req);
-        const requestUuid = (ctx === null || ctx === void 0 ? void 0 : ctx.uuid) || (0, uuid_1.v4)();
-        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 shared_1.RawHeaders(...req.rawHeaders),
-            ...((Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }) ||
-                (typeof req.body === 'string' && { body: req.body })),
-        };
-        shared_1.logger.debug(originalRequest, 'processing request');
-        const logContext = {
-            requestId: originalRequest.id,
-        };
-        const mockEntry = {
-            originalRequest,
-            modifiedRequest: {
-                ...this.unproxyRequest(req),
-                id: requestUuid,
-                timestamp,
-                ...(originalRequest.body && { gqlBody: naiveGQLParser(originalRequest.body) }),
-            },
-        };
-        if (!isProxiedHostname) {
-            this.removeProxyPort(mockEntry.modifiedRequest);
-        }
-        const matchingRule = await (0, ruleExecutor_1.getRuleExecutor)(this.mockUuid).findMatchingRule(mockEntry.modifiedRequest);
-        if (matchingRule) {
-            mockEntry.mockRuleId = matchingRule.id;
-            mockEntry.labels = matchingRule.labels;
-            if ((_a = matchingRule.actions) === null || _a === void 0 ? void 0 : _a.mockResponse) {
-                const staticResponse = typeof matchingRule.actions.mockResponse === 'function'
-                    ? matchingRule.actions.mockResponse(mockEntry.modifiedRequest)
-                    : matchingRule.actions.mockResponse;
-                mockEntry.modifiedResponse = staticResponse;
-                shared_1.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;
-            }
-            if ((_b = matchingRule.actions) === null || _b === void 0 ? void 0 : _b.modifyRequest) {
-                mockEntry.modifiedRequest = (_c = matchingRule.actions) === null || _c === void 0 ? void 0 : _c.modifyRequest(mockEntry.modifiedRequest);
-                shared_1.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 });
-                    shared_1.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
-                shared_1.logger.warn({ ...logContext, error }, `error trying to resolve IP for "${hostname}"`);
-            }
-        }
-        const originalResponse = await this.proxyRequest(req, mockEntry, logContext);
-        shared_1.logger.debug({ ...logContext, originalResponse }, 'received response');
-        mockEntry.originalResponse = originalResponse;
-        let modifedResponse = {
-            ...originalResponse,
-            rawHeaders: new shared_1.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 ((_d = matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions) === null || _d === void 0 ? void 0 : _d.modifyResponse) {
-            modifedResponse = (_e = matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions) === null || _e === void 0 ? void 0 : _e.modifyResponse(mockEntry.modifiedRequest, originalResponse);
-            shared_1.logger.debug({ ...logContext, modifedResponse }, 'modified response');
-        }
-        mockEntry.modifiedResponse = modifedResponse;
-        if (matchingRule === null || matchingRule === void 0 ? void 0 : 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]);
-            }
-        }
-        res.end(Buffer.from(modifedResponse.body, 'binary'));
-    }
     start() {
         if (this.server) {
             throw new Error('mock server already started');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stuntman/server",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Stuntman - HTTP proxy / mock server with API",
   "main": "dist/index.js",
   "repository": {
@@ -57,7 +57,8 @@
     "stuntman": "./dist/bin/stuntman.js"
   },
   "files": [
-    "dist/",
+    "src/**",
+    "dist/**",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/src/api/api.ts

@@ -0,0 +1,231 @@
+import http from 'http';
+import express, { NextFunction, Request, Response, Express as ExpressServer } from 'express';
+import { v4 as uuidv4 } from 'uuid';
+import { getTrafficStore } from '../storage';
+import { getRuleExecutor } from '../ruleExecutor';
+import { logger, AppError, HttpCode, MAX_RULE_TTL_SECONDS, stringify, INDEX_DTS } from '@stuntman/shared';
+import type * as Stuntman from '@stuntman/shared';
+import RequestContext from '../requestContext';
+import serializeJavascript from 'serialize-javascript';
+import LRUCache from 'lru-cache';
+import { validateDeserializedRule } from './validators';
+import { deserializeRule, escapedSerialize, liveRuleToRule } from './utils';
+
+type ApiOptions = Stuntman.ApiConfig & {
+    mockUuid: string;
+};
+
+const API_KEY_HEADER = 'x-api-key';
+
+export class API {
+    protected options: Required<ApiOptions>;
+    protected apiApp: ExpressServer;
+    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) {
+        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 = getTrafficStore(this.options.mockUuid);
+        this.apiApp = express();
+
+        this.apiApp.use(express.json());
+        this.apiApp.use(express.text());
+
+        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' });
+            }
+            return;
+        };
+
+        this.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();
+        };
+
+        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) => {
+            res.send(stringify(await getRuleExecutor(this.options.mockUuid).getRules()));
+        });
+
+        this.apiApp.get('/rule/:ruleId', this.authReadOnly, async (req, res) => {
+            res.send(stringify(await getRuleExecutor(this.options.mockUuid).getRule(req.params.ruleId)));
+        });
+
+        this.apiApp.get('/rule/:ruleId/disable', this.authReadWrite, (req, res) => {
+            getRuleExecutor(this.options.mockUuid).disableRule(req.params.ruleId);
+            res.send();
+        });
+
+        this.apiApp.get('/rule/:ruleId/enable', this.authReadWrite, (req, res) => {
+            getRuleExecutor(this.options.mockUuid).enableRule(req.params.ruleId);
+            res.send();
+        });
+
+        this.apiApp.post(
+            '/rule',
+            this.authReadWrite,
+            async (req: Request<object, string, Stuntman.SerializedRule>, res: Response) => {
+                const deserializedRule = deserializeRule(req.body);
+                validateDeserializedRule(deserializedRule);
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                const rule = await getRuleExecutor(this.options.mockUuid).addRule(deserializedRule);
+                res.send(stringify(rule));
+            }
+        );
+
+        this.apiApp.get('/rule/:ruleId/remove', this.authReadWrite, async (req, res) => {
+            await getRuleExecutor(this.options.mockUuid).removeRule(req.params.ruleId);
+            res.send();
+        });
+
+        this.apiApp.get('/traffic', this.authReadOnly, (req, res) => {
+            const serializedTraffic: Record<string, Stuntman.LogEntry> = {};
+            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: Record<string, Stuntman.LogEntry> = {};
+            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?.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.use((error: Error | AppError, req: Request, res: Response) => {
+            const ctx: RequestContext | null = RequestContext.get(req);
+            const uuid = ctx?.uuid || uuidv4();
+            if (error instanceof AppError && error.isOperational && res) {
+                logger.error(error);
+                res.status(error.httpCode).json({
+                    error: { message: error.message, httpCode: error.httpCode, stack: error.stack },
+                });
+                return;
+            }
+            logger.error({ message: error.message, stack: error.stack, name: error.name, uuid }, 'unexpected error');
+            if (res) {
+                res.status(HttpCode.INTERNAL_SERVER_ERROR).json({
+                    error: { message: error.message, httpCode: HttpCode.INTERNAL_SERVER_ERROR, uuid },
+                });
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.log('API server encountered a critical error. Exiting');
+            process.exit(1);
+        });
+    }
+
+    private initWebGui() {
+        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 });
+            }
+            res.render('rules', { rules: escapedSerialize(rules), INDEX_DTS, ruleKeys: Object.keys(rules) });
+        });
+
+        this.apiApp.get('/webgui/traffic', this.authReadOnly, async (req, res) => {
+            const serializedTraffic: Stuntman.LogEntry[] = [];
+            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: Stuntman.Rule = new Function(req.body)();
+            if (
+                !rule ||
+                !rule.id ||
+                typeof rule.matches !== 'function' ||
+                typeof rule.ttlSeconds !== 'number' ||
+                rule.ttlSeconds > MAX_RULE_TTL_SECONDS
+            ) {
+                throw new AppError({ httpCode: HttpCode.BAD_REQUEST, message: 'Invalid rule' });
+            }
+            await 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();
+        });
+    }
+
+    public start() {
+        if (this.server) {
+            throw new Error('mock server already started');
+        }
+        this.server = this.apiApp.listen(this.options.port, () => {
+            logger.info(`API listening on ${this.options.port}`);
+        });
+    }
+
+    public stop() {
+        if (!this.server) {
+            throw new Error('mock server not started');
+        }
+        this.server.close((error) => {
+            logger.warn(error, 'problem closing server');
+            this.server = null;
+        });
+    }
+}

package/src/api/utils.ts

@@ -0,0 +1,69 @@
+import serializeJavascript from 'serialize-javascript';
+import type * as Stuntman from '@stuntman/shared';
+import { logger } from '@stuntman/shared';
+import { validateSerializedRuleProperties } from './validators';
+
+// TODO
+export const deserializeRule = (serializedRule: Stuntman.SerializedRule): Stuntman.Rule => {
+    logger.debug(serializedRule, 'attempt to deserialize rule');
+    validateSerializedRuleProperties(serializedRule);
+    const rule: Stuntman.Rule = {
+        id: serializedRule.id,
+        matches: (req: Stuntman.Request) => new Function('____arg0', serializedRule.matches.remoteFn)(req),
+        ttlSeconds: serializedRule.ttlSeconds,
+        ...(serializedRule.disableAfterUse !== undefined && { disableAfterUse: serializedRule.disableAfterUse }),
+        ...(serializedRule.removeAfterUse !== undefined && { removeAfterUse: serializedRule.removeAfterUse }),
+        ...(serializedRule.labels !== undefined && { labels: serializedRule.labels }),
+        ...(serializedRule.priority !== undefined && { priority: serializedRule.priority }),
+        ...(serializedRule.isEnabled !== undefined && { isEnabled: serializedRule.isEnabled }),
+        ...(serializedRule.storeTraffic !== undefined && { storeTraffic: serializedRule.storeTraffic }),
+    };
+    if (serializedRule.actions) {
+        // TODO store the original localFn and variables sent from client for web UI editing maybe
+        if (serializedRule.actions.mockResponse) {
+            rule.actions = {
+                mockResponse:
+                    'remoteFn' in serializedRule.actions.mockResponse
+                        ? (req: Stuntman.Request) =>
+                              new Function(
+                                  '____arg0',
+                                  (serializedRule.actions?.mockResponse as Stuntman.SerializedRemotableFunction).remoteFn
+                              )(req)
+                        : serializedRule.actions.mockResponse,
+            };
+        } else {
+            rule.actions = {};
+            if (serializedRule.actions.modifyRequest) {
+                rule.actions.modifyRequest = (req: Stuntman.Request) =>
+                    new Function(
+                        '____arg0',
+                        (serializedRule.actions?.modifyRequest as Stuntman.SerializedRemotableFunction).remoteFn
+                    )(req);
+            }
+            if (serializedRule.actions.modifyResponse) {
+                rule.actions.modifyResponse = (req: Stuntman.Request, res: Stuntman.Response) =>
+                    new Function(
+                        '____arg0',
+                        '____arg1',
+                        (serializedRule.actions?.modifyResponse as Stuntman.SerializedRemotableFunction).remoteFn
+                    )(req, res);
+            }
+        }
+    }
+    logger.debug(rule, 'deserialized rule');
+    return rule;
+};
+
+export const escapedSerialize = (obj: any) =>
+    serializeJavascript(obj).replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, "\\n'\n+ '");
+
+export const liveRuleToRule = (liveRule: Stuntman.LiveRule) => {
+    const ruleClone: Stuntman.Rule = { ...liveRule };
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete ruleClone.counter;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete ruleClone.createdTimestamp;
+    return ruleClone;
+};