@stuntman/server 0.1.6 → 0.1.7

package/dist/mock.js

@@ -1,327 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.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");
-const ruleExecutor_1 = require("./ruleExecutor");
-const storage_1 = require("./storage");
-const shared_1 = require("@stuntman/shared");
-const requestContext_1 = __importDefault(require("./requestContext"));
-const ipUtils_1 = require("./ipUtils");
-const api_1 = require("./api/api");
-const naiveGQLParser = (body) => {
-    try {
-        let json = undefined;
-        try {
-            json = JSON.parse(Buffer.isBuffer(body) ? body.toString('utf-8') : body);
-        }
-        catch (kiss) {
-            // and swallow
-        }
-        if (!(json === null || json === void 0 ? void 0 : json.query) && !(json === null || json === void 0 ? void 0 : json.operationName)) {
-            return;
-        }
-        const lines = json.query
-            .split('\n')
-            .map((l) => l.replace(/^\s+/g, '').trim())
-            .filter((l) => !!l);
-        if (/^query /.test(lines[0])) {
-            json.type = 'query';
-        }
-        else if (/^mutation /.test(lines[0])) {
-            json.type = 'mutation';
-        }
-        else {
-            throw new Error(`Unable to resolve query type of ${lines[0]}`);
-        }
-        json.methodName = lines[json.operationName ? 1 : 0].split('(')[0].split('{')[0];
-        return json;
-    }
-    catch (error) {
-        shared_1.logger.debug(error, 'unable to parse GQL');
-    }
-    return undefined;
-};
-// TODO add proper web proxy mode
-class Mock {
-    get apiServer() {
-        if (this.options.api.disabled) {
-            return null;
-        }
-        if (!this._api) {
-            this._api = new api_1.API({ ...this.options.api, mockUuid: this.mockUuid }, this.options.webgui);
-        }
-        return this._api;
-    }
-    get ruleExecutor() {
-        return (0, ruleExecutor_1.getRuleExecutor)(this.mockUuid);
-    }
-    constructor(options) {
-        this.server = null;
-        this.serverHttps = null;
-        this.ipUtils = null;
-        this._api = null;
-        this.mockUuid = (0, uuid_1.v4)();
-        this.options = options;
-        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}(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 =
-            !this.options.mock.externalDns || this.options.mock.externalDns.length === 0
-                ? null
-                : new ipUtils_1.IPUtils({ mockUuid: this.mockUuid, externalDns: this.options.mock.externalDns });
-        this.requestHandler = async (req, res) => {
-            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 (matchingRule.actions.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 (matchingRule.actions.modifyRequest) {
-                    mockEntry.modifiedRequest = matchingRule.actions.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 = this.options.mock.disableProxy
-                ? {
-                    timestamp: Date.now(),
-                    body: undefined,
-                    rawHeaders: new shared_1.RawHeaders(),
-                    status: 404,
-                }
-                : 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 (matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions.modifyResponse) {
-                modifedResponse = matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.actions.modifyResponse(mockEntry.modifiedRequest, originalResponse);
-                shared_1.logger.debug({ ...logContext, modifedResponse }, 'modified response');
-            }
-            mockEntry.modifiedResponse = modifedResponse;
-            if (matchingRule === null || matchingRule === void 0 ? void 0 : matchingRule.storeTraffic) {
-                this.trafficStore.set(requestUuid, mockEntry);
-            }
-            if (modifedResponse.status) {
-                res.status(modifedResponse.status);
-            }
-            if (modifedResponse.rawHeaders) {
-                for (const header of modifedResponse.rawHeaders.toHeaderPairs()) {
-                    // since fetch decompresses responses we need to get rid of some headers
-                    // TODO maybe could be handled better than just skipping, although express should add these back for new body
-                    // if (/^content-(?:length|encoding)$/i.test(header[0])) {
-                    //     continue;
-                    // }
-                    res.setHeader(header[0], isProxiedHostname ? header[1].replace(unproxiedHostname, originalHostname) : header[1]);
-                }
-            }
-            res.end(Buffer.from(modifedResponse.body, 'binary'));
-        };
-        this.mockApp = (0, express_1.default)();
-        // TODO for now request body is just a buffer passed further, not inflated
-        this.mockApp.use(express_1.default.raw({ type: '*/*' }));
-        this.mockApp.use((req, res, next) => {
-            requestContext_1.default.bind(req, this.mockUuid);
-            next();
-        });
-        this.mockApp.all(/.*/, this.requestHandler);
-        this.mockApp.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)();
-            shared_1.logger.error({ message: error.message, stack: error.stack, name: error.name, uuid }, 'unexpected error');
-            if (res) {
-                res.status(shared_1.HttpCode.INTERNAL_SERVER_ERROR).json({
-                    error: { message: error.message, httpCode: shared_1.HttpCode.INTERNAL_SERVER_ERROR, uuid },
-                });
-                return;
-            }
-            // eslint-disable-next-line no-console
-            console.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),
-        };
-    }
-    start() {
-        if (this.server) {
-            throw new Error('mock server already started');
-        }
-        if (this.options.mock.httpsPort) {
-            this.serverHttps = https_1.default
-                .createServer({
-                key: this.options.mock.httpsKey,
-                cert: this.options.mock.httpsCert,
-            }, this.mockApp)
-                .listen(this.options.mock.httpsPort, () => {
-                shared_1.logger.info(`Mock listening on ${this.options.mock.domain}:${this.options.mock.httpsPort}`);
-            });
-        }
-        this.server = this.mockApp.listen(this.options.mock.port, () => {
-            var _a;
-            shared_1.logger.info(`Mock listening on ${this.options.mock.domain}:${this.options.mock.port}`);
-            if (!this.options.api.disabled) {
-                (_a = this.apiServer) === null || _a === void 0 ? void 0 : _a.start();
-            }
-        });
-    }
-    stop() {
-        var _a;
-        if (!this.server) {
-            throw new Error('mock server not started');
-        }
-        if (!this.options.api.disabled) {
-            (_a = this.apiServer) === null || _a === void 0 ? void 0 : _a.stop();
-        }
-        this.server.close((error) => {
-            shared_1.logger.warn(error, 'problem closing server');
-            this.server = null;
-        });
-    }
-    unproxyRequest(req) {
-        const protocol = (this.MOCK_DOMAIN_REGEX.exec(req.hostname) || [])[2] || req.protocol;
-        const port = (this.MOCK_DOMAIN_REGEX.exec(req.hostname) || [])[1] || undefined;
-        // TODO unproxied req might fail if there's a signed url :shrug:
-        // but then we can probably switch DNS for some particular 3rd party server to point to mock
-        // and in mock have a mapping rule for that domain to point directly to some IP :thinking:
-        return {
-            url: `${protocol}://${req.hostname.replace(this.MOCK_DOMAIN_REGEX, '')}${port ? `:${port}` : ''}${req.originalUrl}`,
-            rawHeaders: new shared_1.RawHeaders(...req.rawHeaders.map((h) => h.replace(this.MOCK_DOMAIN_REGEX, ''))),
-            method: req.method,
-            ...(Buffer.isBuffer(req.body) && { body: req.body.toString('utf-8') }),
-        };
-    }
-    removeProxyPort(req) {
-        if (this.URL_PORT_REGEX.test(req.url)) {
-            req.url = req.url.replace(this.URL_PORT_REGEX, '$1$2');
-        }
-        const host = req.rawHeaders.get('host') || '';
-        if (host.endsWith(`:${this.options.mock.port}`) ||
-            (this.options.mock.httpsPort && host.endsWith(`:${this.options.mock.httpsPort}`))) {
-            req.rawHeaders.set('host', host.split(':')[0]);
-        }
-    }
-}
-exports.Mock = Mock;

