mock-config-server 3.6.1 → 3.7.1

package/dist/src/utils/helpers/logger/helpers/filterTokens/filterTokens.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "filterTokens", {
+    enumerable: true,
+    get: function() {
+        return filterTokens;
+    }
+});
+const _isPlainObject = require("../../../isPlainObject/isPlainObject");
+const resolveNestedOptionFilterMode = (nestedOption)=>{
+    const values = Object.values(nestedOption);
+    return values.some(Boolean) ? 'whitelist' : 'blacklist';
+};
+const filterTokens = (tokens, options)=>Object.entries(options).reduce((acc, [name, option])=>{
+        const token = tokens[name];
+        if (option === true) {
+            acc[name] = token;
+            return acc;
+        }
+        const isNestedOption = (0, _isPlainObject.isPlainObject)(option);
+        const isNestedToken = (0, _isPlainObject.isPlainObject)(token);
+        if (isNestedOption && isNestedToken) {
+            const nestedOptionFilterMode = resolveNestedOptionFilterMode(option);
+            if (nestedOptionFilterMode === 'whitelist') {
+                acc[name] = Object.entries(option).reduce((acc, [name, nestedOption])=>{
+                    if (nestedOption) {
+                        acc[name] = token[name];
+                    }
+                    return acc;
+                }, {});
+            }
+            if (nestedOptionFilterMode === 'blacklist') {
+                acc[name] = Object.keys(token).reduce((acc, name)=>{
+                    if (option[name] !== false) {
+                        acc[name] = token[name];
+                    }
+                    return acc;
+                }, {});
+            }
+        }
+        return acc;
+    }, {});

package/dist/src/utils/helpers/logger/helpers/formatTokens/formatTokens.d.ts

@@ -0,0 +1,2 @@
+import type { PlainObject } from '../../../../types';
+export declare const formatTokens: (tokens: PlainObject) => any;

package/dist/src/utils/helpers/logger/helpers/formatTokens/formatTokens.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatTokens", {
+    enumerable: true,
+    get: function() {
+        return formatTokens;
+    }
+});
+const _date = require("../../../date");
+const formatTokens = (tokens)=>{
+    const { timestamp, method } = tokens;
+    return {
+        ...tokens,
+        ...timestamp && {
+            timestamp: (0, _date.formatTimestamp)(timestamp)
+        },
+        ...method && {
+            method: method.toUpperCase()
+        }
+    };
+};

package/dist/src/utils/helpers/logger/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './filterTokens/filterTokens';
+export * from './formatTokens/formatTokens';

