@stuntman/client 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/apiClient.d.ts

@@ -0,0 +1,22 @@
+import type * as Stuntman from '@stuntman/shared';
+type ClientOptions = {
+    protocol?: 'http' | 'https';
+    host?: string;
+    port?: number;
+    timeout?: number;
+};
+export declare class Client {
+    private options;
+    private get baseUrl();
+    constructor(options?: ClientOptions);
+    private fetch;
+    getRules(): Promise<Stuntman.LiveRule[]>;
+    getRule(id: string): Promise<Stuntman.LiveRule>;
+    disableRule(id: string): Promise<void>;
+    enableRule(id: string): Promise<void>;
+    removeRule(id: string): Promise<void>;
+    addRule(rule: Stuntman.SerializableRule): Promise<Stuntman.Rule>;
+    getTraffic(rule: Stuntman.Rule): Promise<Record<string, Stuntman.LogEntry>>;
+    getTraffic(ruleIdOrLabel: string): Promise<Record<string, Stuntman.LogEntry>>;
+}
+export {};

package/dist/apiClient.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
+const clientError_1 = require("./clientError");
+const shared_1 = require("@stuntman/shared");
+const SERIALIZE_JAVASCRIPT_OPTIONS = {
+    unsafe: true,
+    ignoreFunction: true,
+};
+const getFunctionParams = (func) => {
+    const funstr = func.toString();
+    const params = funstr.slice(funstr.indexOf('(') + 1, funstr.indexOf(')')).match(/([^\s,]+)/g) || new Array();
+    if (params.includes('=')) {
+        throw new Error('default argument values are not supported');
+    }
+    return params;
+};
+const serializeApiFunction = (fn, variables) => {
+    const variableInitializer = [];
+    const functionParams = getFunctionParams(fn);
+    if (variables) {
+        for (const varName of Object.keys(variables)) {
+            let varValue = variables[varName];
+            if (varValue === undefined || varValue === null || typeof varValue === 'number' || typeof varValue === 'boolean') {
+                varValue = `${varValue}`;
+            }
+            else if (typeof varValue === 'string') {
+                varValue = `${(0, serialize_javascript_1.default)(variables[varName], SERIALIZE_JAVASCRIPT_OPTIONS)}`;
+            }
+            else {
+                varValue = `eval('(${(0, serialize_javascript_1.default)(variables[varName], SERIALIZE_JAVASCRIPT_OPTIONS).replace(/'/g, "\\'")})')`;
+            }
+            variableInitializer.push(`const ${varName} = ${varValue};`);
+        }
+    }
+    const functionString = fn.toString();
+    const serializedHeader = `return ((${functionParams.map((_param, index) => `____arg${index}`).join(',')}) => {`;
+    const serializedParams = `${functionParams
+        .map((_param, index) => `const ${functionParams[index]} = ____arg${index};`)
+        .join('\n')}`;
+    const serializedVariables = `${variableInitializer.join('\n')}`;
+    // prettier-ignore
+    const serializedFunction = `return (${functionString.substring(0, functionString.indexOf('('))}()${functionString.substring(functionString.indexOf(')') + 1)})(); })(${functionParams.map((_param, index) => `____arg${index}`).join(',')})`;
+    if (!serializedParams && !serializedVariables) {
+        return `${serializedHeader}${serializedFunction}`;
+    }
+    return [serializedHeader, serializedParams, serializedVariables, serializedFunction].filter((x) => !!x).join('\n');
+};
+const keysOf = (obj) => {
+    return Array.from(Object.keys(obj));
+};
+const serializeRemotableFunctions = (obj) => {
+    const objectKeys = keysOf(obj);
+    if (!objectKeys || objectKeys.length === 0) {
+        return obj;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const output = {};
+    for (const key of objectKeys) {
+        if (typeof obj[key] === 'object') {
+            if ('localFn' in obj[key]) {
+                const remotableFunction = obj[key];
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                output[key] = {
+                    remoteFn: serializeApiFunction(remotableFunction.localFn, remotableFunction.localVariables),
+                    localFn: remotableFunction.localFn.toString(),
+                    localVariables: (0, serialize_javascript_1.default)(remotableFunction.localVariables, SERIALIZE_JAVASCRIPT_OPTIONS),
+                };
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                output[key] = serializeRemotableFunctions(obj[key]);
+            }
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            output[key] = obj[key];
+        }
+    }
+    return output;
+};
+class Client {
+    get baseUrl() {
+        return `${this.options.protocol}://${this.options.host}${this.options.port ? `:${this.options.port}` : ''}`;
+    }
+    constructor(options) {
+        this.options = {
+            ...options,
+            timeout: (options === null || options === void 0 ? void 0 : options.timeout) || 60000,
+            host: (options === null || options === void 0 ? void 0 : options.host) || 'localhost',
+            protocol: (options === null || options === void 0 ? void 0 : options.protocol) || 'http',
+            port: (options === null || options === void 0 ? void 0 : options.port) || (options === null || options === void 0 ? void 0 : options.protocol) ? (options.protocol === 'https' ? 443 : 80) : shared_1.DEFAULT_API_PORT,
+        };
+    }
+    async fetch(url, init) {
+        var _a;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort();
+        }, this.options.timeout);
+        try {
+            const response = await fetch(url, { ...init, signal: (_a = init === null || init === void 0 ? void 0 : init.signal) !== null && _a !== void 0 ? _a : controller.signal });
+            if (!response.ok) {
+                const text = await response.text();
+                let json;
+                try {
+                    json = JSON.parse(text);
+                }
+                catch (kiss) {
+                    // and swallow
+                }
+                if ('error' in json) {
+                    throw new clientError_1.ClientError(json.error);
+                }
+                throw new Error(`Unexpected errror: ${text}`);
+            }
+            return response;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async getRules() {
+        const response = await this.fetch(`${this.baseUrl}/rules`);
+        return response.json();
+    }
+    async getRule(id) {
+        const response = await this.fetch(`${this.baseUrl}/rule/${encodeURIComponent(id)}`);
+        return response.json();
+    }
+    async disableRule(id) {
+        await this.fetch(`${this.baseUrl}/rule/${encodeURIComponent(id)}/disable`);
+    }
+    async enableRule(id) {
+        await this.fetch(`${this.baseUrl}/rule/${encodeURIComponent(id)}/enable`);
+    }
+    async removeRule(id) {
+        await this.fetch(`${this.baseUrl}/rule/${encodeURIComponent(id)}/remove`);
+    }
+    async addRule(rule) {
+        const serializedRule = serializeRemotableFunctions(rule);
+        const response = await this.fetch(`${this.baseUrl}/rule`, {
+            method: 'POST',
+            body: JSON.stringify(serializedRule),
+            headers: { 'content-type': 'application/json' },
+        });
+        return response.json();
+    }
+    async getTraffic(ruleOrIdOrLabel) {
+        const ruleId = typeof ruleOrIdOrLabel === 'object' ? ruleOrIdOrLabel.id : ruleOrIdOrLabel;
+        const response = await this.fetch(`${this.baseUrl}/traffic${ruleId ? `/${encodeURIComponent(ruleId)}` : ''}`);
+        return response.json();
+    }
+}
+exports.Client = Client;

package/dist/clientError.d.ts

@@ -0,0 +1,18 @@
+import { AppError } from '@stuntman/shared';
+import type * as Stuntman from '@stuntman/shared';
+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 declare class ClientError extends AppError {
+    readonly originalStack?: string;
+    constructor(args: Stuntman.AppError & {
+        stack?: string;
+    });
+}

package/dist/clientError.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientError = exports.HttpCode = void 0;
+const shared_1 = require("@stuntman/shared");
+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 = {}));
+class ClientError extends shared_1.AppError {
+    constructor(args) {
+        super(args);
+        this.originalStack = args.stack;
+    }
+}
+exports.ClientError = ClientError;

