@stuntman/server 0.1.0 → 0.1.1

package/src/requestContext.ts

@@ -1,23 +0,0 @@
-import type { Request } from 'express';
-import { v4 as uuidv4 } from 'uuid';
-
-export default class RequestContext {
-    static _bindings: WeakMap<Request, RequestContext> = new WeakMap<Request, RequestContext>();
-
-    public readonly mockUuid;
-    public readonly uuid;
-
-    constructor(mockUuid: string) {
-        this.uuid = uuidv4();
-        this.mockUuid = mockUuid;
-    }
-
-    static bind(req: Request, mockUuid: string): void {
-        const ctx = new RequestContext(mockUuid);
-        RequestContext._bindings.set(req, ctx);
-    }
-
-    static get(req: Request): RequestContext | null {
-        return RequestContext._bindings.get(req) || null;
-    }
-}

package/src/ruleExecutor.ts

@@ -1,193 +0,0 @@
-import AwaitLock from 'await-lock';
-import { AppError, DEFAULT_RULE_PRIORITY, HttpCode, logger } from '@stuntman/shared';
-import type * as Stuntman from '@stuntman/shared';
-import { DEFAULT_RULES } from './rules';
-
-const rulesLock = new AwaitLock();
-
-const transformMockRuleToLive = (rule: Stuntman.Rule): Stuntman.LiveRule => {
-    return {
-        ...rule,
-        counter: 0,
-        isEnabled: rule.isEnabled ?? true,
-        createdTimestamp: Date.now(),
-    };
-};
-
-class RuleExecutor {
-    // TODO persistent rule storage maybe
-    private _rules: Stuntman.LiveRule[];
-
-    private get enabledRules() {
-        if (!this._rules) {
-            return new Array<Stuntman.LiveRule>();
-        }
-        const now = Date.now();
-        return this._rules
-            .filter((r) => (r.isEnabled && !Number.isFinite(r.ttlSeconds)) || r.createdTimestamp + r.ttlSeconds * 1000 > now)
-            .sort((a, b) => (a.priority ?? DEFAULT_RULE_PRIORITY) - (b.priority ?? DEFAULT_RULE_PRIORITY));
-    }
-
-    constructor(rules?: Stuntman.Rule[]) {
-        this._rules = (rules || []).map(transformMockRuleToLive);
-    }
-
-    private hasExpired() {
-        const now = Date.now();
-        return this._rules.some((r) => Number.isFinite(r.ttlSeconds) && r.createdTimestamp + r.ttlSeconds * 1000 < now);
-    }
-
-    private 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) {
-                    logger.debug({ ruleId: r.id }, 'removing expired rule');
-                }
-                return shouldKeep;
-            });
-        } finally {
-            await rulesLock.release();
-        }
-    }
-
-    async addRule(rule: Stuntman.Rule, overwrite?: boolean): Promise<Stuntman.LiveRule> {
-        await this.cleanUpExpired();
-        await rulesLock.acquireAsync();
-        try {
-            if (this._rules.some((r) => r.id === rule.id)) {
-                if (!overwrite) {
-                    throw new AppError({ httpCode: HttpCode.CONFLICT, message: 'rule with given ID already exists' });
-                }
-                this._removeRule(rule.id);
-            }
-            const liveRule = transformMockRuleToLive(rule);
-            this._rules.push(liveRule);
-            logger.debug(liveRule, 'rule added');
-            return liveRule;
-        } finally {
-            await rulesLock.release();
-        }
-    }
-
-    private _removeRule(ruleOrId: string | Stuntman.Rule) {
-        this._rules = this._rules.filter((r) => {
-            const notFound = r.id !== (typeof ruleOrId === 'string' ? ruleOrId : ruleOrId.id);
-            if (!notFound) {
-                logger.debug({ ruleId: r.id }, 'rule removed');
-            }
-            return notFound;
-        });
-    }
-
-    async removeRule(id: string): Promise<void>;
-    async removeRule(rule: Stuntman.Rule): Promise<void>;
-    async removeRule(ruleOrId: string | Stuntman.Rule): Promise<void> {
-        await this.cleanUpExpired();
-        await rulesLock.acquireAsync();
-        try {
-            this._removeRule(ruleOrId);
-        } finally {
-            await rulesLock.release();
-        }
-    }
-
-    enableRule(id: string): void;
-    enableRule(rule: Stuntman.Rule): void;
-    enableRule(ruleOrId: string | Stuntman.Rule): void {
-        this._rules.forEach((r) => {
-            if (r.id === (typeof ruleOrId === 'string' ? ruleOrId : ruleOrId.id)) {
-                r.isEnabled = true;
-                logger.debug({ ruleId: r.id }, 'rule enabled');
-            }
-        });
-    }
-
-    disableRule(id: string): void;
-    disableRule(rule: Stuntman.Rule): void;
-    disableRule(ruleOrId: string | Stuntman.Rule): void {
-        this._rules.forEach((r) => {
-            if (r.id === (typeof ruleOrId === 'string' ? ruleOrId : ruleOrId.id)) {
-                r.isEnabled = false;
-                logger.debug({ ruleId: r.id }, 'rule disabled');
-            }
-        });
-    }
-
-    async findMatchingRule(request: Stuntman.Request): Promise<Stuntman.LiveRule | null> {
-        const logContext: Record<string, any> = {
-            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) {
-            logger.debug(logContext, 'no matching rule found');
-            return null;
-        }
-        const matchResult: Stuntman.RuleMatchResult = matchingRule.matches(request);
-        logContext.ruleId = matchingRule.id;
-        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;
-            logger.warn(logContext, "it's over 9000!!!");
-        }
-        if (matchingRule.disableAfterUse) {
-            if (typeof matchingRule.disableAfterUse === 'boolean' || matchingRule.disableAfterUse <= matchingRule.counter) {
-                logger.debug(logContext, 'disabling rule for future requests');
-                this.disableRule(matchingRule);
-            }
-        }
-        if (matchingRule.removeAfterUse) {
-            if (typeof matchingRule.removeAfterUse === 'boolean' || matchingRule.removeAfterUse <= matchingRule.counter) {
-                logger.debug(logContext, 'removing rule for future requests');
-                this.removeRule(matchingRule);
-            }
-        }
-        if (typeof matchResult !== 'boolean') {
-            if (matchResult.disableRuleIds && matchResult.disableRuleIds.length > 0) {
-                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) {
-                logger.debug(
-                    { ...logContext, disableRuleIds: matchResult.disableRuleIds },
-                    'enabling rules based on matchResult'
-                );
-                for (const ruleId of matchResult.enableRuleIds) {
-                    this.enableRule(ruleId);
-                }
-            }
-        }
-        return matchingRuleClone;
-    }
-
-    async getRules(): Promise<readonly Stuntman.LiveRule[]> {
-        await this.cleanUpExpired();
-        return this._rules;
-    }
-
-    async getRule(id: string): Promise<Stuntman.LiveRule | undefined> {
-        await this.cleanUpExpired();
-        return this._rules.find((r) => r.id === id);
-    }
-}
-
-export const ruleExecutor = new RuleExecutor(DEFAULT_RULES.map((r) => ({ ...r, ttlSeconds: Infinity })));

