mock-config-server 3.7.0 → 4.0.0

package/dist/src/server/createMockServer/createMockServer.js

@@ -15,6 +15,7 @@ const _graphql = require("../../core/graphql");
 const _middlewares = require("../../core/middlewares");
 const _rest = require("../../core/rest");
 const _helpers = require("../../utils/helpers");
+const _validate = require("../../utils/validate");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -22,10 +23,8 @@ function _interop_require_default(obj) {
 }
 const createMockServer = (mockServerConfig, server = (0, _express.default)())=>{
     var _mockServerConfig_interceptors;
+    (0, _validate.validateMockServerConfig)(mockServerConfig);
     const { cors, staticPath, rest, graphql, database, interceptors } = mockServerConfig;
-    server.set('view engine', 'ejs');
-    server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
-    server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
     server.use(_bodyparser.default.urlencoded({
         extended: false
     }));
@@ -34,7 +33,7 @@ const createMockServer = (mockServerConfig, server = (0, _express.default)())=>{
     }));
     server.set('json spaces', 2);
     server.use(_bodyparser.default.text());
-    (0, _middlewares.contextMiddleware)(server);
+    (0, _middlewares.contextMiddleware)(server, mockServerConfig);
     (0, _middlewares.cookieParseMiddleware)(server);
     const serverRequestInterceptor = (_mockServerConfig_interceptors = mockServerConfig.interceptors) === null || _mockServerConfig_interceptors === void 0 ? void 0 : _mockServerConfig_interceptors.request;
     if (serverRequestInterceptor) {
@@ -95,7 +94,6 @@ const createMockServer = (mockServerConfig, server = (0, _express.default)())=>{
         const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
         server.use(baseUrl, routerWithDatabaseRoutes);
     }
-    (0, _middlewares.notFoundMiddleware)(server, mockServerConfig);
     (0, _middlewares.errorMiddleware)(server);
     return server;
 };

package/dist/src/server/createRestMockServer/createRestMockServer.d.ts

@@ -1,3 +1,3 @@
 import type { Express } from 'express';
 import type { RestMockServerConfig } from '../../utils/types';
-export declare const createRestMockServer: (restMockServerConfig: Omit<RestMockServerConfig, 'port'>, server?: Express) => Express;
+export declare const createRestMockServer: (restMockServerConfig: Omit<RestMockServerConfig, "port">, server?: Express) => Express;

package/dist/src/server/createRestMockServer/createRestMockServer.js

@@ -13,7 +13,7 @@ const _express = /*#__PURE__*/ _interop_require_default(require("express"));
 const _database = require("../../core/database");
 const _middlewares = require("../../core/middlewares");
 const _rest = require("../../core/rest");
-const _helpers = require("../../utils/helpers");
+const _validate = require("../../utils/validate");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -21,10 +21,8 @@ function _interop_require_default(obj) {
 }
 const createRestMockServer = (restMockServerConfig, server = (0, _express.default)())=>{
     var _restMockServerConfig_interceptors;
+    (0, _validate.validateApiMockServerConfig)(restMockServerConfig, 'rest');
     const { cors, staticPath, configs, database, interceptors } = restMockServerConfig;
-    server.set('view engine', 'ejs');
-    server.set('views', (0, _helpers.urlJoin)(__dirname, '../../static/views'));
-    server.use(_express.default.static((0, _helpers.urlJoin)(__dirname, '../../static/views')));
     server.use(_bodyparser.default.urlencoded({
         extended: false
     }));
@@ -33,7 +31,7 @@ const createRestMockServer = (restMockServerConfig, server = (0, _express.defaul
     }));
     server.set('json spaces', 2);
     server.use(_bodyparser.default.text());
