@leyyo/http-mock 1.2.1 → 1.3.1

package/dist/response/index-types.d.ts

@@ -1,25 +1,70 @@
-import type { CookieOptions, Response } from "express";
-import type { Arr, Dict } from "@leyyo/common";
-import type { HttpData, HttpHeaders, HttpStatus } from "../shared";
+import { CookieOptions, Response } from "express";
+import { Arr, Dict, HttpStatus } from "@leyyo/common";
+import { HttpData, HttpHeaders } from "../shared";
+/**
+ * Response local storage
+ * */
 export interface ResponseLocal {
 }
+/**
+ * Response cookies
+ * */
 export type ResponseCookies = Dict<ResponseCookie>;
+/**
+ * Response data
+ * */
 export type ResponseData = Arr | HttpData | string | number | boolean | unknown;
+/**
+ * Response error callback
+ * */
 export type ResponseErrorCallback = (e?: Error) => void;
+/**
+ * Service mock result for http bulk calls
+ * */
 export interface MockServicePreparedResponse<R = ResponseData> {
+    /**
+     * Response status
+     * */
     status: HttpStatus;
+    /**
+     * Response status message
+     * */
     statusMessage: string;
+    /**
+     * Response headers
+     * */
     headers: HttpHeaders;
+    /**
+     * Response cookies
+     * */
     cookies: ResponseCookies;
+    /**
+     * Response cleared cookies, Them should be cleared after all calls
+     * */
     clearedCookies: Dict<CookieOptions>;
+    /**
+     * Response data
+     * */
     data: R;
 }
+/**
+ * Response resolver lambda
+ * */
 export type MockResponseResolve<R> = (dto: MockServicePreparedResponse<R>) => void;
+/**
+ * Response cookie with options
+ * */
 export interface ResponseCookie {
     value: string | number;
     opt: CookieOptions;
 }
+/**
+ * Http mock response, it extends express response
+ * */
 export interface MockResponseLike<R extends ResponseData, L extends ResponseLocal = ResponseLocal> extends Response<R, L> {
+    /**
+     * Indicates that it's fake/mock response
+     * */
     readonly isFake: boolean;
     [another: string]: unknown;
 }

package/dist/response/mock-response.d.ts

