@stuntman/server 0.1.0

package/dist/ruleExecutor.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleExecutor = 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 transformMockRuleToLive = (rule) => {
+    var _a;
+    return {
+        ...rule,
+        counter: 0,
+        isEnabled: (_a = rule.isEnabled) !== null && _a !== void 0 ? _a : true,
+        createdTimestamp: Date.now(),
+    };
+};
+class RuleExecutor {
+    get enabledRules() {
+        if (!this._rules) {
+            return new Array();
+        }
+        const now = Date.now();
+        return this._rules
+            .filter((r) => (r.isEnabled && !Number.isFinite(r.ttlSeconds)) || r.createdTimestamp + r.ttlSeconds * 1000 > now)
+            .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._rules = (rules || []).map(transformMockRuleToLive);
+    }
+    hasExpired() {
+        const now = Date.now();
+        return this._rules.some((r) => Number.isFinite(r.ttlSeconds) && r.createdTimestamp + r.ttlSeconds * 1000 < now);
+    }
+    async cleanUpExpired() {
+        if (!this.hasExpired()) {
+            return;
+        }
+        await rulesLock.acquireAsync();
+        const now = Date.now();
+        try {
+            this._rules = this._rules.filter((r) => {
+                const shouldKeep = !Number.isFinite(r.ttlSeconds) || r.createdTimestamp + r.ttlSeconds * 1000 > now;
+                if (!shouldKeep) {
+                    shared_1.logger.debug({ ruleId: r.id }, 'removing expired rule');
+                }
+                return shouldKeep;
+            });
+        }
+        finally {
+            await rulesLock.release();
+        }
+    }
+    async addRule(rule, overwrite) {
+        await this.cleanUpExpired();
+        await rulesLock.acquireAsync();
+        try {
+            if (this._rules.some((r) => r.id === rule.id)) {
+                if (!overwrite) {
+                    throw new shared_1.AppError({ httpCode: shared_1.HttpCode.CONFLICT, message: 'rule with given ID already exists' });
+                }
+                this._removeRule(rule.id);
+            }
+            const liveRule = transformMockRuleToLive(rule);
+            this._rules.push(liveRule);
+            shared_1.logger.debug(liveRule, 'rule added');
+            return liveRule;
+        }
+        finally {
+            await rulesLock.release();
+        }
+    }
+    _removeRule(ruleOrId) {
+        this._rules = this._rules.filter((r) => {
+            const notFound = r.id !== (typeof ruleOrId === 'string' ? ruleOrId : ruleOrId.id);
+            if (!notFound) {
+                shared_1.logger.debug({ ruleId: r.id }, 'rule removed');
+            }
+            return notFound;
+        });
+    }
+    async removeRule(ruleOrId) {
+        await this.cleanUpExpired();
+        await rulesLock.acquireAsync();
+        try {
+            this._removeRule(ruleOrId);
+        }
+        finally {
+            await rulesLock.release();
+        }
+    }
+    enableRule(ruleOrId) {
+        this._rules.forEach((r) => {
+            if (r.id === (typeof ruleOrId === 'string' ? ruleOrId : ruleOrId.id)) {
+                r.isEnabled = true;
+                shared_1.logger.debug({ ruleId: r.id }, 'rule enabled');
+            }
+        });
+    }
+    disableRule(ruleOrId) {
+        this._rules.forEach((r) => {
+            if (r.id === (typeof ruleOrId === 'string' ? ruleOrId : ruleOrId.id)) {
+                r.isEnabled = false;
+                shared_1.logger.debug({ ruleId: r.id }, 'rule disabled');
+            }
+        });
+    }
+    async findMatchingRule(request) {
+        const logContext = {
+            requestId: request.id,
+        };
+        const matchingRule = this.enabledRules.find((rule) => {
+            const matchResult = rule.matches(request);
+            if (typeof matchResult === 'boolean') {
+                return matchResult;
+            }
+            return matchResult.result;
+        });
+        if (!matchingRule) {
+            shared_1.logger.debug(logContext, 'no matching rule found');
+            return null;
+        }
+        const matchResult = matchingRule.matches(request);
+        logContext.ruleId = matchingRule.id;
+        shared_1.logger.debug(logContext, 'matching rule found');
+        const matchingRuleClone = Object.freeze(Object.assign({}, matchingRule));
+        ++matchingRule.counter;
+        logContext.ruleCounter = matchingRule.counter;
+        if (Number.isNaN(matchingRule.counter) || !Number.isFinite(matchingRule.counter)) {
+            matchingRule.counter = 0;
+            shared_1.logger.warn(logContext, "it's over 9000!!!");
+        }
+        if (matchingRule.disableAfterUse) {
+            if (typeof matchingRule.disableAfterUse === 'boolean' || matchingRule.disableAfterUse <= matchingRule.counter) {
+                shared_1.logger.debug(logContext, 'disabling rule for future requests');
+                this.disableRule(matchingRule);
+            }
+        }
+        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);
+            }
+        }
+        if (typeof matchResult !== 'boolean') {
+            if (matchResult.disableRuleIds && matchResult.disableRuleIds.length > 0) {
+                shared_1.logger.debug({ ...logContext, disableRuleIds: matchResult.disableRuleIds }, 'disabling rules based on matchResult');
+                for (const ruleId of matchResult.disableRuleIds) {
+                    this.disableRule(ruleId);
+                }
+            }
+            if (matchResult.enableRuleIds && matchResult.enableRuleIds.length > 0) {
+                shared_1.logger.debug({ ...logContext, disableRuleIds: matchResult.disableRuleIds }, 'enabling rules based on matchResult');
+                for (const ruleId of matchResult.enableRuleIds) {
+                    this.enableRule(ruleId);
+                }
+            }
+        }
+        return matchingRuleClone;
+    }
+    async getRules() {
+        await this.cleanUpExpired();
+        return this._rules;
+    }
+    async getRule(id) {
+        await this.cleanUpExpired();
+        return this._rules.find((r) => r.id === id);
+    }
+}
+exports.ruleExecutor = new RuleExecutor(rules_1.DEFAULT_RULES.map((r) => ({ ...r, ttlSeconds: Infinity })));