package/src/rules/catchAll.ts

@@ -1,14 +0,0 @@
-import { CATCH_ALL_RULE_PRIORITY, CATCH_RULE_NAME } from '@stuntman/shared';
-import type * as Stuntman from '@stuntman/shared';
-
-export const catchAllRule: Stuntman.DeployedRule = {
-    id: CATCH_RULE_NAME,
-    matches: () => true,
-    priority: CATCH_ALL_RULE_PRIORITY,
-    actions: {
-        mockResponse: (req: Stuntman.Request) => ({
-            body: `Request received by Stuntman mock <pre>${JSON.stringify(req, null, 4)}</pre>`,
-            status: 200,
-        }),
-    },
-};

package/src/rules/echo.ts

@@ -1,14 +0,0 @@
-import { DEFAULT_RULE_PRIORITY } from '@stuntman/shared';
-import type * as Stuntman from '@stuntman/shared';
-
-export const echoRule: Stuntman.DeployedRule = {
-    id: 'internal/echo',
-    priority: DEFAULT_RULE_PRIORITY + 1,
-    matches: (req: Stuntman.Request) => /https?:\/\/echo\/.*/.test(req.url),
-    actions: {
-        mockResponse: (req: Stuntman.Request) => ({
-            body: req,
-            status: 200,
-        }),
-    },
-};

package/src/rules/index.ts

@@ -1,7 +0,0 @@
-import { catchAllRule } from './catchAll';
-import { echoRule } from './echo';
-import type * as Stuntman from '@stuntman/shared';
-
-// TODO add option to load rules additional default rules from some nice configurable folder
-
-export const DEFAULT_RULES: Stuntman.DeployedRule[] = [catchAllRule, echoRule];

package/src/storage.ts

@@ -1,39 +0,0 @@
-import LRUCache from 'lru-cache';
-import type * as Stuntman from '@stuntman/shared';
-import sizeof from 'object-sizeof';
-
-const DNS_CACHE_OPTIONS: LRUCache.Options<string, string> = {
-    max: 1000,
-    ttl: 1000 * 60 * 15,
-    allowStale: false,
-    updateAgeOnGet: false,
-    updateAgeOnHas: false,
-};
-
-const trafficStoreInstances: Record<string, LRUCache<string, Stuntman.LogEntry>> = {};
-const dnsResolutionCacheInstances: Record<string, LRUCache<string, string>> = {};
-
-export const getTrafficStore = (key: string, options?: Stuntman.StorageConfig) => {
-    if (!(key in trafficStoreInstances)) {
-        if (!options) {
-            throw new Error('initialize with options first');
-        }
-        trafficStoreInstances[key] = new LRUCache<string, Stuntman.LogEntry>({
-            max: options.limitCount,
-            maxSize: options.limitSize,
-            ttl: options.ttl,
-            allowStale: false,
-            updateAgeOnGet: false,
-            updateAgeOnHas: false,
-            sizeCalculation: (value) => sizeof(value),
-        });
-    }
-    return trafficStoreInstances[key];
-};
-
-export const getDnsResolutionCache = (key: string) => {
-    if (!(key in dnsResolutionCacheInstances)) {
-        dnsResolutionCacheInstances[key] = new LRUCache<string, string>(DNS_CACHE_OPTIONS);
-    }
-    return dnsResolutionCacheInstances[key];
-};

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2018",
-        "module": "commonjs",
-        "rootDir": "src",
-        "declaration": true,
-        "outDir": "dist",
-        "esModuleInterop": true,
-        "forceConsistentCasingInFileNames": true,
-        "strict": true,
-        "skipLibCheck": true,
-        "typeRoots": ["node_modules/@types"],
-        "allowJs": true,
-        "moduleResolution": "node16"
-    }
-}