@leyyo/http-mock 1.2.1 → 1.3.2

package/dist/request/index.types.d.ts

@@ -1,23 +1,60 @@
-import type { Request } from "express";
-import type { ResponseData } from "../response";
-import type { Arr } from "@leyyo/common";
-import type { HttpCookies, HttpData, HttpHeaders, HttpMethod, HttpParams, HttpQuery } from "../shared";
+import { Request } from "express";
+import { ResponseData } from "../response";
+import { Arr } from "@leyyo/common";
+import { HttpCookies, HttpData, HttpHeaders, HttpParams, HttpQuery } from "../event";
+import { HttpMethod } from "../enum";
 export interface RequestLocal {
 }
 export type RequestBody = Arr | HttpData | string | unknown;
 export type RequestErrorCallback = (error?: Error) => void;
+/**
+ * It's used for bulk http calls
+ * */
 export interface MockServiceRequest<B extends RequestBody = RequestBody> {
+    /**
+     * Http method
+     * */
     method: HttpMethod;
+    /**
+     * Local path
+     * */
     url: string;
+    /**
+     * Request payload
+     * */
     body?: B;
+    /**
+     * Custom headers
+     * */
     headers?: HttpHeaders;
+    /**
+     * Client cookies
+     * */
     cookies?: HttpCookies;
+    /**
+     * Server cookies
+     * */
     signedCookies?: HttpCookies;
 }
