@stuntman/shared 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Andrzej Pasterczyk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/appError.d.ts

@@ -0,0 +1,14 @@
+import type * as Stuntman from '.';
+export interface AppErrorInterface {
+    name?: string;
+    httpCode: Stuntman.HttpCode;
+    message: string;
+    isOperational?: boolean;
+}
+export declare class AppError extends Error {
+    readonly name: string;
+    readonly httpCode: Stuntman.HttpCode;
+    readonly uuid?: string;
+    readonly isOperational: boolean;
+    constructor(args: AppErrorInterface);
+}

package/dist/appError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+class AppError extends Error {
+    constructor(args) {
+        super(args.message);
+        this.isOperational = true;
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = args.name || 'Error';
+        this.httpCode = args.httpCode;
+        if (args.isOperational !== undefined) {
+            this.isOperational = args.isOperational;
+        }
+        Error.captureStackTrace(this);
+    }
+}
+exports.AppError = AppError;

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import { ServerConfig } from '.';
+export declare const serverConfig: ServerConfig;

package/dist/config.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverConfig = void 0;
+const _1 = require(".");
+const config_1 = __importDefault(require("config"));
+const defaults_1 = __importDefault(require("defaults"));
+// TODO safeguards & defaults
+const defaultConfig = {
+    api: {
+        disabled: false,
+        port: _1.DEFAULT_API_PORT,
+    },
+    mock: {
+        domain: _1.DEFAULT_MOCK_DOMAIN,
+        externalDns: _1.EXTERNAL_DNS,
+        port: _1.DEFAULT_MOCK_PORT,
+        timeout: _1.DEFAULT_PROXY_TIMEOUT,
+    },
+    storage: {
+        traffic: {
+            limitCount: _1.DEFAULT_CACHE_MAX_ENTRIES,
+            limitSize: _1.DEFAULT_CACHE_MAX_SIZE,
+            ttl: _1.DEFAULT_CACHE_TTL
+        },
+    },
+    webgui: {
+        disabled: false,
+    },
+};
+let configFromFile = {};
+try {
+    configFromFile = config_1.default.get('stuntman');
+}
+catch (error) {
+    console.warn('unable to find correct config');
+}
+exports.serverConfig = (0, defaults_1.default)(configFromFile, defaultConfig);

package/dist/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_PROXY_TIMEOUT = 60000;
+export declare const DEFAULT_RULE_PRIORITY = 100;
+export declare const DEFAULT_MOCK_PORT = 2015;
+export declare const DEFAULT_API_PORT = 1985;
+export declare const DEFAULT_CACHE_MAX_ENTRIES = 500;
+export declare const DEFAULT_CACHE_MAX_SIZE: number;
+export declare const DEFAULT_CACHE_TTL: number;
+export declare const DEFAULT_MOCK_DOMAIN = "stuntman";
+export declare const DEFAULT_RULE_TTL_SECONDS: number;
+export declare const MIN_RULE_TTL_SECONDS = 10;
+export declare const MAX_RULE_TTL_SECONDS: number;
+export declare const CATCH_ALL_RULE_PRIORITY: number;
+export declare const CATCH_RULE_NAME = "internal/catch-all";
+export declare const EXTERNAL_DNS: string[];

package/dist/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTERNAL_DNS = exports.CATCH_RULE_NAME = exports.CATCH_ALL_RULE_PRIORITY = exports.MAX_RULE_TTL_SECONDS = exports.MIN_RULE_TTL_SECONDS = exports.DEFAULT_RULE_TTL_SECONDS = exports.DEFAULT_MOCK_DOMAIN = exports.DEFAULT_CACHE_TTL = exports.DEFAULT_CACHE_MAX_SIZE = exports.DEFAULT_CACHE_MAX_ENTRIES = exports.DEFAULT_API_PORT = exports.DEFAULT_MOCK_PORT = exports.DEFAULT_RULE_PRIORITY = exports.DEFAULT_PROXY_TIMEOUT = void 0;
+exports.DEFAULT_PROXY_TIMEOUT = 60000;
+exports.DEFAULT_RULE_PRIORITY = 100;
+exports.DEFAULT_MOCK_PORT = 2015;
+exports.DEFAULT_API_PORT = 1985;
+exports.DEFAULT_CACHE_MAX_ENTRIES = 500;
+exports.DEFAULT_CACHE_MAX_SIZE = 500 * 1024 * 1024;
+exports.DEFAULT_CACHE_TTL = 1000 * 60 * 60;
+exports.DEFAULT_MOCK_DOMAIN = 'stuntman';
+exports.DEFAULT_RULE_TTL_SECONDS = 60 * 10;
+exports.MIN_RULE_TTL_SECONDS = 10;
+exports.MAX_RULE_TTL_SECONDS = 60 * 60;
+exports.CATCH_ALL_RULE_PRIORITY = Infinity;
+exports.CATCH_RULE_NAME = 'internal/catch-all';
+exports.EXTERNAL_DNS = ['8.8.8.8', '1.1.1.1'];