package/dist/clientTestExample.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clientTestExample.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const apiClient_1 = require("./apiClient");
+const ruleBuilder_1 = require("./ruleBuilder");
+const client = new apiClient_1.Client();
+const uniqueQaUserEmail = 'unique_qa_email@example.com';
+const rule = (0, ruleBuilder_1.ruleBuilder)()
+    .limitedUse(2)
+    .onAnyRequest()
+    .withBodyJson('test', 'value')
+    .mockResponse({
+    localFn: (req) => {
+        if (JSON.parse(req.body).email !== uniqueQaUserEmail) {
+            return {
+                status: 500,
+            };
+        }
+        return { status: 201 };
+    },
+    localVariables: { uniqueQaUserEmail },
+});
+client.addRule(rule).then((x) => console.log(x));

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { Client as StuntmanClient } from './apiClient';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StuntmanClient = void 0;
+var apiClient_1 = require("./apiClient");
+Object.defineProperty(exports, "StuntmanClient", { enumerable: true, get: function () { return apiClient_1.Client; } });

package/dist/ruleBuilder.d.ts

@@ -0,0 +1,77 @@
+import type * as Stuntman from '@stuntman/shared';
+type KeyValueMatcher = string | RegExp | {
+    key: string;
+    value?: string | RegExp;
+};
+type ObjectValueMatcher = string | RegExp | number | boolean | null;
+type ObjectKeyValueMatcher = {
+    key: string;
+    value?: ObjectValueMatcher;
+};
+type GQLRequestMatcher = {
+    operationName?: string | RegExp;
+    variables?: ObjectKeyValueMatcher[];
+    query?: string | RegExp;
+    type?: 'query' | 'mutation';
+    methodName?: string | RegExp;
+};
+type MatchBuilderVariables = {
+    filter?: string | RegExp;
+    hostname?: string | RegExp;
+    pathname?: string | RegExp;
+    port?: number | string | RegExp;
+    searchParams?: KeyValueMatcher[];
+    headers?: KeyValueMatcher[];
+    bodyText?: string | RegExp | null;
+    bodyJson?: ObjectKeyValueMatcher[];
+    bodyGql?: GQLRequestMatcher;
+};
+declare class RuleBuilderBaseBase {
+    protected rule: Stuntman.SerializableRule;
+    protected _matchBuilderVariables: MatchBuilderVariables;
+    constructor(rule?: Stuntman.SerializableRule, _matchBuilderVariables?: MatchBuilderVariables);
+}
+declare class RuleBuilderBase extends RuleBuilderBaseBase {
+    limitedUse(hitCount: number): this;
+    singleUse(): this;
+    storeTraffic(): this;
+    disabled(): void;
+}
+declare class RuleBuilder extends RuleBuilderBase {
+    raisePriority(by?: number): this;
+    decreasePriority(by?: number): this;
+    customTtl(ttlSeconds: number): this;
+    customId(id: string): this;
+    onRequestTo(filter: string | RegExp): RuleBuilderInitialized;
+    onRequestToHostname(hostname: string | RegExp): RuleBuilderInitialized;
+    onRequestToPathname(pathname: string | RegExp): RuleBuilderInitialized;
+    onAnyRequest(): RuleBuilderInitialized;
+}
+declare class RuleBuilderInitialized extends RuleBuilderBase {
+    withHostname(hostname: string | RegExp): this;
+    withPathname(pathname: string | RegExp): this;
+    withPort(port: number | string | RegExp): this;
+    withSearchParam(key: string | RegExp): RuleBuilderInitialized;
+    withSearchParam(key: string, value?: string | RegExp): RuleBuilderInitialized;
+    withSearchParams(params: KeyValueMatcher[]): RuleBuilderInitialized;
+    withHeader(key: string | RegExp): RuleBuilderInitialized;
+    withHeader(key: string, value?: string | RegExp): RuleBuilderInitialized;
+    withHeaders(headers: KeyValueMatcher[]): RuleBuilderInitialized;
+    withBodyText(includes: string): RuleBuilderInitialized;
+    withBodyText(matches: RegExp): RuleBuilderInitialized;
+    withoutBody(): RuleBuilderInitialized;
+    withBodyJson(hasKey: string): RuleBuilderInitialized;
+    withBodyJson(hasKey: string, withValue: ObjectValueMatcher): RuleBuilderInitialized;
+    withBodyJson(matches: ObjectKeyValueMatcher): RuleBuilderInitialized;
+    withBodyGql(gqlMatcher: GQLRequestMatcher): RuleBuilderInitialized;
+    proxyPass(): Stuntman.SerializableRule;
+    mockResponse(staticResponse: Stuntman.Response): Stuntman.SerializableRule;
+    mockResponse(generationFunction: Stuntman.RemotableFunction<Stuntman.ResponseGenerationFn>): Stuntman.SerializableRule;
+    modifyRequest(modifyFunction: Stuntman.RemotableFunction<Stuntman.RequestManipulationFn>): RuleBuilderRequestInitialized;
+    modifyResponse(modifyFunction: Stuntman.RemotableFunction<Stuntman.ResponseManipulationFn>): Stuntman.SerializableRule;
+}
+declare class RuleBuilderRequestInitialized extends RuleBuilderBase {
+    modifyResponse(modifyFunction: Stuntman.RemotableFunction<Stuntman.ResponseManipulationFn>): Stuntman.SerializableRule;
+}
+export declare const ruleBuilder: () => RuleBuilder;
+export {};