+/**
+ * Http mock request, it extends express request
+ * */
 export interface MockRequestLike<B extends RequestBody = RequestBody, L extends RequestLocal = RequestLocal> extends Request<HttpParams, B, ResponseData, HttpQuery, L> {
+    /**
+     * Indicates that it's fake/mock request
+     * */
     readonly isFake?: boolean;
+    /**
+     * Temporary local storage
+     * */
     readonly locals?: L;
+    /**
+     * Get query parameter
+     * */
     param(name: string, defaultValue?: any): string;
+    /**
+     * Custom properties
+     * */
     [another: string]: unknown;
 }
 export interface PipeOption {

package/dist/request/mock.request.d.ts

@@ -1,123 +1,249 @@
-import type { Application, MediaType, NextFunction, Request, Response } from "express";
-import type { Socket } from "net";
-import type { IncomingHttpHeaders } from "http";
-import type RangeParser from "range-parser";
-import type { MockRequestLike, MockServiceRequest, PipeOption, RequestBody, RequestErrorCallback, RequestLocal } from "./index.types";
-import type { _StreamAbort, _StreamBool, _StreamCompose, _StreamGeneric, _StreamIterator, _StreamReduce, _StreamVoid, HttpCookies, HttpMethod, HttpParams, HttpProtocol, HttpQuery, HttpStatus } from "../shared";
-import { HttpEvent } from '../shared';
-import type { Dict, Fnc, OneOrMore } from "@leyyo/common";
-import type { ArrayOptions, Readable } from "node:stream";
+import { Application, MediaType, NextFunction, Request, Response } from "express";
+import { Socket } from "net";
+import { IncomingHttpHeaders } from "http";
+import RangeParser from "range-parser";
+import { MockRequestLike, MockServiceRequest, PipeOption, RequestBody, RequestErrorCallback, RequestLocal } from "./index.types";
+import { _StreamAbort, _StreamBool, _StreamCompose, _StreamGeneric, _StreamIterator, _StreamReduce, _StreamVoid, HttpCookies, HttpEvent, HttpParams, HttpQuery } from "../event";
+import { Dict, Fnc, HttpStatus, OneOrMore } from "@leyyo/common";
+import { ArrayOptions, Readable } from "node:stream";
+import { HttpMethod, HttpProtocol } from "../enum";
 export declare class MockRequest<B extends RequestBody = RequestBody, L extends RequestLocal = RequestLocal> extends HttpEvent<Request> implements MockRequestLike<B, L> {
+    /** @inheritDoc */
     readonly isFake: boolean;
+    /** @inheritDoc */
     readonly locals: L;
+    /** @inheritDoc */
     [another: string]: unknown;
-    static setFirstOrigin(origin: Request): void;
-    static get firstOrigin(): Request;
+    /**
+     * Constructor
+     *
+     * @param {MockServiceRequest} service - for bulk request
+     * @param {Request} origin - first real request
+     * @param {object} custom - custom values
+     * */
     constructor(service?: MockServiceRequest<B>, origin?: Request, custom?: Dict);
+    /** @inheritDoc*/
     accepted: MediaType[];
+    /** @inheritDoc*/
     readonly protocol: HttpProtocol;
+    /** @inheritDoc*/
     readonly secure: boolean;
+    /** @inheritDoc*/
     readonly ip: string;
+    /** @inheritDoc*/
     readonly ips: string[];
+    /** @inheritDoc*/
     readonly subdomains: string[];
+    /** @inheritDoc*/
     readonly path: string;
+    /** @inheritDoc*/
     readonly host: string;
+    /** @inheritDoc*/
     readonly hostname: string;
+    /** @inheritDoc*/
     readonly httpVersion: string;
+    /** @inheritDoc*/
     readonly httpVersionMajor: number;
+    /** @inheritDoc*/
     readonly httpVersionMinor: number;
+    /** @inheritDoc*/
     readonly fresh: boolean;
+    /** @inheritDoc*/
     readonly stale: boolean;
+    /** @inheritDoc*/
     readonly xhr: boolean;
+    /** @inheritDoc*/
     body: RequestBody;
+    /** @inheritDoc*/
     cookies: any;
+    /** @inheritDoc*/
     method: HttpMethod;
+    /** @inheritDoc*/
     params: HttpParams;
+    /** @inheritDoc*/
     query: HttpQuery;
+    /** @inheritDoc*/
     route: any;
+    /** @inheritDoc*/
     signedCookies: HttpCookies;
+    /** @inheritDoc*/
     originalUrl: string;
+    /** @inheritDoc*/
     url: string;
+    /** @inheritDoc*/
     baseUrl: string;
+    /** @inheritDoc*/
     app: Application;
+    /** @inheritDoc*/
     res?: Response<unknown, L>;
+    /** @inheritDoc*/
     next?: NextFunction;
+    /** @inheritDoc*/
     headers: IncomingHttpHeaders;
+    /** @inheritDoc*/
     is(t: OneOrMore<string>): string | false | null;
+    /** @inheritDoc*/
     get(n: "set-cookie"): string[] | undefined;
+    /** @inheritDoc*/
     get(n: string): string | undefined;
+    /** @inheritDoc*/
     header(n: "set-cookie"): string[] | undefined;
+    /** @inheritDoc*/
     header(n: string): string | undefined;
+    /** @inheritDoc*/
     accepts(): string[];
+    /** @inheritDoc*/
     accepts(t: string): string | false;
+    /** @inheritDoc*/
     accepts(t: string[]): string | false;
+    /** @inheritDoc*/
     accepts(...t: string[]): string | false;
+    /** @inheritDoc*/
     acceptsCharsets(): string[];
+    /** @inheritDoc*/
     acceptsCharsets(c: string): string | false;
+    /** @inheritDoc*/
     acceptsCharsets(c: string[]): string | false;
+    /** @inheritDoc*/
     acceptsCharsets(...c: string[]): string | false;
+    /** @inheritDoc*/
     acceptsEncodings(): string[];
+    /** @inheritDoc*/
     acceptsEncodings(e: string): string | false;
+    /** @inheritDoc*/
     acceptsEncodings(e: string[]): string | false;
+    /** @inheritDoc*/
     acceptsEncodings(...e: string[]): string | false;
+    /** @inheritDoc*/
     acceptsLanguages(): string[];
+    /** @inheritDoc*/
     acceptsLanguages(l: string): string | false;
+    /** @inheritDoc*/
     acceptsLanguages(l: string[]): string | false;
+    /** @inheritDoc*/
     acceptsLanguages(...l: string[]): string | false;
+    /** @inheritDoc*/
     range(s: number, o?: RangeParser.Options): RangeParser.Ranges | RangeParser.Result | undefined;
+    /** @inheritDoc*/
     aborted: boolean;
+    /** @inheritDoc*/
     complete: boolean;
+    /** @inheritDoc*/
     statusCode: HttpStatus | undefined;
+    /** @inheritDoc*/
     statusMessage: string | undefined;
+    /** @inheritDoc*/
     socket: Socket;
+    /** @inheritDoc*/
     headersDistinct: NodeJS.Dict<string[]>;
+    /** @inheritDoc*/
     rawHeaders: string[];
+    /** @inheritDoc*/
     trailers: Record<string, string>;
+    /** @inheritDoc*/
     rawTrailers: string[];
+    /** @inheritDoc*/
     trailersDistinct: NodeJS.Dict<string[]>;
+    /** @inheritDoc*/
     get connection(): Socket;
+    /** @inheritDoc*/
     destroy(_e?: Error): this;
+    /** @inheritDoc*/
     setTimeout(_m: number, _c?: Fnc): this;
+    /** @inheritDoc*/
     [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+    /** @inheritDoc*/
     [Symbol.asyncDispose](): Promise<void>;
+    /** @inheritDoc*/
     readonly closed: boolean;
+    /** @inheritDoc*/
     readonly errored: Error;
+    /** @inheritDoc*/
     destroyed: boolean;
+    /** @inheritDoc*/
     readonly readableDidRead: boolean;
+    /** @inheritDoc*/
     readonly readableEncoding: BufferEncoding | null;
+    /** @inheritDoc*/
     readonly readableEnded: boolean;
+    /** @inheritDoc*/
     readonly readableAborted: boolean;
+    /** @inheritDoc*/
     readonly readableFlowing: boolean | null;
+    /** @inheritDoc*/
     readonly readableHighWaterMark: number;
+    /** @inheritDoc*/
     readonly readableLength: number;
+    /** @inheritDoc*/
     readonly readableObjectMode: boolean;
+    /** @inheritDoc*/
     readable: boolean;
+    /** @inheritDoc*/
     _construct(_c: RequestErrorCallback): void;
+    /** @inheritDoc*/
     _destroy(_e: Error | null, _c: RequestErrorCallback): void;
+    /** @inheritDoc*/
     _read(_s: number): void;
+    /** @inheritDoc*/
     read(_s: number | undefined): string | Buffer;
+    /** @inheritDoc*/
     push(_c: any, _e?: BufferEncoding): boolean;
+    /** @inheritDoc*/
     isPaused(): boolean;
+    /** @inheritDoc*/
     resume(): this;
+    /** @inheritDoc*/
     pause(): this;
+    /** @inheritDoc*/
     pipe<T extends NodeJS.WritableStream>(_d: T, _o?: PipeOption): T;
+    /** @inheritDoc*/
     setEncoding(_e: BufferEncoding): this;
+    /** @inheritDoc*/
     unpipe(_d?: NodeJS.WritableStream): this;
+    /** @inheritDoc*/
     unshift(_c: string | Uint8Array, _e?: BufferEncoding): void;
+    /** @inheritDoc*/
     wrap(_s: NodeJS.ReadableStream): this;
+    /** @inheritDoc*/
     asIndexedPairs(_o: _StreamAbort | undefined): Readable;
+    /** @inheritDoc*/
     compose<T extends NodeJS.ReadableStream>(_s: _StreamCompose | Iterable<T> | AsyncIterable<T> | T, _o: _StreamAbort | undefined): T;
+    /** @inheritDoc*/
     drop(_l: number, _o: _StreamAbort | undefined): Readable;
+    /** @inheritDoc*/
     every(_f: _StreamBool, _o: ArrayOptions | undefined): Promise<boolean>;
+    /** @inheritDoc*/
     filter(_f: _StreamBool, _o: ArrayOptions | undefined): Readable;
+    /** @inheritDoc*/
     find<T>(_f: _StreamGeneric<T>, _o: ArrayOptions | undefined): Promise<T | undefined>;
+    /** @inheritDoc*/
     flatMap(_f: _StreamGeneric<any>, _o: ArrayOptions | undefined): Readable;
+    /** @inheritDoc*/
     forEach(_f: _StreamVoid, _o: ArrayOptions | undefined): Promise<void>;
+    /** @inheritDoc*/
     iterator(_o: _StreamIterator | undefined): NodeJS.AsyncIterator<any>;
+    /** @inheritDoc*/
     map(_f: _StreamGeneric<any>, _o: ArrayOptions | undefined): Readable;
+    /** @inheritDoc*/
     reduce<T>(_f: _StreamReduce<T>, _i: undefined, _o: _StreamAbort | undefined): Promise<T>;
+    /** @inheritDoc*/
     some(_f: _StreamBool, _o: ArrayOptions | undefined): Promise<boolean>;
+    /** @inheritDoc*/
     take(_l: number, _o: _StreamAbort | undefined): Readable;
+    /** @inheritDoc*/
     toArray(_o: _StreamAbort | undefined): Promise<any[]>;
+    /** @inheritDoc*/
     param(name: string, defaultValue?: any): string;
+    /**
+     * Set first real request
+     *
+     * @param {Request} origin
+     * */
+    static setFirstOrigin(origin: Request): void;
+    /**
+     * Get first real request
+     *
+     * @return {Request}
+     * */
+    static get firstOrigin(): Request;
 }

package/dist/request/mock.request.js

@@ -1,35 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockRequest = void 0;
-const shared_1 = require("../shared");
+const event_1 = require("../event");
 const common_1 = require("@leyyo/common");
-const common_2 = require("@leyyo/common");
 let _firstOrigin;
 // noinspection JSUnusedGlobalSymbols
-class MockRequest extends shared_1.HttpEvent {
+class MockRequest extends event_1.HttpEvent {
     // endregion property
-    // region static
-    static setFirstOrigin(origin) {
-        if (!_firstOrigin && origin) {
-            _firstOrigin = origin;
-            delete _firstOrigin.headers;
-            delete _firstOrigin.body;
-            delete _firstOrigin.cookies;
-            delete _firstOrigin.params;
-            _removePath(_firstOrigin);
-            try {
-                delete _firstOrigin.path;
-            }
-            catch (e) {
-                // nothing
-            }
-        }
-    }
-    static get firstOrigin() {
-        return _firstOrigin;
-    }
-    // endregion static
     // region constructor
+    /**
+     * Constructor
+     *
+     * @param {MockServiceRequest} service - for bulk request
+     * @param {Request} origin - first real request
+     * @param {object} custom - custom values
+     * */
     constructor(service, origin, custom) {
         super(origin);
         _attachOrigin(this, origin);
@@ -37,171 +22,243 @@ class MockRequest extends shared_1.HttpEvent {
         _attachCustom(this, custom);
         _checkRoute(this);
     }
+    /** @inheritDoc*/
     is(t) {
         var _a, _b;
         return (_b = (_a = this._origin) === null || _a === void 0 ? void 0 : _a.is(t)) !== null && _b !== void 0 ? _b : false;
     }
+    /** @inheritDoc*/
     get(n) {
         return this.header(n);
     }
+    /** @inheritDoc*/
     header(n) {
         return (typeof n === 'string') ? this.headers[n] : undefined;
     }
+    /** @inheritDoc*/
     accepts(...t) {
         var _a;
         return (_a = this._origin) === null || _a === void 0 ? void 0 : _a.accepts(...t);
     }
+    /** @inheritDoc*/
     acceptsCharsets(...c) {
         var _a;
         return (_a = this._origin) === null || _a === void 0 ? void 0 : _a.acceptsCharsets(...c);
     }
+    /** @inheritDoc*/
     acceptsEncodings(...e) {
         var _a;
         return (_a = this._origin) === null || _a === void 0 ? void 0 : _a.acceptsEncodings(...e);
     }
+    /** @inheritDoc*/
     acceptsLanguages(...l) {
         var _a;
         return (_a = this._origin) === null || _a === void 0 ? void 0 : _a.acceptsLanguages(...l);
     }
+    /** @inheritDoc*/
     range(s, o) {
         var _a, _b;
         return (_b = (_a = this._origin) === null || _a === void 0 ? void 0 : _a.range(s, o)) !== null && _b !== void 0 ? _b : -1;
     }
+    /** @inheritDoc*/
     get connection() {
         logger.warn('Should not be called', { fn: 'connection' });
         return this.socket;
     }
+    /** @inheritDoc*/
     destroy(_e) {
         logger.warn('Should not be called', { fn: 'destroy' });
         return this;
     }
+    /** @inheritDoc*/
     setTimeout(_m, _c) {
         logger.warn('Should not be called', { fn: 'setTimeout' });
         return this;
     }
     // endregion http
     // region stream
+    /** @inheritDoc*/
     [Symbol.asyncIterator]() {
         logger.warn('Should not be called', { fn: 'asyncIterator' });
         return this._origin ? this._origin[Symbol.asyncIterator]() : undefined;
     }
+    /** @inheritDoc*/
     [Symbol.asyncDispose]() {
         logger.warn('Should not be called', { fn: 'asyncDispose' });
-        return this._origin ? this._origin[Symbol.asyncDispose]() : (0, common_2.delay)(100);
+        return this._origin ? this._origin[Symbol.asyncDispose]() : (0, common_1.delay)(100);
     }
+    /** @inheritDoc*/
     _construct(_c) {
         logger.warn('Should not be called', { fn: '_construct' });
     }
+    /** @inheritDoc*/
     _destroy(_e, _c) {
         logger.warn('Should not be called', { fn: '_destroy' });
     }
+    /** @inheritDoc*/
     _read(_s) {
         logger.warn('Should not be called', { fn: '_read' });
     }
+    /** @inheritDoc*/
     read(_s) {
         logger.warn('Should not be called', { fn: 'read' });
         return undefined;
     }
+    /** @inheritDoc*/
     push(_c, _e) {
         logger.warn('Should not be called', { fn: 'push' });
         return false;
     }
+    /** @inheritDoc*/
     isPaused() {
         logger.warn('Should not be called', { fn: 'isPaused' });
         return false;
     }
+    /** @inheritDoc*/
     resume() {
         logger.warn('Should not be called', { fn: 'resume' });
         return this;
     }
+    /** @inheritDoc*/
     pause() {
         logger.warn('Should not be called', { fn: 'pause' });
         return this;
     }
+    /** @inheritDoc*/
     pipe(_d, _o) {
         logger.warn('Should not be called', { fn: 'pipe' });
         return undefined;
     }
+    /** @inheritDoc*/
     setEncoding(_e) {
         logger.warn('Should not be called', { fn: 'setEncoding' });
         return this;
     }
+    /** @inheritDoc*/
     unpipe(_d) {
         logger.warn('Should not be called', { fn: 'unpipe' });
         return this;
     }
+    /** @inheritDoc*/
     unshift(_c, _e) {
         logger.warn('Should not be called', { fn: 'unshift' });
     }
+    /** @inheritDoc*/
     wrap(_s) {
         logger.warn('Should not be called', { fn: 'wrap' });
         return this;
     }
+    /** @inheritDoc*/
     asIndexedPairs(_o) {
         logger.warn('Should not be called', { fn: 'asIndexedPairs' });
         return undefined;
     }
+    /** @inheritDoc*/
     compose(_s, _o) {
         logger.warn('Should not be called', { fn: 'compose' });
         return undefined;
     }
+    /** @inheritDoc*/
     drop(_l, _o) {
         logger.warn('Should not be called', { fn: 'drop' });
         return undefined;
     }
+    /** @inheritDoc*/
     every(_f, _o) {
         logger.warn('Should not be called', { fn: 'every' });
-        return (0, common_2.delay)(10, false);
+        return (0, common_1.delay)(10, false);
     }
+    /** @inheritDoc*/
     filter(_f, _o) {
         logger.warn('Should not be called', { fn: 'filter' });
         return undefined;
     }
+    /** @inheritDoc*/
     find(_f, _o) {
         logger.warn('Should not be called', { fn: 'find' });
-        return (0, common_2.delay)(10);
+        return (0, common_1.delay)(10);
     }
+    /** @inheritDoc*/
     flatMap(_f, _o) {
         logger.warn('Should not be called', { fn: 'flatMap' });
         return undefined;
     }
+    /** @inheritDoc*/
     forEach(_f, _o) {
         logger.warn('Should not be called', { fn: 'forEach' });
-        return (0, common_2.delay)(10);
+        return (0, common_1.delay)(10);
     }
+    /** @inheritDoc*/
     iterator(_o) {
         logger.warn('Should not be called', { fn: 'iterator' });
         return undefined;
     }
+    /** @inheritDoc*/
     map(_f, _o) {
         logger.warn('Should not be called', { fn: 'map' });
         return undefined;
     }
+    /** @inheritDoc*/
     reduce(_f, _i, _o) {
         logger.warn('Should not be called', { fn: 'reduce' });
-        return (0, common_2.delay)(10);
+        return (0, common_1.delay)(10);
     }
+    /** @inheritDoc*/
     some(_f, _o) {
         logger.warn('Should not be called', { fn: 'some' });
-        return (0, common_2.delay)(10, false);
+        return (0, common_1.delay)(10, false);
     }
+    /** @inheritDoc*/
     take(_l, _o) {
         logger.warn('Should not be called', { fn: 'take' });
         return undefined;
     }
+    /** @inheritDoc*/
     toArray(_o) {
         logger.warn('Should not be called', { fn: 'toArray' });
-        return (0, common_2.delay)(10, []);
+        return (0, common_1.delay)(10, []);
     }
     // endregion stream
     // region method
+    /** @inheritDoc*/
     param(name, defaultValue) {
         var _a;
         return (_a = this.params[name]) !== null && _a !== void 0 ? _a : defaultValue;
     }
+    // endregion method
+    // region static
+    /**
+     * Set first real request
+     *
+     * @param {Request} origin
+     * */
+    static setFirstOrigin(origin) {
+        if (!_firstOrigin && origin) {
+            _firstOrigin = origin;
+            delete _firstOrigin.headers;
+            delete _firstOrigin.body;
+            delete _firstOrigin.cookies;
+            delete _firstOrigin.params;
+            _removePath(_firstOrigin);
+            try {
+                delete _firstOrigin.path;
+            }
+            catch (e) {
+                // nothing
+            }
+        }
+    }
+    /**
+     * Get first real request
+     *
+     * @return {Request}
+     * */
+    static get firstOrigin() {
+        return _firstOrigin;
+    }
 }
 exports.MockRequest = MockRequest;
-const logger = common_1.$log.create(MockRequest);
+const logger = (0, common_1.newLogger)(MockRequest);
 // region functions
 function _removePath(req) {
     try {
@@ -211,6 +268,12 @@ function _removePath(req) {
         // nothing
     }
 }
+/**
+ * Attach service to request
+ *
+ * @param {Request} req - request
+ * @param {MockServiceRequest} service - service request object
+ * */
 function _attachService(req, service) {
     var _a, _b, _g, _h, _j;
     if (!service) {
@@ -231,14 +294,27 @@ function _attachService(req, service) {
     req.cookies = (_h = service === null || service === void 0 ? void 0 : service.cookies) !== null && _h !== void 0 ? _h : {};
     req.signedCookies = (_j = service === null || service === void 0 ? void 0 : service.signedCookies) !== null && _j !== void 0 ? _j : {};
 }
-function _attachOrigin(req, origin) {
+/**
+ * Attach first real request
+ *
+ * @param {Request} _req
+ * @param {Request} origin
+ * */
+function _attachOrigin(_req, origin) {
     origin = origin !== null && origin !== void 0 ? origin : _firstOrigin;
     if (origin) {
+        // Clear specific values
         origin.body = undefined;
         origin.params = {};
         _removePath(origin);
     }
 }
+/**
+ * Attach custom object to request
+ *
+ * @param {Request} req
+ * @param {object} custom
+ * */
 function _attachCustom(req, custom) {
     if (custom) {
         for (const [key, value] of Object.entries(custom)) {
@@ -248,6 +324,11 @@ function _attachCustom(req, custom) {
         }
     }
 }
+/**
+ * Check route
+ *
+ * @param {Request} req
+ * */
 function _checkRoute(req) {
     if (!req.route) {
         req.route = {