@stuntman/server 0.1.4 → 0.1.6

package/src/rules/index.ts

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import glob from 'glob';
+import * as tsImport from 'ts-import';
+import { catchAllRule } from './catchAll';
+import { echoRule } from './echo';
+import { serverConfig, logger } from '@stuntman/shared';
+import type * as Stuntman from '@stuntman/shared';
+
+export const DEFAULT_RULES: Stuntman.DeployedRule[] = [catchAllRule, echoRule];
+export const CUSTOM_RULES: Stuntman.DeployedRule[] = [];
+
+const loadAdditionalRules = () => {
+    if (!serverConfig.mock.rulesPath || !fs.existsSync(serverConfig.mock.rulesPath)) {
+        logger.debug({ rulesPath: serverConfig.mock.rulesPath }, `additional rules directory not found`);
+        return;
+    }
+    logger.debug({ rulesPath: serverConfig.mock.rulesPath }, `loading additional rules`);
+    const filePaths = glob.sync('*.[tj]s', { absolute: true, cwd: 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) as Stuntman.DeployedRule[]).filter((rule) => {
+                if (!rule || !rule.id || typeof rule.matches !== 'function') {
+                    logger.error({ filePath, rule }, 'invalid exported rule');
+                    return false;
+                }
+                return true;
+            });
+            CUSTOM_RULES.push(...exportedRules);
+        } catch (error) {
+            logger.error({ filePath, error }, 'error importing rule');
+        }
+    }
+    const ruleIds = [...DEFAULT_RULES, ...CUSTOM_RULES].map((rule) => rule.id);
+    const duplicatedRuleIds = ruleIds.filter((currentValue, currentIndex) => ruleIds.indexOf(currentValue) !== currentIndex);
+    if (duplicatedRuleIds.length > 0) {
+        logger.error({ duplicatedRuleIds }, 'duplicated rule ids');
+        throw new Error('duplicated rule ids');
+    }
+};
+
+loadAdditionalRules();

package/src/storage.ts

@@ -0,0 +1,39 @@
+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];
+};