package/dist/index.d.ts

@@ -0,0 +1,153 @@
+export * from './constants';
+export * from './appError';
+export * from './logger';
+export * from './stringify';
+export * from './rawHeaders';
+export * from './config';
+export declare const INDEX_DTS: string;
+type NonObject = string | number | boolean | symbol | undefined | null | any[];
+interface SerializableTypesRecord<T> {
+    [k: string | number]: T;
+}
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+type SerializableTypes = string | number | boolean | undefined | null | RegExp | SerializableTypes[] | SerializableTypesRecord<SerializableTypes>;
+export declare enum HttpCode {
+    OK = 200,
+    NO_CONTENT = 204,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    NOT_FOUND = 404,
+    CONFLICT = 409,
+    UNPROCESSABLE_ENTITY = 422,
+    INTERNAL_SERVER_ERROR = 500
+}
+export type LocalVariables = Record<string, SerializableTypes>;
+export type RuleMatchResult = boolean | {
+    result: boolean;
+    enableRuleIds?: string[];
+    disableRuleIds?: string[];
+};
+export type RemotableFunction<T extends Function> = {
+    localFn: T;
+    localVariables?: LocalVariables;
+};
+export type SerializedRemotableFunction = {
+    localFn: string;
+    variable?: string;
+    remoteFn: string;
+};
+type WithRemotableFunctions<Type> = {
+    [PropertyKey in keyof Type]: Extract<Type[PropertyKey], Function> extends never ? Exclude<Type[PropertyKey], NonObject> extends never ? Type[PropertyKey] : WithRemotableFunctions<Exclude<Type[PropertyKey], NonObject>> : Exclude<Type[PropertyKey], Function> | RemotableFunction<Extract<Type[PropertyKey], Function>>;
+};
+export type WithSerializedFunctions<Type> = {
+    [PropertyKey in keyof Type]: Extract<Type[PropertyKey], RemotableFunction<Function>> extends never ? Exclude<Type[PropertyKey], NonObject> extends never ? Type[PropertyKey] : WithSerializedFunctions<Exclude<Type[PropertyKey], NonObject>> : Exclude<Type[PropertyKey], RemotableFunction<Function>> | SerializedRemotableFunction;
+};
+export interface RawHeadersInterface extends Array<string> {
+    get: (name: string) => string | undefined;
+    set: (name: string, value: string) => void;
+    has: (name: string, value?: string) => boolean;
+    add: (name: string, value: string) => void;
+    remove: (name: string) => void;
+    toHeaderPairs: () => readonly [string, string][];
+}
+export type BaseRequest = {
+    rawHeaders: RawHeadersInterface;
+    url: string;
+    body?: any;
+    method: string;
+};
+export type Request = BaseRequest & {
+    id: string;
+    timestamp: number;
+    gqlBody?: GQLRequestBody;
+};
+export type Response = {
+    rawHeaders?: RawHeadersInterface;
+    status?: number;
+    body?: any;
+    timestamp?: number;
+};
+export type LogEntry = {
+    originalRequest: Request;
+    labels?: string[];
+    mockRuleId?: string;
+    originalResponse?: Response;
+    modifiedRequest?: Request;
+    modifiedResponse?: Response;
+};
+export type RuleMatchFunction = (request: Request) => RuleMatchResult;
+export type RequestManipulationFn = (request: Request) => Request;
+export type ResponseManipulationFn = (request: Request, response: Response) => Response;
+export type ResponseGenerationFn = (request: Request) => Response;
+export type Actions = {
+    mockResponse: Response | ResponseGenerationFn;
+    modifyRequest?: undefined;
+    modifyResponse?: undefined;
+} | {
+    mockResponse?: undefined;
+    modifyRequest?: RequestManipulationFn;
+    modifyResponse?: ResponseManipulationFn;
+};
+export type Rule = {
+    id: string;
+    priority?: number;
+    matches: RuleMatchFunction;
+    labels?: string[];
+    actions?: Actions;
+    disableAfterUse?: boolean | number;
+    removeAfterUse?: boolean | number;
+    ttlSeconds: number;
+    storeTraffic?: boolean;
+    isEnabled?: boolean;
+};
+export type DeployedRule = Omit<Rule, 'disableAfterUse' | 'removeAfterUse' | 'ttlSeconds'>;
+export type SerializableRule = WithRemotableFunctions<Rule>;
+export type SerializedRule = WithSerializedFunctions<SerializableRule>;
+export type LiveRule = Rule & {
+    counter: number;
+    createdTimestamp: number;
+};
+export type GQLRequestBody = {
+    operationName: string;
+    variables?: any;
+    query: string;
+    type: 'query' | 'mutation';
+    methodName?: string;
+};
+export type WebGuiConfig = {
+    disabled: boolean;
+};
+export type ApiConfig = {
+    port: number;
+    disabled: boolean;
+};
+export type ClientConfig = {
+    protocol?: 'http' | 'https';
+    host?: string;
+    port?: number;
+    timeout?: number;
+};
+export type MockConfig = {
+    domain: string;
+    port: number;
+    httpsPort?: number;
+    httpsKey?: string;
+    httpsCert?: string;
+    timeout: number;
+    externalDns: string[];
+};
+export type StorageConfig = {
+    limitCount: number;
+    limitSize: number;
+    ttl: number;
+};
+export type ServerConfig = {
+    webgui: WebGuiConfig;
+    api: ApiConfig;
+    mock: MockConfig;
+    storage: {
+        traffic: StorageConfig;
+    };
+};