-    (0, _middlewares.contextMiddleware)(server);
+    (0, _middlewares.contextMiddleware)(server, restMockServerConfig);
     (0, _middlewares.cookieParseMiddleware)(server);
     const serverRequestInterceptor = (_restMockServerConfig_interceptors = restMockServerConfig.interceptors) === null || _restMockServerConfig_interceptors === void 0 ? void 0 : _restMockServerConfig_interceptors.request;
     if (serverRequestInterceptor) {
@@ -64,7 +62,6 @@ const createRestMockServer = (restMockServerConfig, server = (0, _express.defaul
         const routerWithDatabaseRoutes = (0, _database.createDatabaseRoutes)(_express.default.Router(), database);
         server.use(baseUrl, routerWithDatabaseRoutes);
     }
-    (0, _middlewares.notFoundMiddleware)(server, restMockServerConfig);
     (0, _middlewares.errorMiddleware)(server);
     return server;
 };

package/dist/src/server/index.d.ts

@@ -1,8 +1,10 @@
 export * from './createDatabaseMockServer/createDatabaseMockServer';
+export * from './createFlatMockServer/createFlatMockServer';
 export * from './createGraphQLMockServer/createGraphQLMockServer';
 export * from './createMockServer/createMockServer';
 export * from './createRestMockServer/createRestMockServer';
 export * from './startDatabaseMockServer/startDatabaseMockServer';
+export * from './startFlatMockServer/startFlatMockServer';
 export * from './startGraphQLMockServer/startGraphQLMockServer';
 export * from './startMockServer/startMockServer';
 export * from './startRestMockServer/startRestMockServer';

package/dist/src/server/index.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./createDatabaseMockServer/createDatabaseMockServer"), exports);
+_export_star(require("./createFlatMockServer/createFlatMockServer"), exports);
 _export_star(require("./createGraphQLMockServer/createGraphQLMockServer"), exports);
 _export_star(require("./createMockServer/createMockServer"), exports);
 _export_star(require("./createRestMockServer/createRestMockServer"), exports);
 _export_star(require("./startDatabaseMockServer/startDatabaseMockServer"), exports);
+_export_star(require("./startFlatMockServer/startFlatMockServer"), exports);
 _export_star(require("./startGraphQLMockServer/startGraphQLMockServer"), exports);
 _export_star(require("./startMockServer/startMockServer"), exports);
 _export_star(require("./startRestMockServer/startRestMockServer"), exports);

package/dist/src/server/startDatabaseMockServer/startDatabaseMockServer.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
 import type { DatabaseMockServerConfig } from '../../utils/types';
 export declare const startDatabaseMockServer: (databaseMockServerConfig: DatabaseMockServerConfig) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
-    destroy: (callback?: ((err?: Error | undefined) => void) | undefined) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    destroy: import("http").Server["close"];
 };

package/dist/src/server/startFlatMockServer/startFlatMockServer.d.ts

@@ -0,0 +1,4 @@
+import type { FlatMockServerConfig } from '../../utils/types';
+export declare const startFlatMockServer: (flatMockServerConfig: FlatMockServerConfig) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
+    destroy: import("http").Server["close"];
+};

package/dist/src/server/startFlatMockServer/startFlatMockServer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "startFlatMockServer", {
+    enumerable: true,
+    get: function() {
+        return startFlatMockServer;
+    }
+});
+const _ansicolors = /*#__PURE__*/ _interop_require_default(require("ansi-colors"));
+const _middlewares = require("../../core/middlewares");
+const _constants = require("../../utils/constants");
+const _createFlatMockServer = require("../createFlatMockServer/createFlatMockServer");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const startFlatMockServer = (flatMockServerConfig)=>{
+    const flatMockServer = (0, _createFlatMockServer.createFlatMockServer)(flatMockServerConfig);
+    const { port = _constants.DEFAULT.PORT } = !('configs' in flatMockServerConfig[0]) ? flatMockServerConfig[0] : {};
+    const server = flatMockServer.listen(port, ()=>{
+        console.log(_ansicolors.default.green(`🎉 Flat Mock Server is running at http://localhost:${port}`));
+    });
+    // ✅ important: add destroy method for closing keep-alive connections after server shutdown
+    return (0, _middlewares.destroyerMiddleware)(server);
+};

package/dist/src/server/startGraphQLMockServer/startGraphQLMockServer.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
 import type { GraphQLMockServerConfig } from '../../utils/types';
 export declare const startGraphQLMockServer: (graphQLMockServerConfig: GraphQLMockServerConfig) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