package/dist/rules/catchAll.d.ts

@@ -0,0 +1,2 @@
+import type * as Stuntman from '@stuntman/shared';
+export declare const catchAllRule: Stuntman.DeployedRule;

package/dist/rules/catchAll.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.catchAllRule = void 0;
+const shared_1 = require("@stuntman/shared");
+exports.catchAllRule = {
+    id: shared_1.CATCH_RULE_NAME,
+    matches: () => true,
+    priority: shared_1.CATCH_ALL_RULE_PRIORITY,
+    actions: {
+        mockResponse: (req) => ({
+            body: `Request received by Stuntman mock <pre>${JSON.stringify(req, null, 4)}</pre>`,
+            status: 200,
+        }),
+    },
+};

package/dist/rules/echo.d.ts

@@ -0,0 +1,2 @@
+import type * as Stuntman from '@stuntman/shared';
+export declare const echoRule: Stuntman.DeployedRule;

package/dist/rules/echo.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.echoRule = void 0;
+const shared_1 = require("@stuntman/shared");
+exports.echoRule = {
+    id: 'internal/echo',
+    priority: shared_1.DEFAULT_RULE_PRIORITY + 1,
+    matches: (req) => /https?:\/\/echo\/.*/.test(req.url),
+    actions: {
+        mockResponse: (req) => ({
+            body: req,
+            status: 200,
+        }),
+    },
+};

package/dist/rules/index.d.ts

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

package/dist/rules/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RULES = void 0;
+const catchAll_1 = require("./catchAll");
+const echo_1 = require("./echo");
+// TODO add option to load rules additional default rules from some nice configurable folder
+exports.DEFAULT_RULES = [catchAll_1.catchAllRule, echo_1.echoRule];

package/dist/storage.d.ts

@@ -0,0 +1,4 @@
+import LRUCache from 'lru-cache';
+import type * as Stuntman from '@stuntman/shared';
+export declare const getTrafficStore: (key: string, options?: Stuntman.StorageConfig) => LRUCache<string, Stuntman.LogEntry>;
+export declare const getDnsResolutionCache: (key: string) => LRUCache<string, string>;