package/dist/src/utils/helpers/logger/helpers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./filterTokens/filterTokens"), exports);
+_export_star(require("./formatTokens/formatTokens"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/src/utils/helpers/logger/index.d.ts

@@ -0,0 +1,2 @@
+export * from './callRequestLogger/callRequestLogger';
+export * from './callResponseLogger/callResponseLogger';

package/dist/src/utils/helpers/logger/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./callRequestLogger/callRequestLogger"), exports);
+_export_star(require("./callResponseLogger/callResponseLogger"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/src/utils/types/checkModes.d.ts

@@ -4,7 +4,6 @@ export type CompareWithDescriptorStringValueCheckMode = 'includes' | 'notInclude
 export type CompareWithDescriptorValueCheckMode = CompareWithDescriptorAnyValueCheckMode | CompareWithDescriptorStringValueCheckMode;
 export type CalculateByDescriptorValueCheckMode = 'regExp' | 'function';
 export type CheckMode = CheckActualValueCheckMode | CompareWithDescriptorValueCheckMode | CalculateByDescriptorValueCheckMode;
-export type PlainEntityCheckMode = Exclude<CheckMode, CompareWithDescriptorStringValueCheckMode | Extract<CalculateByDescriptorValueCheckMode, 'regExp'>>;
 export interface EntityDescriptor {
     checkMode: CheckMode;
     value?: any;

package/dist/src/utils/types/graphql.d.ts

@@ -6,9 +6,6 @@ export type GraphQLEntityName = 'headers' | 'cookies' | 'query' | 'variables';
 export type GraphQLEntity<EntityName extends GraphQLEntityName = GraphQLEntityName> = EntityName extends 'variables' ? PlainEntity : MappedEntity;
 export type GraphQLOperationType = 'query' | 'mutation';
 export type GraphQLOperationName = string | RegExp;
-export type GraphQLEntityNamesByOperationType = {
-    [operationType in GraphQLOperationType]: GraphQLEntityName;
-};
 export type GraphQLEntitiesByEntityName = {
     [EntityName in GraphQLEntityName]?: GraphQLEntity<EntityName>;
 };
@@ -32,12 +29,12 @@ export type GraphQLRouteConfig = ({
     data: ((request: Request, entities: GraphQLEntitiesByEntityName) => Data | Promise<Data>) | Data;
 }) & {
     entities?: GraphQLEntitiesByEntityName;
-    interceptors?: Interceptors;
+    interceptors?: Interceptors<'graphql'>;
 };
 interface BaseGraphQLRequestConfig {
     operationType: GraphQLOperationType;
     routes: GraphQLRouteConfig[];
-    interceptors?: Interceptors;
+    interceptors?: Interceptors<'graphql'>;
 }
 export interface OperationNameGraphQLRequestConfig extends BaseGraphQLRequestConfig {
     operationName: GraphQLOperationName;

package/dist/src/utils/types/index.d.ts

@@ -3,7 +3,9 @@ export * from './database';
 export * from './entities';
 export * from './graphql';
 export * from './interceptors';
+export * from './logger';
 export * from './rest';
 export * from './server';
+export * from './shared';
 export * from './utils';
 export * from './values';

package/dist/src/utils/types/index.js

@@ -7,8 +7,10 @@ _export_star(require("./database"), exports);
 _export_star(require("./entities"), exports);
 _export_star(require("./graphql"), exports);
 _export_star(require("./interceptors"), exports);
+_export_star(require("./logger"), exports);
 _export_star(require("./rest"), exports);
 _export_star(require("./server"), exports);
+_export_star(require("./shared"), exports);
 _export_star(require("./utils"), exports);
 _export_star(require("./values"), exports);
 function _export_star(from, to) {

package/dist/src/utils/types/interceptors.d.ts

@@ -1,15 +1,18 @@
 import type { CookieOptions, Request, Response } from 'express';
+import type { Logger, LoggerTokens } from './logger';
+import type { ApiType } from './shared';
 type RequestInterceptorCookieValue = string | undefined;
 type RequestInterceptorHeaderValue = string | number | string[] | undefined;
-export interface RequestInterceptorParams {
+export interface RequestInterceptorParams<Api extends ApiType = ApiType> {
     request: Request;
     setDelay: (delay: number) => Promise<void>;
     getCookie: (name: string) => RequestInterceptorCookieValue;
     getHeader: (field: string) => RequestInterceptorHeaderValue;
     getHeaders: () => Record<string, RequestInterceptorHeaderValue>;
+    log: (logger?: Logger<'request', Api>) => Partial<LoggerTokens>;
 }
-export type RequestInterceptor = (params: RequestInterceptorParams) => void | Promise<void>;
-export interface ResponseInterceptorParams {
+export type RequestInterceptor<Api extends ApiType = ApiType> = (params: RequestInterceptorParams<Api>) => void | Promise<void>;
+export interface ResponseInterceptorParams<Api extends ApiType = ApiType> {
     request: Request;
     response: Response;
     setDelay: (delay: number) => Promise<void>;
@@ -22,10 +25,11 @@ export interface ResponseInterceptorParams {
     getCookie: (name: string) => RequestInterceptorCookieValue;
     clearCookie: (name: string, options?: CookieOptions) => void;
     attachment: (filename: string) => void;
+    log: (logger?: Logger<'response', Api>) => Partial<LoggerTokens>;
 }
-export type ResponseInterceptor<Data = any> = (data: Data, params: ResponseInterceptorParams) => any;
-export interface Interceptors {
-    request?: RequestInterceptor;
-    response?: ResponseInterceptor;
+export type ResponseInterceptor<Data = any, Api extends ApiType = ApiType> = (data: Data, params: ResponseInterceptorParams<Api>) => any;
+export interface Interceptors<Api extends ApiType = ApiType> {
+    request?: RequestInterceptor<Api>;
+    response?: ResponseInterceptor<any, Api>;
 }
 export {};

package/dist/src/utils/types/logger.d.ts

@@ -0,0 +1,43 @@
+import type { GraphQLOperationName, GraphQLOperationType } from './graphql';
+import type { RestMethod } from './rest';
+import type { ApiType } from './shared';
+import type { Cookies, Headers, Params, PlainObject, Query } from './values';
+export interface LoggerBaseTokens {
+    type: string;
+    id: number;
+    timestamp: number;
+    method: RestMethod;
+    url: string;
+    headers: Headers;
+    cookies: Cookies;
+    query: Query;
+    params: Params;
+    body: any;
+}
+interface LoggerRestRequestTokens extends LoggerBaseTokens {
+}
+interface LoggerRestResponseTokens extends LoggerRestRequestTokens {
+    statusCode: number;
+    data: any;
+}
+interface LoggerGraphQLRequestTokens extends LoggerBaseTokens {
+    graphQLOperationType: GraphQLOperationType | null;
+    graphQLOperationName: GraphQLOperationName | null;
+    graphQLQuery: string | null;
+    variables: PlainObject | null;
+}
+interface LoggerGraphQLResponseTokens extends LoggerGraphQLRequestTokens {
+    statusCode: number;
+    data: any;
+}
+export type LoggerType = 'request' | 'response';
+export type LoggerTokens<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> = Type extends 'request' ? Api extends 'rest' ? LoggerRestRequestTokens : Api extends 'graphql' ? LoggerGraphQLRequestTokens : never : Type extends 'response' ? Api extends 'rest' ? LoggerRestResponseTokens : Api extends 'graphql' ? LoggerGraphQLResponseTokens : never : never;
+type LoggerTokensToLoggerOptions<Type> = {
+    [Key in keyof Type]?: Type[Key] extends PlainObject ? Record<string, boolean> | boolean : boolean;
+};
+export type LoggerOptions<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> = LoggerTokensToLoggerOptions<LoggerTokens<Type, Api>>;
+export interface Logger<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> {
+    options?: LoggerOptions<Type, Api>;
+    rewrite?: (tokens: Partial<LoggerTokens<Type, Api>>) => void;
+}
+export {};

package/dist/src/utils/types/logger.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/src/utils/types/rest.d.ts

@@ -36,14 +36,14 @@ export type RestRouteConfig<Method extends RestMethod> = ({
     file: string;
 }) & {
     entities?: RestEntitiesByEntityName<Method>;
-    interceptors?: Interceptors;
+    interceptors?: Interceptors<'rest'>;
 };
 export type RestPathString = `/${string}`;
 interface BaseRestRequestConfig<Method extends RestMethod> {
     path: RestPathString | RegExp;
     method: Method;
     routes: RestRouteConfig<Method>[];
-    interceptors?: Interceptors;
+    interceptors?: Interceptors<'rest'>;
 }
 type RestGetRequestConfig = BaseRestRequestConfig<'get'>;
 type RestPostRequestConfig = BaseRestRequestConfig<'post'>;

package/dist/src/utils/types/server.d.ts

@@ -23,12 +23,12 @@ export type BaseUrl = `/${string}`;
 export interface RestConfig {
     baseUrl?: BaseUrl;
     configs: RestRequestConfig[];
-    interceptors?: Interceptors;
+    interceptors?: Interceptors<'rest'>;
 }
 export interface GraphqlConfig {
     baseUrl?: BaseUrl;
     configs: GraphQLRequestConfig[];
-    interceptors?: Interceptors;
+    interceptors?: Interceptors<'graphql'>;
 }
 export type DatabaseConfig = {
     data: Record<string, unknown> | `${string}.json`;

package/dist/src/utils/types/shared.d.ts

@@ -0,0 +1 @@
+export type ApiType = 'rest' | 'graphql';

package/dist/src/utils/types/shared.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/src/utils/types/values.d.ts

@@ -1,3 +1,10 @@
+/// <reference types="node" />
+import type { ParamsDictionary, Query as ExpressQuery } from 'express-serve-static-core';
+import type { IncomingHttpHeaders } from 'http';
 export type PlainObject = Record<string, any>;
 export type Primitive = boolean | number | bigint | string | null | undefined | symbol;
+export type Headers = IncomingHttpHeaders;
+export type Query = ExpressQuery;
+export type Params = ParamsDictionary;
+export type Cookies = Record<string, string>;
 export type Data = boolean | number | string | any[] | Record<any, any> | null | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mock-config-server",
-  "version": "3.6.1",
+  "version": "3.7.1",
   "description": "Tool that easily and quickly imitates server operation, create full fake api in few steps",
   "author": {
     "name": "SIBERIA CAN CODE 🧊",