-    destroy: (callback?: ((err?: Error | undefined) => void) | undefined) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    destroy: import("http").Server["close"];
 };

package/dist/src/server/startMockServer/startMockServer.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
 import type { MockServerConfig } from '../../utils/types';
 export declare const startMockServer: (mockServerConfig: MockServerConfig) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
-    destroy: (callback?: ((err?: Error | undefined) => void) | undefined) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    destroy: import("http").Server["close"];
 };

package/dist/src/server/startRestMockServer/startRestMockServer.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
 import type { RestMockServerConfig } from '../../utils/types';
 export declare const startRestMockServer: (restMockServerConfig: RestMockServerConfig) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> & {
-    destroy: (callback?: ((err?: Error | undefined) => void) | undefined) => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    destroy: import("http").Server["close"];
 };

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

@@ -3,6 +3,4 @@ export declare const COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES: readonly ["e
 export declare const COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES: readonly ["includes", "notIncludes", "startsWith", "notStartsWith", "endsWith", "notEndsWith"];
 export declare const COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES: readonly ["equals", "notEquals", "includes", "notIncludes", "startsWith", "notStartsWith", "endsWith", "notEndsWith"];
 export declare const CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES: readonly ["regExp", "function"];
-export declare const CHECK_MODES: readonly ["exists", "notExists", "equals", "notEquals", "includes", "notIncludes", "startsWith", "notStartsWith", "endsWith", "notEndsWith", "regExp", "function"];
-export declare const PLAIN_ENTITY_CHECK_MODES: readonly ["exists", "notExists", "equals", "notEquals", "function"];
-export declare const NEGATION_CHECK_MODES: readonly ["notExists", "notEquals", "notIncludes", "notStartsWith", "notEndsWith"];
+export declare const NEGATIVE_CHECK_MODES: readonly ["notExists", "notEquals", "notIncludes", "notStartsWith", "notEndsWith"];

package/dist/src/utils/constants/checkModes.js

@@ -15,9 +15,6 @@ _export(exports, {
     CHECK_ACTUAL_VALUE_CHECK_MODES: function() {
         return CHECK_ACTUAL_VALUE_CHECK_MODES;
     },
-    CHECK_MODES: function() {
-        return CHECK_MODES;
-    },
     COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES: function() {
         return COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES;
     },
@@ -27,11 +24,8 @@ _export(exports, {
     COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES: function() {
         return COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES;
     },
-    NEGATION_CHECK_MODES: function() {
-        return NEGATION_CHECK_MODES;
-    },
-    PLAIN_ENTITY_CHECK_MODES: function() {
-        return PLAIN_ENTITY_CHECK_MODES;
+    NEGATIVE_CHECK_MODES: function() {
+        return NEGATIVE_CHECK_MODES;
     }
 });
 const CHECK_ACTUAL_VALUE_CHECK_MODES = [
@@ -58,17 +52,7 @@ const CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES = [
     'regExp',
     'function'
 ];
-const CHECK_MODES = [
-    ...CHECK_ACTUAL_VALUE_CHECK_MODES,
-    ...COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES,
-    ...CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES
-];
-const PLAIN_ENTITY_CHECK_MODES = [
-    ...CHECK_ACTUAL_VALUE_CHECK_MODES,
-    ...COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES,
-    'function'
-];
-const NEGATION_CHECK_MODES = [
+const NEGATIVE_CHECK_MODES = [
     'notExists',
     'notEquals',
     'notIncludes',

package/dist/src/utils/helpers/config/resolveEntityValues/resolveEntityValues.d.ts

@@ -1,2 +1,20 @@
-import type { CheckMode } from '../../../types';
-export declare const resolveEntityValues: (checkMode: CheckMode, actualValue: any, descriptorValue?: any) => any;
+import type { CheckActualValueCheckMode, CheckMode } from '../../../types';
+interface ResolveEntityValuesParamsWithCheckActualValueCheckMode {
+    actualValue: unknown;
+    checkMode: CheckActualValueCheckMode;
+}
+interface ResolveEntityValuesParamsWithEnabledOneOf {
+    actualValue: unknown;
+    checkMode: Exclude<CheckMode, CheckActualValueCheckMode>;
+    descriptorValue: unknown[];
+    oneOf: true;
+}
+interface ResolveEntityValuesParamsWithDisabledOneOf {
+    actualValue: unknown;
+    checkMode: Exclude<CheckMode, CheckActualValueCheckMode>;
+    descriptorValue: unknown;
+    oneOf?: false;
+}
+type ResolveEntityValuesParams = ResolveEntityValuesParamsWithCheckActualValueCheckMode | ResolveEntityValuesParamsWithDisabledOneOf | ResolveEntityValuesParamsWithEnabledOneOf;
+export declare const resolveEntityValues: (params: ResolveEntityValuesParams) => boolean;
+export {};

package/dist/src/utils/helpers/config/resolveEntityValues/resolveEntityValues.js

@@ -12,14 +12,17 @@ const _flat = require("flat");
 const _constants = require("../../../constants");
 const _isPlainObject = require("../../isPlainObject/isPlainObject");
 const _isPrimitive = require("../../isPrimitive/isPrimitive");
-const _isRegExp = require("../../isRegExp/isRegExp");
 const checkFunction = (checkMode, actualValue, descriptorValue)=>{
-    if (checkMode === 'function' && typeof descriptorValue === 'function') return descriptorValue(actualValue, checkFunction);
-    const actualValueString = String(actualValue);
-    if (checkMode === 'regExp' && (0, _isRegExp.isRegExp)(descriptorValue)) return descriptorValue.test(actualValueString);
     const isActualValueUndefined = typeof actualValue === 'undefined';
     if (checkMode === 'exists') return !isActualValueUndefined;
     if (checkMode === 'notExists') return isActualValueUndefined;
+    if (checkMode === 'function') {
+        return !!descriptorValue(actualValue, checkFunction);
+    }
+    const actualValueString = String(actualValue);
+    if (checkMode === 'regExp' && descriptorValue instanceof RegExp) {
+        return new RegExp(descriptorValue).test(actualValueString);
+    }
     // ✅ important:
     // cast values to string for ignore types of values
     const descriptorValueString = String(descriptorValue);
@@ -31,81 +34,44 @@ const checkFunction = (checkMode, actualValue, descriptorValue)=>{
     if (checkMode === 'notStartsWith') return !actualValueString.startsWith(descriptorValueString);
     if (checkMode === 'endsWith') return actualValueString.endsWith(descriptorValueString);
     if (checkMode === 'notEndsWith') return !actualValueString.endsWith(descriptorValueString);
-    throw new Error('Wrong checkMode');
+    throw new Error(`Wrong checkMode ${checkMode}`);
 };
-const resolveEntityValues = (checkMode, actualValue, descriptorValue)=>{
-    if (checkMode === 'function') return descriptorValue(actualValue, checkFunction);
-    if (checkMode === 'exists' || checkMode === 'notExists') return checkFunction(checkMode, actualValue, descriptorValue);
-    // ✅ actual: primitive, descriptor: primitive
-    const isActualValuePrimitive = (0, _isPrimitive.isPrimitive)(actualValue);
-    const isDescriptorValuePrimitive = (0, _isPrimitive.isPrimitive)(descriptorValue);
-    if (isActualValuePrimitive && isDescriptorValuePrimitive) return checkFunction(checkMode, actualValue, descriptorValue);
-    // ✅ actual: primitive, descriptor: array
-    const isDescriptorValueArray = Array.isArray(descriptorValue);
-    const isNegativeCheckMode = _constants.NEGATION_CHECK_MODES.includes(checkMode);
-    if (isActualValuePrimitive && isDescriptorValueArray) {
-        if (isNegativeCheckMode) {
-            return descriptorValue.every((descriptorValueElement)=>checkFunction(checkMode, actualValue, descriptorValueElement));
-        }
-        return descriptorValue.some((descriptorValueElement)=>checkFunction(checkMode, actualValue, descriptorValueElement));
+const compareEntityValues = (checkMode, actualValue, descriptorValue)=>{
+    if (checkMode === 'exists' || checkMode === 'notExists') {
+        return checkFunction(checkMode, actualValue);
     }
-    // ✅ actual: primitive, descriptor: object => skip
-    const isDescriptorValueObject = (0, _isPlainObject.isPlainObject)(descriptorValue) || (0, _isRegExp.isRegExp)(descriptorValue);
-    if (isActualValuePrimitive && isDescriptorValueObject) {
-        if (checkMode === 'regExp') return checkFunction(checkMode, actualValue, descriptorValue);
-        // ✅ important: resolving primitive with object make no sense
-        return isNegativeCheckMode;
+    if (checkMode === 'function') {
+        return !!descriptorValue(actualValue, checkFunction);
     }
-    // ✅ actual: array, descriptor: primitive => skip
-    const isActualValueArray = Array.isArray(actualValue);
-    // ✅ important: resolving array with primitive make no sense
-    if (isActualValueArray && isDescriptorValuePrimitive) return isNegativeCheckMode;
-    // ✅ actual: array, descriptor: array
-    if (isActualValueArray && isDescriptorValueArray) {
-        if (actualValue.length !== descriptorValue.length) return isNegativeCheckMode;
-        const flattenActualValue = (0, _flat.flatten)(actualValue);
-        const flattenDescriptorValue = (0, _flat.flatten)(descriptorValue);
-        if (Object.keys(flattenActualValue).length === Object.keys(flattenDescriptorValue).length) return Object.keys(flattenDescriptorValue).every((flattenDescriptorValueKey)=>checkFunction(checkMode, flattenActualValue[flattenDescriptorValueKey], flattenDescriptorValue[flattenDescriptorValueKey]));
-        return isNegativeCheckMode;
+    if (checkMode === 'regExp') {
+        return checkFunction(checkMode, actualValue, descriptorValue);
     }
-    // ✅ actual: array, descriptor: object => skip
-    if (isActualValueArray && isDescriptorValueObject) {
-        if (checkMode === 'regExp') return actualValue.some((actualValueElement)=>checkFunction(checkMode, actualValueElement, descriptorValue));
-        // ✅ important: resolving array with object make no sense
-        return isNegativeCheckMode;
-    }
-    // ✅ actual: object, descriptor: primitive => skip
-    const isActualValueObject = (0, _isPlainObject.isPlainObject)(actualValue);
-    // ✅ important: resolving object with primitive make no sense
-    if (isActualValueObject && isDescriptorValuePrimitive) return isNegativeCheckMode;
-    // ✅ actual: object, descriptor: array
-    if (isActualValueObject && isDescriptorValueArray) {
-        // ✅ important: any object can not pass RegExp check
-        if (checkMode === 'regExp') return false;
-        const flattenActualValue = (0, _flat.flatten)(actualValue);
-        if (isNegativeCheckMode) {
-            return descriptorValue.every((descriptorValueElement)=>{
-                const flattenDescriptorValue = (0, _flat.flatten)(descriptorValueElement);
-                if (Object.keys(flattenActualValue).length !== Object.keys(flattenDescriptorValue).length) return isNegativeCheckMode;
-                return Object.keys(flattenActualValue).every((flattenActualValueKey)=>checkFunction(checkMode, flattenActualValue[flattenActualValueKey], flattenDescriptorValue[flattenActualValueKey]));
-            });
-        }
-        return descriptorValue.some((descriptorValueElement)=>{
-            const flattenDescriptorValue = (0, _flat.flatten)(descriptorValueElement);
-            if (Object.keys(flattenActualValue).length !== Object.keys(flattenDescriptorValue).length) return isNegativeCheckMode;
-            return Object.keys(flattenActualValue).every((flattenActualValueKey)=>checkFunction(checkMode, flattenActualValue[flattenActualValueKey], flattenDescriptorValue[flattenActualValueKey]));
-        });
+    const isActualValuePrimitive = (0, _isPrimitive.isPrimitive)(actualValue);
+    const isDescriptorValuePrimitive = (0, _isPrimitive.isPrimitive)(descriptorValue);
+    if (isActualValuePrimitive && isDescriptorValuePrimitive) {
+        return checkFunction(checkMode, actualValue, descriptorValue);
     }
-    // ✅ actual: object, descriptor: object
+    const isActualValueObject = (0, _isPlainObject.isPlainObject)(actualValue) || Array.isArray(actualValue);
+    const isDescriptorValueObject = (0, _isPlainObject.isPlainObject)(descriptorValue) || Array.isArray(descriptorValue);
+    const isNegativeCheckMode = _constants.NEGATIVE_CHECK_MODES.includes(checkMode);
     if (isActualValueObject && isDescriptorValueObject) {
-        // ✅ important: any object can not pass RegExp check
-        if (checkMode === 'regExp') return false;
         const flattenActualValue = (0, _flat.flatten)(actualValue);
         const flattenDescriptorValue = (0, _flat.flatten)(descriptorValue);
-        if (Object.keys(flattenActualValue).length !== Object.keys(flattenDescriptorValue).length) return isNegativeCheckMode;
-        if (isNegativeCheckMode) {
-            return Object.keys(flattenDescriptorValue).some((flattenDescriptorValueKey)=>checkFunction(checkMode, flattenActualValue[flattenDescriptorValueKey], flattenDescriptorValue[flattenDescriptorValueKey]));
+        if (Object.keys(flattenActualValue).length !== Object.keys(flattenDescriptorValue).length) {
+            return isNegativeCheckMode;
         }
-        return Object.keys(flattenDescriptorValue).every((flattenDescriptorValueKey)=>checkFunction(checkMode, flattenActualValue[flattenDescriptorValueKey], flattenDescriptorValue[flattenDescriptorValueKey]));
+        return Object.keys(flattenDescriptorValue)[isNegativeCheckMode ? 'some' : 'every']((flattenDescriptorValueKey)=>checkFunction(checkMode, flattenActualValue[flattenDescriptorValueKey], flattenDescriptorValue[flattenDescriptorValueKey]));
+    }
+    return isNegativeCheckMode;
+};
+const resolveEntityValues = (params)=>{
+    const { checkMode, actualValue } = params;
+    if (checkMode === 'exists' || checkMode === 'notExists') {
+        return compareEntityValues(checkMode, actualValue);
+    }
+    const { oneOf, descriptorValue } = params;
+    if (!oneOf) {
+        return compareEntityValues(checkMode, actualValue, descriptorValue);
     }
+    return descriptorValue.some((descriptorValueElement)=>compareEntityValues(checkMode, actualValue, descriptorValueElement));
 };

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

@@ -1 +1,2 @@
+export * from './isFileDescriptor/isFileDescriptor';
 export * from './isFilePathValid/isFilePathValid';

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./isFileDescriptor/isFileDescriptor"), exports);
 _export_star(require("./isFilePathValid/isFilePathValid"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/dist/src/utils/helpers/files/isFileDescriptor/isFileDescriptor.d.ts

@@ -0,0 +1,2 @@
+import type { FileDescriptor } from '../../../types';
+export declare const isFileDescriptor: (value: any) => value is FileDescriptor;

package/dist/src/utils/helpers/files/isFileDescriptor/isFileDescriptor.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isFileDescriptor", {
+    enumerable: true,
+    get: function() {
+        return isFileDescriptor;
+    }
+});
+const _nodebuffer = require("node:buffer");
+const _zod = require("zod");
+const isFileDescriptor = (value)=>_zod.z.object({
+        path: _zod.z.string(),
+        file: _zod.z.instanceof(_nodebuffer.Buffer)
+    }).strict().safeParse(value).success;

package/dist/src/utils/helpers/files/isFilePathValid/isFilePathValid.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "isFilePathValid", {
         return isFilePathValid;
     }
 });
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -16,8 +16,8 @@ function _interop_require_default(obj) {
 }
 const isFilePathValid = (path)=>{
     try {
-        if (!_fs.default.existsSync(path)) return false;
-        if (!_fs.default.statSync(path).isFile()) return false;
+        if (!_nodefs.default.existsSync(path)) return false;
+        if (!_nodefs.default.statSync(path).isFile()) return false;
         return true;
     } catch (error) {
         console.error(error);

package/dist/src/utils/helpers/graphql/parseQuery/parseQuery.d.ts

@@ -1,7 +1,7 @@
 import type { OperationTypeNode } from 'graphql';
 interface ParseDocumentNodeResult {
-    operationType: OperationTypeNode;
     operationName: string | undefined;
+    operationType: OperationTypeNode;
 }
 export declare const parseQuery: (query: string) => ParseDocumentNodeResult | null;
 export {};

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

@@ -7,7 +7,6 @@ export * from './graphql';
 export * from './interceptors';
 export * from './isPlainObject/isPlainObject';
 export * from './isPrimitive/isPrimitive';
-export * from './isRegExp/isRegExp';
 export * from './logger';
 export * from './sleep';
 export * from './url';

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

@@ -11,7 +11,6 @@ _export_star(require("./graphql"), exports);
 _export_star(require("./interceptors"), exports);
 _export_star(require("./isPlainObject/isPlainObject"), exports);
 _export_star(require("./isPrimitive/isPrimitive"), exports);
-_export_star(require("./isRegExp/isRegExp"), exports);
 _export_star(require("./logger"), exports);
 _export_star(require("./sleep"), exports);
 _export_star(require("./url"), exports);

package/dist/src/utils/helpers/interceptors/callRequestInterceptor/callRequestInterceptor.d.ts

@@ -1,8 +1,8 @@
 import type { Request } from 'express';
 import type { RequestInterceptor } from '../../../types';
 interface CallRequestInterceptorParams {
-    request: Request;
     interceptor: RequestInterceptor;
+    request: Request;
 }
 export declare const callRequestInterceptor: (params: CallRequestInterceptorParams) => Promise<void>;
 export {};

package/dist/src/utils/helpers/interceptors/callRequestInterceptor/callRequestInterceptor.js

@@ -25,7 +25,8 @@ const callRequestInterceptor = async (params)=>{
         getHeader,
         getHeaders,
         getCookie,
-        log
+        log,
+        orm: request.context.orm
     };
     await interceptor(requestInterceptorParams);
 };

package/dist/src/utils/helpers/interceptors/callResponseInterceptors/callResponseInterceptors.js

@@ -12,8 +12,10 @@ const _logger = require("../../logger");
 const _setDelay = require("../helpers/setDelay");
 const callResponseInterceptors = async (params)=>{
     const { data, request, response, interceptors } = params;
-    const getHeader = (field)=>response.getHeader(field);
-    const getHeaders = ()=>response.getHeaders();
+    const getRequestHeader = (field)=>request.headers[field];
+    const getRequestHeaders = ()=>request.headers;
+    const getResponseHeader = (field)=>response.getHeader(field);
+    const getResponseHeaders = ()=>response.getHeaders();
     const setHeader = (field, value)=>{
         response.set(field, value);
     };
@@ -50,13 +52,16 @@ const callResponseInterceptors = async (params)=>{
         setStatusCode,
         setHeader,
         appendHeader,
-        getHeader,
-        getHeaders,
+        getRequestHeader,
+        getRequestHeaders,
+        getResponseHeader,
+        getResponseHeaders,
         setCookie,
         getCookie,
         clearCookie,
         attachment,
-        log
+        log,
+        orm: request.context.orm
     };
     let updatedData = data;
     if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.routeInterceptor) {

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

@@ -1,8 +1,8 @@
 import type { Request, Response } from 'express';
 import type { Data, Logger } from '../../../types';
 interface CallResponseLoggerParams {
-    logger?: Logger<'response'>;
     data: Data;
+    logger?: Logger<'response'>;
     request: Request;
     response: Response;
 }

package/dist/src/utils/helpers/tests/createTmpDir.js

@@ -8,12 +8,12 @@ Object.defineProperty(exports, "createTmpDir", {
         return createTmpDir;
     }
 });
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _os = /*#__PURE__*/ _interop_require_default(require("os"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodeos = /*#__PURE__*/ _interop_require_default(require("node:os"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-const createTmpDir = ()=>_fs.default.mkdtempSync(`${_os.default.tmpdir()}${_path.default.sep}`);
+const createTmpDir = ()=>_nodefs.default.mkdtempSync(`${_nodeos.default.tmpdir()}${_nodepath.default.sep}`);

package/dist/src/utils/helpers/url/convertWin32PathToUnix/convertWin32PathToUnix.js

@@ -8,4 +8,4 @@ Object.defineProperty(exports, "convertWin32PathToUnix", {
         return convertWin32PathToUnix;
     }
 });
-const convertWin32PathToUnix = (win32Path)=>win32Path.replace(/^\\\\\?\\/, '').replace(/\\/g, '/').replace(/\/\/+/g, '/');
+const convertWin32PathToUnix = (win32Path)=>win32Path.replace(/^\\\\\?\\/, '').replace(/\\/g, '/').replace(/\/{2,}/g, '/');

package/dist/src/utils/helpers/url/urlJoin/urlJoin.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "urlJoin", {
         return urlJoin;
     }
 });
-const _os = /*#__PURE__*/ _interop_require_default(require("os"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _nodeos = /*#__PURE__*/ _interop_require_default(require("node:os"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _convertWin32PathToUnix = require("../convertWin32PathToUnix/convertWin32PathToUnix");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -17,6 +17,6 @@ function _interop_require_default(obj) {
     };
 }
 const urlJoin = (...paths)=>{
-    const pathsToJoin = _os.default.platform() === 'win32' ? paths.map((path)=>(0, _convertWin32PathToUnix.convertWin32PathToUnix)(path)) : paths;
-    return _path.default.posix.join(...pathsToJoin);
+    const pathsToJoin = _nodeos.default.platform() === 'win32' ? paths.map((path)=>(0, _convertWin32PathToUnix.convertWin32PathToUnix)(path)) : paths;
+    return _nodepath.default.posix.join(...pathsToJoin);
 };

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

@@ -1,11 +1,18 @@
 export type CheckActualValueCheckMode = 'exists' | 'notExists';
 export type CompareWithDescriptorAnyValueCheckMode = 'equals' | 'notEquals';
-export type CompareWithDescriptorStringValueCheckMode = 'includes' | 'notIncludes' | 'startsWith' | 'notStartsWith' | 'endsWith' | 'notEndsWith';
+export type CompareWithDescriptorStringValueCheckMode = 'endsWith' | 'includes' | 'notEndsWith' | 'notIncludes' | 'notStartsWith' | 'startsWith';
 export type CompareWithDescriptorValueCheckMode = CompareWithDescriptorAnyValueCheckMode | CompareWithDescriptorStringValueCheckMode;
-export type CalculateByDescriptorValueCheckMode = 'regExp' | 'function';
-export type CheckMode = CheckActualValueCheckMode | CompareWithDescriptorValueCheckMode | CalculateByDescriptorValueCheckMode;
-export interface EntityDescriptor {
-    checkMode: CheckMode;
-    value?: any;
-}
+export type CalculateByDescriptorValueCheckMode = 'function' | 'regExp';
+export type CheckMode = CalculateByDescriptorValueCheckMode | CheckActualValueCheckMode | CompareWithDescriptorValueCheckMode;
+export type EntityDescriptor<Check extends CheckMode = CheckMode, Value = any> = Check extends CheckActualValueCheckMode ? {
+    checkMode: Check;
+} : {
+    checkMode: Check;
+    value: Value;
+    oneOf?: false;
+} | {
+    checkMode: Check;
+    value: Value[];
+    oneOf: true;
+};
 export type CheckFunction = <ActualValue = any, DescriptorValue = any>(checkMode: CheckMode, actualValue: ActualValue, descriptorValue?: DescriptorValue) => boolean;