package/dist/index.js

@@ -0,0 +1,40 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCode = exports.INDEX_DTS = void 0;
+/* eslint-disable @typescript-eslint/ban-types */
+__exportStar(require("./constants"), exports);
+__exportStar(require("./appError"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./stringify"), exports);
+__exportStar(require("./rawHeaders"), exports);
+__exportStar(require("./config"), exports);
+const fs_1 = __importDefault(require("fs"));
+exports.INDEX_DTS = fs_1.default.readFileSync(`${__dirname}/index.d.ts`, 'utf-8');
+var HttpCode;
+(function (HttpCode) {
+    HttpCode[HttpCode["OK"] = 200] = "OK";
+    HttpCode[HttpCode["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpCode[HttpCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpCode[HttpCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpCode[HttpCode["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpCode[HttpCode["CONFLICT"] = 409] = "CONFLICT";
+    HttpCode[HttpCode["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpCode[HttpCode["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+})(HttpCode = exports.HttpCode || (exports.HttpCode = {}));

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+export declare const logger: import("pino").Logger<{
+    level: string;
+    messageKey: string;
+    formatters: {
+        level(label: string): {
+            level: string;
+        };
+    };
+}>;

package/dist/logger.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const pino_1 = __importDefault(require("pino"));
+exports.logger = (0, pino_1.default)({
+    level: (_a = process.env.LOG_LEVEL) !== null && _a !== void 0 ? _a : 'info',
+    messageKey: 'message',
+    formatters: {
+        level(label) {
+            return { level: label };
+        },
+    },
+});

package/dist/rawHeaders.d.ts

@@ -0,0 +1,11 @@
+import type * as Stuntman from '.';
+export declare class RawHeaders extends Array<string> implements Stuntman.RawHeadersInterface {
+    get(name: string): string | undefined;
+    has(name: string, value?: string): boolean;
+    set(name: string, value: string): void;
+    add(name: string, value: string): void;
+    remove(name: string): void;
+    toHeaderPairs(): readonly [string, string][];
+    static fromHeaderPairs(headerPairs: [string, string][]): RawHeaders;
+    static toHeaderPairs(rawHeaders: string[]): readonly [string, string][];
+}

package/dist/rawHeaders.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawHeaders = void 0;
+class RawHeaders extends Array {
+    get(name) {
+        const headers = this.toHeaderPairs();
+        const matchingHeaders = headers.filter((h) => h[0].toLowerCase() === name.toLowerCase());
+        if (matchingHeaders.length === 0) {
+            return;
+        }
+        if (matchingHeaders.length === 1) {
+            return matchingHeaders[0][1];
+        }
+        throw new Error('Multiple headers with same name. Manipulate rawHeaders instead');
+    }
+    has(name, value) {
+        const foundValue = this.get(name);
+        if (value === undefined) {
+            return foundValue !== undefined;
+        }
+        return foundValue === value;
+    }
+    set(name, value) {
+        let foundHeaders = 0;
+        for (let headerIndex = 0; headerIndex < this.length; headerIndex += 2) {
+            if (this[headerIndex].toLowerCase() === name.toLowerCase()) {
+                this[headerIndex + 1] = value;
+                ++foundHeaders;
+            }
+        }
+        if (foundHeaders === 0) {
+            return this.add(name, value);
+        }
+        if (foundHeaders > 1) {
+            throw new Error('Multiple headers with same name. Manipulate rawHeaders instead');
+        }
+    }
+    add(name, value) {
+        this.push(name);
+        this.push(value);
+    }
+    remove(name) {
+        const headersCopy = [...this];
+        let foundHeaders = 0;
+        for (let headerIndex = 0; headerIndex < headersCopy.length; headerIndex += 2) {
+            if (this[headerIndex - foundHeaders * 2].toLowerCase() === name.toLowerCase()) {
+                delete this[headerIndex];
+                delete this[headerIndex];
+                ++foundHeaders;
+            }
+        }
+        if (foundHeaders > 1) {
+            throw new Error('Multiple headers with same name. Manipulate rawHeaders instead');
+        }
+    }
+    toHeaderPairs() {
+        return RawHeaders.toHeaderPairs(this);
+    }
+    static fromHeaderPairs(headerPairs) {
+        return new RawHeaders(...headerPairs.flatMap((x) => x));
+    }
+    static toHeaderPairs(rawHeaders) {
+        const headers = new Array();
+        for (let headerIndex = 0; headerIndex < rawHeaders.length; headerIndex += 2) {
+            headers.push([rawHeaders[headerIndex], rawHeaders[headerIndex + 1]]);
+        }
+        return headers;
+    }
+}
+exports.RawHeaders = RawHeaders;

package/dist/stringify.d.ts

@@ -0,0 +1 @@
+export declare const stringify: (obj: any) => string;

package/dist/stringify.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = void 0;
+const stringify = (obj) => JSON.stringify(obj, (key, value) => {
+    if (typeof value === 'function' || value instanceof RegExp) {
+        return value.toString();
+    }
+    return value;
+});
+exports.stringify = stringify;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@stuntman/shared",
+  "version": "0.1.0",
+  "description": "Stuntman - HTTP proxy / mock shared types and utils",
+  "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": {
+    "config": "3.3.9",
+    "defaults": "1.0.4",
+    "pino": "8.10.0"
+  },
+  "devDependencies": {
+    "@types/config": "3.3.0",
+    "@types/defaults": "1.0.3"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "clean": "rm -fr dist",
+    "build": "tsc",
+    "lint": "prettier --check . && eslint . --ext ts",
+    "lint:fix": "prettier --write ./src && eslint ./src --ext ts --fix"
+  }
+}

package/src/appError.ts

@@ -0,0 +1,30 @@
+import type * as Stuntman from '.';
+
+export interface AppErrorInterface {
+    name?: string;
+    httpCode: Stuntman.HttpCode;
+    message: string;
+    isOperational?: boolean;
+}
+
+export class AppError extends Error {
+    public readonly name: string;
+    public readonly httpCode: Stuntman.HttpCode;
+    public readonly uuid?: string;
+    public readonly isOperational: boolean = true;
+
+    constructor(args: AppErrorInterface) {
+        super(args.message);
+
+        Object.setPrototypeOf(this, new.target.prototype);
+
+        this.name = args.name || 'Error';
+        this.httpCode = args.httpCode;
+
+        if (args.isOperational !== undefined) {
+            this.isOperational = args.isOperational;
+        }
+
+        Error.captureStackTrace(this);
+    }
+}

package/src/config.ts

@@ -0,0 +1,48 @@
+import {
+    RecursivePartial,
+    ServerConfig,
+    DEFAULT_API_PORT,
+    DEFAULT_MOCK_DOMAIN,
+    EXTERNAL_DNS,
+    DEFAULT_MOCK_PORT,
+    DEFAULT_PROXY_TIMEOUT,
+    DEFAULT_CACHE_MAX_ENTRIES,
+    DEFAULT_CACHE_MAX_SIZE,
+    DEFAULT_CACHE_TTL,
+} from '.';
+import config from 'config';
+import defaults from 'defaults';
+
+// TODO safeguards & defaults
+
+const defaultConfig: ServerConfig = {
+    api: {
+        disabled: false,
+        port: DEFAULT_API_PORT,
+    },
+    mock: {
+        domain: DEFAULT_MOCK_DOMAIN,
+        externalDns: EXTERNAL_DNS,
+        port: DEFAULT_MOCK_PORT,
+        timeout: DEFAULT_PROXY_TIMEOUT,
+    },
+    storage: {
+        traffic: {
+            limitCount: DEFAULT_CACHE_MAX_ENTRIES,
+            limitSize: DEFAULT_CACHE_MAX_SIZE,
+            ttl: DEFAULT_CACHE_TTL
+        },
+    },
+    webgui: {
+        disabled: false,
+    },
+};
+
+let configFromFile: RecursivePartial<ServerConfig> = {};
+try {
+    configFromFile = config.get<RecursivePartial<ServerConfig>>('stuntman');
+} catch (error) {
+    console.warn('unable to find correct config');
+}
+
+export const serverConfig = defaults(configFromFile, defaultConfig) as ServerConfig;

package/src/constants.ts

@@ -0,0 +1,14 @@
+export const DEFAULT_PROXY_TIMEOUT = 60000;
+export const DEFAULT_RULE_PRIORITY = 100;
+export const DEFAULT_MOCK_PORT = 2015;
+export const DEFAULT_API_PORT = 1985;
+export const DEFAULT_CACHE_MAX_ENTRIES = 500;
+export const DEFAULT_CACHE_MAX_SIZE = 500 * 1024 * 1024;
+export const DEFAULT_CACHE_TTL = 1000 * 60 * 60;
+export const DEFAULT_MOCK_DOMAIN = 'stuntman';
+export const DEFAULT_RULE_TTL_SECONDS = 60 * 10;
+export const MIN_RULE_TTL_SECONDS = 10;
+export const MAX_RULE_TTL_SECONDS = 60 * 60;
+export const CATCH_ALL_RULE_PRIORITY = Infinity;
+export const CATCH_RULE_NAME = 'internal/catch-all';
+export const EXTERNAL_DNS = ['8.8.8.8', '1.1.1.1'];

package/src/index.ts

@@ -0,0 +1,199 @@
+/* eslint-disable @typescript-eslint/ban-types */
+export * from './constants';
+export * from './appError';
+export * from './logger';
+export * from './stringify';
+export * from './rawHeaders';
+export * from './config';
+
+import fs from 'fs';
+export const INDEX_DTS = fs.readFileSync(`${__dirname}/index.d.ts`, 'utf-8');
+
+type NonObject = string | number | boolean | symbol | undefined | null | any[];
+
+interface SerializableTypesRecord<T> {
+    [k: string | number]: T;
+}
+
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+
+type SerializableTypes =
+    | string
+    | number
+    | boolean
+    | undefined
+    | null
+    | RegExp
+    | SerializableTypes[]
+    | SerializableTypesRecord<SerializableTypes>;
+
+export enum HttpCode {
+    OK = 200,
+    NO_CONTENT = 204,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    NOT_FOUND = 404,
+    CONFLICT = 409,
+    UNPROCESSABLE_ENTITY = 422,
+    INTERNAL_SERVER_ERROR = 500,
+}
+
+export type LocalVariables = Record<string, SerializableTypes>;
+
+export type RuleMatchResult = boolean | { result: boolean; enableRuleIds?: string[]; disableRuleIds?: string[] };
+
+export type RemotableFunction<T extends Function> = {
+    localFn: T;
+    localVariables?: LocalVariables;
+};
+
+export type SerializedRemotableFunction = {
+    localFn: string;
+    variable?: string;
+    remoteFn: string;
+};
+
+type WithRemotableFunctions<Type> = {
+    [PropertyKey in keyof Type]: Extract<Type[PropertyKey], Function> extends never
+        ? Exclude<Type[PropertyKey], NonObject> extends never
+            ? Type[PropertyKey]
+            : WithRemotableFunctions<Exclude<Type[PropertyKey], NonObject>>
+        : Exclude<Type[PropertyKey], Function> | RemotableFunction<Extract<Type[PropertyKey], Function>>;
+};
+
+export type WithSerializedFunctions<Type> = {
+    [PropertyKey in keyof Type]: Extract<Type[PropertyKey], RemotableFunction<Function>> extends never
+        ? Exclude<Type[PropertyKey], NonObject> extends never
+            ? Type[PropertyKey]
+            : WithSerializedFunctions<Exclude<Type[PropertyKey], NonObject>>
+        : Exclude<Type[PropertyKey], RemotableFunction<Function>> | SerializedRemotableFunction;
+};
+
+export interface RawHeadersInterface extends Array<string> {
+    get: (name: string) => string | undefined;
+    set: (name: string, value: string) => void;
+    has: (name: string, value?: string) => boolean;
+    add: (name: string, value: string) => void;
+    remove: (name: string) => void;
+    toHeaderPairs: () => readonly [string, string][];
+}
+
+export type BaseRequest = {
+    rawHeaders: RawHeadersInterface;
+    url: string;
+    body?: any;
+    method: string;
+};
+
+export type Request = BaseRequest & {
+    id: string;
+    timestamp: number;
+    gqlBody?: GQLRequestBody;
+};
+
+export type Response = {
+    rawHeaders?: RawHeadersInterface;
+    status?: number;
+    body?: any;
+    timestamp?: number;
+};
+
+export type LogEntry = {
+    originalRequest: Request;
+    labels?: string[];
+    mockRuleId?: string;
+    originalResponse?: Response;
+    modifiedRequest?: Request;
+    modifiedResponse?: Response;
+};
+
+export type RuleMatchFunction = (request: Request) => RuleMatchResult;
+export type RequestManipulationFn = (request: Request) => Request;
+export type ResponseManipulationFn = (request: Request, response: Response) => Response;
+export type ResponseGenerationFn = (request: Request) => Response;
+
+export type Actions =
+    | {
+          mockResponse: Response | ResponseGenerationFn;
+          modifyRequest?: undefined;
+          modifyResponse?: undefined;
+      }
+    | {
+          mockResponse?: undefined;
+          modifyRequest?: RequestManipulationFn;
+          modifyResponse?: ResponseManipulationFn;
+      };
+
+export type Rule = {
+    id: string;
+    priority?: number;
+    matches: RuleMatchFunction; // function for picking request to process
+    labels?: string[]; // groupping req/res pairs for searching later e.g. ['exoclick', 'testId123']
+    actions?: Actions;
+    disableAfterUse?: boolean | number; // disable after rule is triggered n-times
+    removeAfterUse?: boolean | number; // disable after rule is triggered n-times
+    ttlSeconds: number;
+    storeTraffic?: boolean;
+    isEnabled?: boolean;
+};
+
+export type DeployedRule = Omit<Rule, 'disableAfterUse' | 'removeAfterUse' | 'ttlSeconds'>;
+
+export type SerializableRule = WithRemotableFunctions<Rule>;
+export type SerializedRule = WithSerializedFunctions<SerializableRule>;
+
+export type LiveRule = Rule & {
+    counter: number;
+    createdTimestamp: number;
+};
+
+export type GQLRequestBody = {
+    operationName: string;
+    variables?: any;
+    query: string;
+    type: 'query' | 'mutation';
+    methodName?: string;
+};
+
+export type WebGuiConfig = {
+    disabled: boolean;
+};
+
+export type ApiConfig = {
+    port: number;
+    disabled: boolean;
+};
+
+export type ClientConfig = {
+    protocol?: 'http' | 'https';
+    host?: string;
+    port?: number;
+    timeout?: number;
+};
+
+export type MockConfig = {
+    domain: string;
+    port: number;
+    httpsPort?: number;
+    httpsKey?: string;
+    httpsCert?: string;
+    timeout: number;
+    externalDns: string[];
+};
+
+export type StorageConfig = {
+    limitCount: number;
+    limitSize: number;
+    ttl: number;
+};
+
+export type ServerConfig = {
+    webgui: WebGuiConfig;
+    api: ApiConfig;
+    mock: MockConfig;
+    storage: {
+        traffic: StorageConfig;
+    };
+};

package/src/logger.ts

@@ -0,0 +1,11 @@
+import pino from 'pino';
+
+export const logger = pino({
+    level: process.env.LOG_LEVEL ?? 'info',
+    messageKey: 'message',
+    formatters: {
+        level(label) {
+            return { level: label };
+        },
+    },
+});

package/src/rawHeaders.ts

@@ -0,0 +1,75 @@
+import type * as Stuntman from '.';
+
+export class RawHeaders extends Array<string> implements Stuntman.RawHeadersInterface {
+    get(name: string): string | undefined {
+        const headers = this.toHeaderPairs();
+        const matchingHeaders = headers.filter((h) => h[0].toLowerCase() === name.toLowerCase());
+        if (matchingHeaders.length === 0) {
+            return;
+        }
+        if (matchingHeaders.length === 1) {
+            return matchingHeaders[0][1];
+        }
+        throw new Error('Multiple headers with same name. Manipulate rawHeaders instead');
+    }
+
+    has(name: string, value?: string): boolean {
+        const foundValue = this.get(name);
+        if (value === undefined) {
+            return foundValue !== undefined;
+        }
+        return foundValue === value;
+    }
+
+    set(name: string, value: string): void {
+        let foundHeaders = 0;
+        for (let headerIndex = 0; headerIndex < this.length; headerIndex += 2) {
+            if (this[headerIndex].toLowerCase() === name.toLowerCase()) {
+                this[headerIndex + 1] = value;
+                ++foundHeaders;
+            }
+        }
+        if (foundHeaders === 0) {
+            return this.add(name, value);
+        }
+        if (foundHeaders > 1) {
+            throw new Error('Multiple headers with same name. Manipulate rawHeaders instead');
+        }
+    }
+
+    add(name: string, value: string): void {
+        this.push(name);
+        this.push(value);
+    }
+
+    remove(name: string): void {
+        const headersCopy = [...this];
+        let foundHeaders = 0;
+        for (let headerIndex = 0; headerIndex < headersCopy.length; headerIndex += 2) {
+            if (this[headerIndex - foundHeaders * 2].toLowerCase() === name.toLowerCase()) {
+                delete this[headerIndex];
+                delete this[headerIndex];
+                ++foundHeaders;
+            }
+        }
+        if (foundHeaders > 1) {
+            throw new Error('Multiple headers with same name. Manipulate rawHeaders instead');
+        }
+    }
+
+    toHeaderPairs(): readonly [string, string][] {
+        return RawHeaders.toHeaderPairs(this);
+    }
+
+    static fromHeaderPairs(headerPairs: [string, string][]): RawHeaders {
+        return new RawHeaders(...headerPairs.flatMap((x) => x));
+    }
+
+    static toHeaderPairs(rawHeaders: string[]): readonly [string, string][] {
+        const headers = new Array<[string, string]>();
+        for (let headerIndex = 0; headerIndex < rawHeaders.length; headerIndex += 2) {
+            headers.push([rawHeaders[headerIndex], rawHeaders[headerIndex + 1]]);
+        }
+        return headers;
+    }
+}

package/src/stringify.ts

@@ -0,0 +1,7 @@
+export const stringify = (obj: any) =>
+    JSON.stringify(obj, (key, value) => {
+        if (typeof value === 'function' || value instanceof RegExp) {
+            return value.toString();
+        }
+        return value;
+    });

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "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"
+    }
+}