package/dist/requestContext.d.ts

@@ -1,9 +0,0 @@
-import type { Request } from 'express';
-export default class RequestContext {
-    static _bindings: WeakMap<Request, RequestContext>;
-    readonly mockUuid: string;
-    readonly uuid: string;
-    constructor(mockUuid: string);
-    static bind(req: Request, mockUuid: string): void;
-    static get(req: Request): RequestContext | null;
-}

package/dist/requestContext.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const uuid_1 = require("uuid");
-class RequestContext {
-    constructor(mockUuid) {
-        this.uuid = (0, uuid_1.v4)();
-        this.mockUuid = mockUuid;
-    }
-    static bind(req, mockUuid) {
-        const ctx = new RequestContext(mockUuid);
-        RequestContext._bindings.set(req, ctx);
-    }
-    static get(req) {
-        return RequestContext._bindings.get(req) || null;
-    }
-}
-exports.default = RequestContext;
-RequestContext._bindings = new WeakMap();

package/dist/ruleExecutor.d.ts

@@ -1,22 +0,0 @@
-import type * as Stuntman from '@stuntman/shared';
-declare class RuleExecutor implements Stuntman.RuleExecutorInterface {
-    private _rules;
-    private rulesLock;
-    private get enabledRules();
-    constructor(rules?: Stuntman.Rule[]);
-    private hasExpired;
-    private cleanUpExpired;
-    addRule(rule: Stuntman.Rule, overwrite?: boolean): Promise<Stuntman.LiveRule>;
-    private _removeRule;
-    removeRule(id: string): Promise<void>;
-    removeRule(rule: Stuntman.Rule): Promise<void>;
-    enableRule(id: string): void;
-    enableRule(rule: Stuntman.Rule): void;
-    disableRule(id: string): void;
-    disableRule(rule: Stuntman.Rule): void;
-    findMatchingRule(request: Stuntman.Request): Promise<Stuntman.LiveRule | null>;
-    getRules(): Promise<readonly Stuntman.LiveRule[]>;
-    getRule(id: string): Promise<Stuntman.LiveRule | undefined>;
-}
-export declare const getRuleExecutor: (mockUuid: string) => RuleExecutor;
-export {};

package/dist/ruleExecutor.js

@@ -1,187 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRuleExecutor = void 0;
-const await_lock_1 = __importDefault(require("await-lock"));
-const shared_1 = require("@stuntman/shared");
-const rules_1 = require("./rules");
-const ruleExecutors = {};
-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.rulesLock = new await_lock_1.default();
-        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 this.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 this.rulesLock.release();
-        }
-    }
-    async addRule(rule, overwrite) {
-        await this.cleanUpExpired();
-        await this.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 this.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 this.rulesLock.acquireAsync();
-        try {
-            this._removeRule(ruleOrId);
-        }
-        finally {
-            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');
-            }
-        });
-    }
-    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) => {
-            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');
-            }
-        });
-        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, matchResultMessage: typeof matchResult !== 'boolean' ? matchResult.description : null }, 'found matching rule');
-        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!!!");
-        }
-        // 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');
-                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');
-                await 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);
-    }
-}
-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/catchAll.d.ts

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

package/dist/rules/catchAll.js

@@ -1,15 +0,0 @@
-"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

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

package/dist/rules/echo.js

@@ -1,15 +0,0 @@
-"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

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