@@ -1,113 +1,261 @@
-import type { Application, CookieOptions, Errback, Request, Response } from "express";
-import type { Socket } from "net";
-import type { MockResponseLike, MockResponseResolve, ResponseData, ResponseErrorCallback, ResponseLocal } from "./index-types";
-import type { Dict, KeyValue, OneOrMore } from "@leyyo/common";
-import { HttpEvent, type HttpStatus } from "../shared";
-import type { OutgoingHttpHeader, OutgoingHttpHeaders } from "node:http";
+import { Application, CookieOptions, Errback, Request, Response } from "express";
+import { Socket } from "net";
+import { MockResponseLike, MockResponseResolve, ResponseData, ResponseErrorCallback, ResponseLocal } from "./index-types";
+import { Dict, HttpStatus, KeyValue, OneOrMore } from "@leyyo/common";
+import { HttpEvent } from "../shared";
+import { OutgoingHttpHeader, OutgoingHttpHeaders } from "node:http";
 export declare class MockResponse<R extends ResponseData, L extends ResponseLocal = ResponseLocal> extends HttpEvent<Response> implements MockResponseLike<R, L> {
+    /**
+     * is header already sent?
+     * */
     private _headersSent;
+    /**
+     * Response resolver lambda
+     * */
     private readonly _resolver;
+    /**
+     * Response headers
+     * */
     private _headers;
+    /**
+     * Response cookies
+     * */
     private _cookies;
+    /**
+     * Response cleared cookies
+     * */
     private _clearedCookies;
+    /**
+     * Response data
+     * */
     private _data;
+    /**
+     * Response status
+     * */
     private _status;
+    /**
+     * Response local vale
+     * */
     readonly locals: L;
+    /** @inheritDoc */
     readonly isFake: boolean;
     [another: string]: unknown;
-    static setFirstOrigin(origin: Response): void;
-    static get firstOrigin(): Response;
+    /**
+     * Constructor
+     *
+     * @param {MockResponseResolve} resolver - response resolver
+     * @param {Response} origin - first origin/real response
+     * */
     constructor(resolver: MockResponseResolve<R>, origin?: Response);
+    /**
+     * It's used for in place of original sen data
+     *
+     * It collects data and trigger resolver
+     *
+     * @param {any} data
+     * */
     private _send;
+    /**
+     * Set header
+     *
+     * @param {string} key - header key
+     * @param {(string|string[])} value - header value
+     * */
     private _setHeader;
+    /**
+     * Set cookie
+     *
+     * @param {string} key - cookie key
+     * @param {string} value - cookie value
+     * @param {CookieOptions} opt
+     * */
     private _setCookie;
+    /**
+     * Remove a key from cleared cookies
+     *
+     * @param {string} key - cookie key
+     * @return {boolean} - is removed?
+     * */
     private _cancelCookieClear;
+    /**
+     * Clear response
+     * */
     private _clear;
+    /** @inheritDoc */
     destroyed: boolean;
+    /** @inheritDoc */
     closed: boolean;
+    /** @inheritDoc */
     errored: Error;
+    /** @inheritDoc */
     readonly writable: boolean;
+    /** @inheritDoc */
     readonly writableAborted: boolean;
+    /** @inheritDoc */
     readonly writableCorked: number;
+    /** @inheritDoc */
     readonly writableEnded: boolean;
+    /** @inheritDoc */
     readonly writableFinished: boolean;
+    /** @inheritDoc */
     readonly writableHighWaterMark: number;
+    /** @inheritDoc */
     readonly writableLength: number;
+    /** @inheritDoc */
     readonly writableObjectMode: boolean;
+    /** @inheritDoc */
     writableNeedDrain: boolean;
+    /** @inheritDoc */
     _construct(_c?: ResponseErrorCallback): void;
+    /** @inheritDoc */
     _destroy(_e: Error | null, _c: ResponseErrorCallback): void;
+    /** @inheritDoc */
     _final(_c: ResponseErrorCallback): void;
+    /** @inheritDoc */
     _write(_c: unknown, _e: BufferEncoding, _r: ResponseErrorCallback): void;
+    /** @inheritDoc */
     _writev(_c: Array<{
         chunk: unknown;
         encoding: BufferEncoding;
     }>, _b: ResponseErrorCallback): void;
+    /** @inheritDoc */
     cork(): void;
+    /** @inheritDoc */
     destroy(_e: Error | undefined): this;
+    /** @inheritDoc */
     pipe<T extends NodeJS.WritableStream>(_d: T, _o: {
         end?: boolean | undefined;
     } | undefined): T;
+    /** @inheritDoc */
     setDefaultEncoding(_e: BufferEncoding): this;
+    /** @inheritDoc */
     uncork(): void;
+    /** @inheritDoc */
     end(): this;
+    /** @inheritDoc */
     write(_b: Uint8Array | string, _c?: ResponseErrorCallback | BufferEncoding, _d?: ResponseErrorCallback): boolean;
+    /** @inheritDoc */
     compose<T>(_s: ComposeFnParam | Iterable<T> | AsyncIterable<T> | T, _o: {
         signal: AbortSignal;
     } | undefined): T;
+    /** @inheritDoc */
     sendDate: boolean;
+    /** @inheritDoc */
     statusMessage: string;
+    /** @inheritDoc */
     chunkedEncoding: boolean;
+    /** @inheritDoc */
     shouldKeepAlive: boolean;
+    /** @inheritDoc */
     finished: boolean;
+    /** @inheritDoc */
     get connection(): Socket;
+    /** @inheritDoc */
     useChunkedEncodingByDefault: boolean;
+    /** @inheritDoc */
     readonly socket: Socket | null;
+    /** @inheritDoc */
     statusCode: number;
+    /** @inheritDoc */
     writeHead: ((statusCode: number, statusMessage?: string, headers?: (OutgoingHttpHeaders | OutgoingHttpHeader[])) => this) & ((statusCode: number, headers?: (OutgoingHttpHeaders | OutgoingHttpHeader[])) => this);
+    /** @inheritDoc */
     strictContentLength: boolean;
+    /** @inheritDoc */
     addTrailers(_h: OutgoingHttpHeaders | Array<[string, string]>): void;
+    /** @inheritDoc */
     assignSocket(_s: Socket): void;
+    /** @inheritDoc */
     detachSocket(_s: Socket): void;
+    /** @inheritDoc */
     flushHeaders(): void;
+    /** @inheritDoc */
     getHeader(name: string): number | string | string[] | undefined;
+    /** @inheritDoc */
     getHeaderNames(): string[];
+    /** @inheritDoc */
     getHeaders(): OutgoingHttpHeaders;
+    /** @inheritDoc */
     hasHeader(name: string): boolean;
+    /** @inheritDoc */
     removeHeader(name: string): void;
+    /** @inheritDoc */
     setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
+    /** @inheritDoc */
     setTimeout(_m: number, _c: (() => void) | undefined): this;
+    /** @inheritDoc */
     writeContinue(_c: (() => void) | undefined): void;
+    /** @inheritDoc */
     writeProcessing(): void;
+    /** @inheritDoc */
     appendHeader(name: string, value: string | readonly string[]): this;
+    /** @inheritDoc */
     setHeaders(headers: Headers | Map<string, number | string | readonly string[]>): this;
+    /** @inheritDoc */
     writeEarlyHints(_h: Record<string, string | string[]>, _c: (() => void) | undefined): void;
+    /** @inheritDoc */
     readonly app: Application;
+    /** @inheritDoc */
     charset: string;
+    /** @inheritDoc */
     readonly req: Request;
+    /** @inheritDoc */
     get headersSent(): boolean;
+    /** @inheritDoc */
     json(data: R): this;
+    /** @inheritDoc */
     jsonp(data: R): this;
+    /** @inheritDoc */
     send(body?: unknown): this;
+    /** @inheritDoc */
     attachment(filename?: string): this;
+    /** @inheritDoc */
     clearCookie(name: string, options?: CookieOptions): this;
+    /** @inheritDoc */
     append(key: string, value?: OneOrMore<string>): this;
+    /** @inheritDoc */
     contentType(type: string): this;
+    /** @inheritDoc */
     cookie(key: string, value: unknown, option?: CookieOptions): this;
+    /** @inheritDoc */
     download(path: string, _fn?: Errback | string, _err?: unknown, _errBack?: Errback): void;
+    /** @inheritDoc */
     format(obj: unknown): this;
+    /** @inheritDoc */
     get(field: string): string;
+    /** @inheritDoc */
     header(field: unknown, value?: OneOrMore<string>): this;
+    /** @inheritDoc */
     links(map: unknown): this;
+    /** @inheritDoc */
     location(url: string): this;
+    /** @inheritDoc */
     redirect(url: KeyValue, status?: KeyValue): void;
+    /** @inheritDoc */
     render(_v: string, _o?: Dict | ((err: Error, html: string) => void), _c?: (err: Error, html: string) => void): void;
+    /** @inheritDoc */
     sendFile(path: string, _fn?: unknown, _err?: Errback): void;
+    /** @inheritDoc */
     sendStatus(status: number): this;
+    /** @inheritDoc */
     set(field: unknown, value?: string | string[]): this;
+    /** @inheritDoc */
     status(status: HttpStatus): this;
+    /** @inheritDoc */
     type(type: string): this;
+    /** @inheritDoc */
     vary(field: string): this;
+    /**
+     * Set first real response
+     *
+     * @param {Response} origin
+     * */
+    static setFirstOrigin(origin: Response): void;
+    /**
+     * Get first real response
+     *
+     * @return {Response}
+     * */
+    static get firstOrigin(): Response;
 }
 type ComposeFnParam = (source: any) => void;
 export {};