package/dist/storage.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDnsResolutionCache = exports.getTrafficStore = void 0;
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const object_sizeof_1 = __importDefault(require("object-sizeof"));
+const DNS_CACHE_OPTIONS = {
+    max: 1000,
+    ttl: 1000 * 60 * 15,
+    allowStale: false,
+    updateAgeOnGet: false,
+    updateAgeOnHas: false,
+};
+const trafficStoreInstances = {};
+const dnsResolutionCacheInstances = {};
+const getTrafficStore = (key, options) => {
+    if (!(key in trafficStoreInstances)) {
+        if (!options) {
+            throw new Error('initialize with options first');
+        }
+        trafficStoreInstances[key] = new lru_cache_1.default({
+            max: options.limitCount,
+            maxSize: options.limitSize,
+            ttl: options.ttl,
+            allowStale: false,
+            updateAgeOnGet: false,
+            updateAgeOnHas: false,
+            sizeCalculation: (value) => (0, object_sizeof_1.default)(value),
+        });
+    }
+    return trafficStoreInstances[key];
+};
+exports.getTrafficStore = getTrafficStore;
+const getDnsResolutionCache = (key) => {
+    if (!(key in dnsResolutionCacheInstances)) {
+        dnsResolutionCacheInstances[key] = new lru_cache_1.default(DNS_CACHE_OPTIONS);
+    }
+    return dnsResolutionCacheInstances[key];
+};
+exports.getDnsResolutionCache = getDnsResolutionCache;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@stuntman/server",
+  "version": "0.1.0",
+  "description": "Stuntman - HTTP proxy / mock server with API",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andrzej-woof/stuntman.git"
+  },
+  "keywords": [
+    "proxy",
+    "mock",
+    "http",
+    "https",
+    "server",
+    "api",
+    "e2e",
+    "development",
+    "rest",
+    "gql",
+    "end-to-end",
+    "testing",
+    "qa",
+    "automated-testing",
+    "stub",
+    "functional"
+  ],
+  "author": "Andrzej Pasterczyk",
+  "license": "MIT",
+  "dependencies": {
+    "@stuntman/shared": "^0.1.0",
+    "await-lock": "2.2.2",
+    "express": "5.0.0-beta.1",
+    "lru-cache": "7.16.0",
+    "object-sizeof": "2.6.1",
+    "pug": "^3.0.2",
+    "serialize-javascript": "6.0.1",
+    "uuid": "9.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "4.17.17",
+    "@types/serialize-javascript": "5.0.2",
+    "@types/uuid": "9.0.0"
+  },
+  "bin": {
+    "stuntman": "./dist/bin/stuntman.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "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",
+    "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"
+  }
+}

package/src/api/api.ts

@@ -0,0 +1,194 @@
+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 { ruleExecutor } 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 './validatiors';
+import { deserializeRule, escapedSerialize, liveRuleToRule } from './utils';
+
+type ApiOptions = Stuntman.ApiConfig & {
+    mockUuid: string;
+};
+
+export class API {
+    protected options: Required<ApiOptions>;
+    protected apiApp: ExpressServer;
+    trafficStore: LRUCache<string, Stuntman.LogEntry>;
+    server: http.Server | null = null;
+
+    constructor(options: ApiOptions, webGuiOptions?: Stuntman.WebGuiConfig) {
+        this.options = options;
+
+        this.trafficStore = getTrafficStore(this.options.mockUuid);
+        this.apiApp = express();
+
+        this.apiApp.use(express.json());
+        this.apiApp.use(express.text());
+
+        this.apiApp.use((req: Request, res: Response, next: NextFunction) => {
+            RequestContext.bind(req, this.options.mockUuid);
+            next();
+        });
+
+        this.apiApp.get('/rule', async (req, res) => {
+            res.send(stringify(await ruleExecutor.getRules()));
+        });
+
+        this.apiApp.get('/rule/:ruleId', async (req, res) => {
+            res.send(stringify(await ruleExecutor.getRule(req.params.ruleId)));
+        });
+
+        this.apiApp.get('/rule/:ruleId/disable', (req, res) => {
+            ruleExecutor.disableRule(req.params.ruleId);
+            res.send();
+        });
+
+        this.apiApp.get('/rule/:ruleId/enable', (req, res) => {
+            ruleExecutor.enableRule(req.params.ruleId);
+            res.send();
+        });
+
+        this.apiApp.post('/rule', async (req: Request<object, string, Stuntman.SerializedRule>, res) => {
+            const deserializedRule = deserializeRule(req.body);
+            validateDeserializedRule(deserializedRule);
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const rule = await ruleExecutor.addRule(deserializedRule);
+            res.send(stringify(rule));
+        });
+
+        this.apiApp.get('/rule/:ruleId/remove', async (req, res) => {
+            await ruleExecutor.removeRule(req.params.ruleId);
+            res.send();
+        });
+
+        this.apiApp.get('/traffic', (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', (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);
+        });
+
+        this.apiApp.use((error: Error | AppError, req: Request, res: Response, _next: NextFunction) => {
+            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({ ...error, uuid }, 'Unexpected error');
+            if (res) {
+                res.status(HttpCode.INTERNAL_SERVER_ERROR).json({
+                    error: { message: error.message, httpCode: HttpCode.INTERNAL_SERVER_ERROR, uuid },
+                });
+                return;
+            }
+            console.log('Application encountered a critical error. Exiting');
+            process.exit(1);
+        });
+
+        this.apiApp.set('views', __dirname + '/webgui');
+        this.apiApp.set('view engine', 'pug');
+
+        if (!webGuiOptions?.disabled) {
+            this.initWebGui();
+        }
+    }
+
+    private initWebGui() {
+        this.apiApp.get('/webgui/rules', async (req, res) => {
+            const rules: Record<string, string> = {};
+            for (const rule of await ruleExecutor.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', 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', 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 ruleExecutor.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 './validatiors';
+
+// 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;
+};