@stuntman/server 0.1.2 → 0.1.3

package/README.md

@@ -4,7 +4,7 @@ Stuntman is a proxy/mock server that can be deployed remotely together with your
 
 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/packages/example#readme)
+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
 

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) => {
+        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) => {
+        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) => {
+        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) => {
+        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 (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) => {
+        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) {
@@ -88,21 +115,16 @@ class API {
             console.log('API server encountered a critical error. Exiting');
             process.exit(1);
         });
-        if (!(webGuiOptions === null || webGuiOptions === void 0 ? void 0 : webGuiOptions.disabled)) {
-            this.apiApp.set('views', __dirname + '/webgui');
-            this.apiApp.set('view engine', 'pug');
-            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 (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);
@@ -112,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 ||

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/mock.d.ts

@@ -21,6 +21,8 @@ export declare class Mock {
     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

@@ -85,161 +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.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}"`);
-                }
-            }
-            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());
-            const originalResponse = {
-                timestamp: Date.now(),
-                body: targetResponseBuffer.toString('binary'),
-                status: targetResponse.statusCode,
-                rawHeaders: shared_1.RawHeaders.fromHeadersRecord(targetResponse.headers),
-            };
-            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.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)();
@@ -255,6 +101,164 @@ class Mock {
             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.js

@@ -95,6 +95,7 @@ class RuleExecutor {
     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');
             }
@@ -139,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');
@@ -148,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') {
@@ -178,7 +180,7 @@ class RuleExecutor {
 }
 const getRuleExecutor = (mockUuid) => {
     if (!ruleExecutors[mockUuid]) {
-        ruleExecutors[mockUuid] = new RuleExecutor(rules_1.DEFAULT_RULES.map((r) => ({ ...r, ttlSeconds: Infinity })));
+        ruleExecutors[mockUuid] = new RuleExecutor([...rules_1.DEFAULT_RULES, ...rules_1.CUSTOM_RULES].map((r) => ({ ...r, ttlSeconds: Infinity })));
     }
     return ruleExecutors[mockUuid];
 };

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.2",
+  "version": "0.1.3",
   "description": "Stuntman - HTTP proxy / mock server with API",
   "main": "dist/index.js",
   "repository": {
@@ -35,16 +35,20 @@
     "@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",
     "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",
     "prettier": "2.8.4"
@@ -63,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"