@stuntman/server 0.1.1 → 0.1.3

package/README.md

@@ -1,5 +1,13 @@
 # Stuntman
 
+Stuntman is a proxy/mock server that can be deployed remotely together with your application under test, working as either pass-through proxy allowing you to inspect traffic or proxy/mock which can intercept requests/responses and modify them or stub with predefined ones.
+
+It offers API and client library that can be used for example within E2E functional test scripts to dynamically alter it's behaviour for specific traffic matching set of rules of your definition.
+
+In order to get more familiar with the concept and how to use it please refer to [example app](https://github.com/andrzej-woof/stuntman/tree/master/apps/example#readme)
+
+> **_NOTE:_**  This project is at a very early stage of developement and as such may often contain breaking changes in upcoming releases before reaching stable version 1.0.0
+
 ## Building from source
 
 ### Prerequisites
@@ -22,6 +30,7 @@ pnpm stuntman
 ## Configuration
 
 Stuntman uses [config](https://github.com/node-config/node-config)
+
 You can create `config/default.json` with settings of your liking matching `ServerConfig` type
 
 ## Running as a package
@@ -68,8 +77,6 @@ for local playground you can also use `http://www.example.com.localhost:2015`
 
 ### Take a look at client
 
-Take a look at `./src/clientTestExample.ts`, you can use it to set up some rules
-
 Mind the scope of `Stuntman.RemotableFunction` like `matches`, `modifyRequest`, `modifyResponse`.
 `Stuntman.RemotableFunction.localFn` contains the function, but since it'll be executed on a remote mock server it cannot access any variables outside it's body. In order to pass variable values into the function use `Stuntman.RemotableFunction.variables` for example:
 

package/dist/api/api.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import http from 'http';
-import { Express as ExpressServer } from 'express';
+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 & {
@@ -11,6 +11,9 @@ export declare class API {
     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;

package/dist/api/api.js

@@ -11,54 +11,75 @@ 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 validatiors_1 = require("./validatiors");
+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) => {
+            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', async (req, res) => {
-            res.send((0, shared_1.stringify)(await ruleExecutor_1.ruleExecutor.getRules()));
+        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', async (req, res) => {
-            res.send((0, shared_1.stringify)(await ruleExecutor_1.ruleExecutor.getRule(req.params.ruleId)));
+        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', (req, res) => {
-            ruleExecutor_1.ruleExecutor.disableRule(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', (req, res) => {
-            ruleExecutor_1.ruleExecutor.enableRule(req.params.ruleId);
+        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', async (req, res) => {
+        this.apiApp.post('/rule', this.authReadWrite, async (req, res) => {
             const deserializedRule = (0, utils_1.deserializeRule)(req.body);
-            (0, validatiors_1.validateDeserializedRule)(deserializedRule);
+            (0, validators_1.validateDeserializedRule)(deserializedRule);
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
-            const rule = await ruleExecutor_1.ruleExecutor.addRule(deserializedRule);
+            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', async (req, res) => {
-            await ruleExecutor_1.ruleExecutor.removeRule(req.params.ruleId);
+        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', (req, res) => {
+        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', (req, res) => {
+        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)) {
@@ -67,7 +88,13 @@ class API {
             }
             res.json(serializedTraffic);
         });
-        this.apiApp.use((error, req, res, _next) => {
+        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) {
@@ -84,24 +111,20 @@ class API {
                 });
                 return;
             }
-            console.log('Application encountered a critical error. Exiting');
+            // eslint-disable-next-line no-console
+            console.log('API server encountered a critical error. Exiting');
             process.exit(1);
         });
-        this.apiApp.set('views', __dirname + '/webgui');
-        this.apiApp.set('view engine', 'pug');
-        if (!(webGuiOptions === null || webGuiOptions === void 0 ? void 0 : webGuiOptions.disabled)) {
-            this.initWebGui();
-        }
     }
     initWebGui() {
-        this.apiApp.get('/webgui/rules', async (req, res) => {
+        this.apiApp.get('/webgui/rules', this.authReadOnly, async (req, res) => {
             const rules = {};
-            for (const rule of await ruleExecutor_1.ruleExecutor.getRules()) {
+            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', async (req, res) => {
+        this.apiApp.get('/webgui/traffic', this.authReadOnly, async (req, res) => {
             const serializedTraffic = [];
             for (const value of this.trafficStore.values()) {
                 serializedTraffic.push(value);
@@ -111,7 +134,7 @@ class API {
             });
         });
         // TODO make webui way better and safer, nicer formatting, eslint/prettier, blackjack and hookers
-        this.apiApp.post('/webgui/rules/unsafesave', async (req, res) => {
+        this.apiApp.post('/webgui/rules/unsafesave', this.authReadWrite, async (req, res) => {
             const rule = new Function(req.body)();
             if (!rule ||
                 !rule.id ||
@@ -120,7 +143,7 @@ class API {
                 rule.ttlSeconds > shared_1.MAX_RULE_TTL_SECONDS) {
                 throw new shared_1.AppError({ httpCode: shared_1.HttpCode.BAD_REQUEST, message: 'Invalid rule' });
             }
-            await ruleExecutor_1.ruleExecutor.addRule({
+            await (0, ruleExecutor_1.getRuleExecutor)(this.options.mockUuid).addRule({
                 id: rule.id,
                 matches: rule.matches,
                 ttlSeconds: rule.ttlSeconds,

package/dist/api/utils.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.liveRuleToRule = exports.escapedSerialize = exports.deserializeRule = void 0;
 const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
 const shared_1 = require("@stuntman/shared");
-const validatiors_1 = require("./validatiors");
+const validators_1 = require("./validators");
 // TODO
 const deserializeRule = (serializedRule) => {
     shared_1.logger.debug(serializedRule, 'attempt to deserialize rule');
-    (0, validatiors_1.validateSerializedRuleProperties)(serializedRule);
+    (0, validators_1.validateSerializedRuleProperties)(serializedRule);
     const rule = {
         id: serializedRule.id,
         matches: (req) => new Function('____arg0', serializedRule.matches.remoteFn)(req),

package/dist/api/{validatiors.js → validators.js}

@@ -104,7 +104,7 @@ const validateDeserializedRule = (deserializedRule) => {
         shared_1.logger.error({ ruleId: deserializedRule.id }, error);
         throw new shared_1.AppError({
             httpCode: shared_1.HttpCode.UNPROCESSABLE_ENTITY,
-            message: 'match function returned invalid value',
+            message: 'match function threw an error',
         });
     }
     if (matchValidationResult !== true &&

package/dist/mock.d.ts

@@ -8,7 +8,7 @@ import { IPUtils } from './ipUtils';
 import LRUCache from 'lru-cache';
 import { API } from './api/api';
 export declare class Mock {
-    protected mockUuid: string;
+    readonly mockUuid: string;
     protected options: Stuntman.ServerConfig;
     protected mockApp: express.Express;
     protected MOCK_DOMAIN_REGEX: RegExp;
@@ -19,7 +19,10 @@ export declare class Mock {
     protected ipUtils: IPUtils | null;
     private _api;
     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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mock = void 0;
+const undici_1 = require("undici");
 const https_1 = __importDefault(require("https"));
 const express_1 = __importDefault(require("express"));
 const uuid_1 = require("uuid");
@@ -57,6 +58,9 @@ class Mock {
         }
         return this._api;
     }
+    get ruleExecutor() {
+        return (0, ruleExecutor_1.getRuleExecutor)(this.mockUuid);
+    }
     constructor(options) {
         this.server = null;
         this.serverHttps = null;
@@ -67,7 +71,7 @@ class Mock {
         if (this.options.mock.httpsPort && (!this.options.mock.httpsKey || !this.options.mock.httpsCert)) {
             throw new Error('missing https key/cert');
         }
-        this.MOCK_DOMAIN_REGEX = new RegExp(`(?:\\.([0-9]+))?\\.(?:(?:${this.options.mock.domain})|(?:localhost))(https?)?(:${this.options.mock.port}${this.options.mock.httpsPort ? `|${this.options.mock.httpsPort}` : ''})?(?:\\b|$)`, 'i');
+        this.MOCK_DOMAIN_REGEX = new RegExp(`(?:\\.([0-9]+))?\\.(?:(?:${this.options.mock.domain}(https?)?)|(?:localhost))(:${this.options.mock.port}${this.options.mock.httpsPort ? `|${this.options.mock.httpsPort}` : ''})?(?:\\b|$)`, 'i');
         this.URL_PORT_REGEX = new RegExp(`^(https?:\\/\\/[^:/]+):(?:${this.options.mock.port}${this.options.mock.httpsPort ? `|${this.options.mock.httpsPort}` : ''})(\\/.*)`, 'i');
         this.trafficStore = (0, storage_1.getTrafficStore)(this.mockUuid, this.options.storage.traffic);
         this.ipUtils =
@@ -81,157 +85,7 @@ class Mock {
             requestContext_1.default.bind(req, this.mockUuid);
             next();
         });
-        this.mockApp.all(/.*/, 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.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') }),
-            };
-            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 ruleExecutor_1.ruleExecutor.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}"`);
-                }
-            }
-            let controller = new AbortController();
-            const fetchTimeout = setTimeout(() => {
-                if (controller) {
-                    controller.abort(`timeout after ${this.options.mock.timeout}`);
-                }
-            }, this.options.mock.timeout);
-            req.on('close', () => {
-                shared_1.logger.debug(logContext, 'remote client canceled the request');
-                clearTimeout(fetchTimeout);
-                if (controller) {
-                    controller.abort('remote client canceled the request');
-                }
-            });
-            let targetResponse;
-            const hasKeepAlive = !!mockEntry.modifiedRequest.rawHeaders
-                .toHeaderPairs()
-                .find((h) => /^connection$/.test(h[0]) && /^keep-alive$/.test(h[1]));
-            try {
-                targetResponse = await fetch(mockEntry.modifiedRequest.url, {
-                    redirect: 'manual',
-                    headers: mockEntry.modifiedRequest.rawHeaders
-                        .toHeaderPairs()
-                        .filter((h) => !/^connection$/.test(h[0]) && !/^keep-alive$/.test(h[1])),
-                    body: mockEntry.modifiedRequest.body,
-                    method: mockEntry.modifiedRequest.method,
-                    keepalive: !!hasKeepAlive,
-                });
-            }
-            finally {
-                controller = null;
-                clearTimeout(fetchTimeout);
-            }
-            const targetResponseBuffer = Buffer.from(await targetResponse.arrayBuffer());
-            const originalResponse = {
-                timestamp: Date.now(),
-                body: targetResponseBuffer.toString('binary'),
-                status: targetResponse.status,
-                rawHeaders: new shared_1.RawHeaders(...Array.from(targetResponse.headers.entries()).flatMap(([key, value]) => [key, value])),
-            };
-            shared_1.logger.debug({ ...logContext, originalResponse }, 'received response');
-            mockEntry.originalResponse = originalResponse;
-            let modifedResponse = {
-                ...originalResponse,
-                rawHeaders: new shared_1.RawHeaders(...Array.from(targetResponse.headers.entries()).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], header[1]);
-                }
-            }
-            res.end(Buffer.from(modifedResponse.body, 'binary'));
-        });
+        this.mockApp.all(/.*/, this.requestHandler);
         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)();
@@ -242,10 +96,169 @@ class Mock {
                 });
                 return;
             }
-            console.log('mock encountered a critical error. exiting');
+            // eslint-disable-next-line no-console
+            console.error('mock server encountered a critical error. exiting');
             process.exit(1);
         });
     }
+    async proxyRequest(req, mockEntry, logContext) {
+        let controller = new AbortController();
+        const fetchTimeout = setTimeout(() => {
+            if (controller) {
+                controller.abort(`timeout after ${this.options.mock.timeout}`);
+            }
+        }, this.options.mock.timeout);
+        req.on('close', () => {
+            shared_1.logger.debug(logContext, 'remote client canceled the request');
+            clearTimeout(fetchTimeout);
+            if (controller) {
+                controller.abort('remote client canceled the request');
+            }
+        });
+        let targetResponse;
+        try {
+            const requestOptions = {
+                headers: mockEntry.modifiedRequest.rawHeaders,
+                body: mockEntry.modifiedRequest.body,
+                method: mockEntry.modifiedRequest.method.toUpperCase(),
+            };
+            shared_1.logger.debug({
+                ...logContext,
+                url: mockEntry.modifiedRequest.url,
+                ...requestOptions,
+            }, 'outgoing request attempt');
+            targetResponse = await (0, undici_1.request)(mockEntry.modifiedRequest.url, requestOptions);
+        }
+        catch (error) {
+            shared_1.logger.error({ ...logContext, error, request: mockEntry.modifiedRequest }, 'error fetching');
+            throw error;
+        }
+        finally {
+            controller = null;
+            clearTimeout(fetchTimeout);
+        }
+        const targetResponseBuffer = Buffer.from(await targetResponse.body.arrayBuffer());
+        return {
+            timestamp: Date.now(),
+            body: targetResponseBuffer.toString('binary'),
+            status: targetResponse.statusCode,
+            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/dist/ruleExecutor.d.ts

@@ -1,6 +1,7 @@
 import type * as Stuntman from '@stuntman/shared';
-declare class RuleExecutor {
+declare class RuleExecutor implements Stuntman.RuleExecutorInterface {
     private _rules;
+    private rulesLock;
     private get enabledRules();
     constructor(rules?: Stuntman.Rule[]);
     private hasExpired;
@@ -17,5 +18,5 @@ declare class RuleExecutor {
     getRules(): Promise<readonly Stuntman.LiveRule[]>;
     getRule(id: string): Promise<Stuntman.LiveRule | undefined>;
 }
-export declare const ruleExecutor: RuleExecutor;
+export declare const getRuleExecutor: (mockUuid: string) => RuleExecutor;
 export {};

package/dist/ruleExecutor.js

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ruleExecutor = void 0;
+exports.getRuleExecutor = void 0;
 const await_lock_1 = __importDefault(require("await-lock"));
 const shared_1 = require("@stuntman/shared");
 const rules_1 = require("./rules");
-const rulesLock = new await_lock_1.default();
+const ruleExecutors = {};
 const transformMockRuleToLive = (rule) => {
     var _a;
     return {
@@ -28,6 +28,7 @@ class RuleExecutor {
             .sort((a, b) => { var _a, _b; return ((_a = a.priority) !== null && _a !== void 0 ? _a : shared_1.DEFAULT_RULE_PRIORITY) - ((_b = b.priority) !== null && _b !== void 0 ? _b : shared_1.DEFAULT_RULE_PRIORITY); });
     }
     constructor(rules) {
+        this.rulesLock = new await_lock_1.default();
         this._rules = (rules || []).map(transformMockRuleToLive);
     }
     hasExpired() {
@@ -38,7 +39,7 @@ class RuleExecutor {
         if (!this.hasExpired()) {
             return;
         }
-        await rulesLock.acquireAsync();
+        await this.rulesLock.acquireAsync();
         const now = Date.now();
         try {
             this._rules = this._rules.filter((r) => {
@@ -50,12 +51,12 @@ class RuleExecutor {
             });
         }
         finally {
-            await rulesLock.release();
+            await this.rulesLock.release();
         }
     }
     async addRule(rule, overwrite) {
         await this.cleanUpExpired();
-        await rulesLock.acquireAsync();
+        await this.rulesLock.acquireAsync();
         try {
             if (this._rules.some((r) => r.id === rule.id)) {
                 if (!overwrite) {
@@ -69,7 +70,7 @@ class RuleExecutor {
             return liveRule;
         }
         finally {
-            await rulesLock.release();
+            await this.rulesLock.release();
         }
     }
     _removeRule(ruleOrId) {
@@ -83,17 +84,18 @@ class RuleExecutor {
     }
     async removeRule(ruleOrId) {
         await this.cleanUpExpired();
-        await rulesLock.acquireAsync();
+        await this.rulesLock.acquireAsync();
         try {
             this._removeRule(ruleOrId);
         }
         finally {
-            await rulesLock.release();
+            await this.rulesLock.release();
         }
     }
     enableRule(ruleOrId) {
         this._rules.forEach((r) => {
             if (r.id === (typeof ruleOrId === 'string' ? ruleOrId : ruleOrId.id)) {
+                r.counter = 0;
                 r.isEnabled = true;
                 shared_1.logger.debug({ ruleId: r.id }, 'rule enabled');
             }
@@ -112,11 +114,17 @@ class RuleExecutor {
             requestId: request.id,
         };
         const matchingRule = this.enabledRules.find((rule) => {
-            const matchResult = rule.matches(request);
-            if (typeof matchResult === 'boolean') {
-                return matchResult;
+            try {
+                const matchResult = rule.matches(request);
+                shared_1.logger.trace({ ...logContext, matchResult }, `rule match attempt for ${rule.id}`);
+                if (typeof matchResult === 'boolean') {
+                    return matchResult;
+                }
+                return matchResult.result;
+            }
+            catch (error) {
+                shared_1.logger.error({ ...logContext, ruleId: rule === null || rule === void 0 ? void 0 : rule.id, error }, 'error in rule match function');
             }
-            return matchResult.result;
         });
         if (!matchingRule) {
             shared_1.logger.debug(logContext, 'no matching rule found');
@@ -124,7 +132,7 @@ class RuleExecutor {
         }
         const matchResult = matchingRule.matches(request);
         logContext.ruleId = matchingRule.id;
-        shared_1.logger.debug(logContext, 'matching rule found');
+        shared_1.logger.debug({ ...logContext, matchResultMessage: typeof matchResult !== 'boolean' ? matchResult.description : null }, 'found matching rule');
         const matchingRuleClone = Object.freeze(Object.assign({}, matchingRule));
         ++matchingRule.counter;
         logContext.ruleCounter = matchingRule.counter;
@@ -132,6 +140,7 @@ class RuleExecutor {
             matchingRule.counter = 0;
             shared_1.logger.warn(logContext, "it's over 9000!!!");
         }
+        // TODO check if that works
         if (matchingRule.disableAfterUse) {
             if (typeof matchingRule.disableAfterUse === 'boolean' || matchingRule.disableAfterUse <= matchingRule.counter) {
                 shared_1.logger.debug(logContext, 'disabling rule for future requests');
@@ -141,7 +150,7 @@ class RuleExecutor {
         if (matchingRule.removeAfterUse) {
             if (typeof matchingRule.removeAfterUse === 'boolean' || matchingRule.removeAfterUse <= matchingRule.counter) {
                 shared_1.logger.debug(logContext, 'removing rule for future requests');
-                this.removeRule(matchingRule);
+                await this.removeRule(matchingRule);
             }
         }
         if (typeof matchResult !== 'boolean') {
@@ -169,4 +178,10 @@ class RuleExecutor {
         return this._rules.find((r) => r.id === id);
     }
 }
-exports.ruleExecutor = new RuleExecutor(rules_1.DEFAULT_RULES.map((r) => ({ ...r, ttlSeconds: Infinity })));
+const getRuleExecutor = (mockUuid) => {
+    if (!ruleExecutors[mockUuid]) {
+        ruleExecutors[mockUuid] = new RuleExecutor([...rules_1.DEFAULT_RULES, ...rules_1.CUSTOM_RULES].map((r) => ({ ...r, ttlSeconds: Infinity })));
+    }
+    return ruleExecutors[mockUuid];
+};
+exports.getRuleExecutor = getRuleExecutor;

package/dist/rules/index.d.ts

@@ -1,2 +1,3 @@
 import type * as Stuntman from '@stuntman/shared';
 export declare const DEFAULT_RULES: Stuntman.DeployedRule[];
+export declare const CUSTOM_RULES: Stuntman.DeployedRule[];

package/dist/rules/index.js

@@ -1,7 +1,70 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_RULES = void 0;
+exports.CUSTOM_RULES = exports.DEFAULT_RULES = void 0;
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const tsImport = __importStar(require("ts-import"));
 const catchAll_1 = require("./catchAll");
 const echo_1 = require("./echo");
-// TODO add option to load rules additional default rules from some nice configurable folder
+const shared_1 = require("@stuntman/shared");
 exports.DEFAULT_RULES = [catchAll_1.catchAllRule, echo_1.echoRule];
+exports.CUSTOM_RULES = [];
+const loadAdditionalRules = () => {
+    if (!shared_1.serverConfig.mock.rulesPath || !fs_1.default.existsSync(shared_1.serverConfig.mock.rulesPath)) {
+        shared_1.logger.debug({ rulesPath: shared_1.serverConfig.mock.rulesPath }, `additional rules directory not found`);
+        return;
+    }
+    shared_1.logger.debug({ rulesPath: shared_1.serverConfig.mock.rulesPath }, `loading additional rules`);
+    const filePaths = glob_1.default.sync('*.[tj]s', { absolute: true, cwd: shared_1.serverConfig.mock.rulesPath });
+    for (const filePath of filePaths) {
+        // TODO add .ts rule support
+        try {
+            const loadedFile = /\.js$/.test(filePath) ? require(filePath) : tsImport.loadSync(filePath);
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const exportedRules = Object.values(loadedFile).filter((rule) => {
+                if (!rule || !rule.id || typeof rule.matches !== 'function') {
+                    shared_1.logger.error({ filePath, rule }, 'invalid exported rule');
+                    return false;
+                }
+                return true;
+            });
+            exports.CUSTOM_RULES.push(...exportedRules);
+        }
+        catch (error) {
+            shared_1.logger.error({ filePath, error }, 'error importing rule');
+        }
+    }
+    const ruleIds = [...exports.DEFAULT_RULES, ...exports.CUSTOM_RULES].map((rule) => rule.id);
+    const duplicatedRuleIds = ruleIds.filter((currentValue, currentIndex) => ruleIds.indexOf(currentValue) !== currentIndex);
+    if (duplicatedRuleIds.length > 0) {
+        shared_1.logger.error({ duplicatedRuleIds }, 'duplicated rule ids');
+        throw new Error('duplicated rule ids');
+    }
+};
+loadAdditionalRules();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stuntman/server",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Stuntman - HTTP proxy / mock server with API",
   "main": "dist/index.js",
   "repository": {
@@ -32,19 +32,26 @@
   "author": "Andrzej Pasterczyk",
   "license": "MIT",
   "dependencies": {
-    "@stuntman/shared": "^0.1.1",
+    "@stuntman/shared": "^0.1.2",
     "await-lock": "2.2.2",
     "express": "5.0.0-beta.1",
+    "glob": "8.1.0",
     "lru-cache": "7.16.0",
     "object-sizeof": "2.6.1",
-    "pug": "^3.0.2",
+    "pug": "3.0.2",
     "serialize-javascript": "6.0.1",
+    "ts-import": "4.0.0-beta.10",
+    "typescript": "4.9.5",
+    "undici": "5.20.0",
     "uuid": "9.0.0"
   },
   "devDependencies": {
+    "@prettier/plugin-pug": "2.4.1",
     "@types/express": "4.17.17",
+    "@types/glob": "8.1.0",
     "@types/serialize-javascript": "5.0.2",
-    "@types/uuid": "9.0.0"
+    "@types/uuid": "9.0.0",
+    "prettier": "2.8.4"
   },
   "bin": {
     "stuntman": "./dist/bin/stuntman.js"
@@ -60,7 +67,7 @@
     "clean": "rm -fr dist",
     "build": "tsc && cp -rv src/api/webgui dist/api",
     "lint": "prettier --check . && eslint . --ext ts",
-    "lint:fix": "prettier --write ./src && eslint ./src --ext ts --fix",
+    "lint:fix": "prettier --write ./{src,test} && eslint ./{src,test} --ext ts --fix",
     "start": "node ./dist/bin/stuntman.js",
     "start:dev": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' ./src/bin/stuntman.ts",
     "start:debug": "node --inspect-brk=0.0.0.0 ./node_modules/.bin/ts-node --transpile-only ./src/bin/stuntman.ts"