mock-config-server 3.0.0 → 3.0.1

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

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

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

@@ -0,0 +1,9 @@
+import type { CalculateByDescriptorValueCheckMode, CheckMode, CompareWithDescriptorValueCheckMode, CheckActualValueCheckMode, CompareWithDescriptorAnyValueCheckMode, CompareWithDescriptorStringValueCheckMode } from '../types';
+export declare const CHECK_ACTUAL_VALUE_CHECK_MODES: CheckActualValueCheckMode[];
+export declare const COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES: CompareWithDescriptorAnyValueCheckMode[];
+export declare const COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES: CompareWithDescriptorStringValueCheckMode[];
+export declare const COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES: CompareWithDescriptorValueCheckMode[];
+export declare const CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES: CalculateByDescriptorValueCheckMode[];
+export declare const CHECK_MODES: CheckMode[];
+export declare const PLAIN_ENTITY_CHECK_MODES: CheckMode[];
+export declare const NEGATION_CHECK_MODES: CheckMode[];

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEGATION_CHECK_MODES = exports.PLAIN_ENTITY_CHECK_MODES = exports.CHECK_MODES = exports.CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES = exports.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES = exports.COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES = exports.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES = exports.CHECK_ACTUAL_VALUE_CHECK_MODES = void 0;
+exports.CHECK_ACTUAL_VALUE_CHECK_MODES = ['exists', 'notExists'];
+exports.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES = ['equals', 'notEquals'];
+exports.COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES = ['includes', 'notIncludes', 'startsWith', 'notStartsWith', 'endsWith', 'notEndsWith'];
+exports.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES = [
+    ...exports.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES,
+    ...exports.COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES
+];
+exports.CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES = [
+    'regExp',
+    'function'
+];
+exports.CHECK_MODES = [
+    ...exports.CHECK_ACTUAL_VALUE_CHECK_MODES,
+    ...exports.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES,
+    ...exports.CALCULATE_BY_DESCRIPTOR_VALUE_CHECK_MODES
+];
+exports.PLAIN_ENTITY_CHECK_MODES = [
+    ...exports.CHECK_ACTUAL_VALUE_CHECK_MODES,
+    ...exports.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES,
+    'function'
+];
+exports.NEGATION_CHECK_MODES = [
+    'notExists',
+    'notEquals',
+    'notIncludes',
+    'notStartsWith',
+    'notEndsWith'
+];

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

@@ -0,0 +1,11 @@
+export declare const DEFAULT: {
+    PORT: number;
+    CORS: {
+        ORIGIN: string;
+        METHODS: string;
+        ALLOWED_HEADERS: string;
+        EXPOSED_HEADERS: string;
+        CREDENTIALS: boolean;
+        MAX_AGE: number;
+    };
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT = void 0;
+exports.DEFAULT = {
+    PORT: 31299,
+    CORS: {
+        ORIGIN: '*',
+        METHODS: 'GET,OPTIONS,PUT,PATCH,POST,DELETE',
+        ALLOWED_HEADERS: '*',
+        EXPOSED_HEADERS: '*',
+        CREDENTIALS: true,
+        MAX_AGE: 3600
+    }
+};

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

@@ -0,0 +1,3 @@
+export * from './appPath';
+export * from './checkModes';
+export * from './default';

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./appPath"), exports);
+__exportStar(require("./checkModes"), exports);
+__exportStar(require("./default"), exports);

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

@@ -0,0 +1,2 @@
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+export declare const asyncHandler: (fn: (request: Request, response: Response, next: NextFunction) => Promise<any>) => RequestHandler;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncHandler = void 0;
+const asyncHandler = (fn) => (request, response, next) => Promise.resolve(fn(request, response, next)).catch(next);
+exports.asyncHandler = asyncHandler;

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

@@ -0,0 +1 @@
+export * from './resolveEntityValues/resolveEntityValues';

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resolveEntityValues/resolveEntityValues"), exports);

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

@@ -0,0 +1,2 @@
+import type { CheckMode } from '../../../types';
+export declare const resolveEntityValues: (checkMode: CheckMode, actualValue: any, descriptorValue?: any) => any;

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEntityValues = void 0;
+const flat_1 = require("flat");
+const constants_1 = require("../../../constants");
+const isPlainObject_1 = require("../../isPlainObject/isPlainObject");
+const isPrimitive_1 = require("../../isPrimitive/isPrimitive");
+const isRegExp_1 = 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_1.isRegExp)(descriptorValue))
+        return descriptorValue.test(actualValueString);
+    const isActualValueUndefined = typeof actualValue === 'undefined';
+    if (checkMode === 'exists')
+        return !isActualValueUndefined;
+    if (checkMode === 'notExists')
+        return isActualValueUndefined;
+    // ✅ important:
+    // cast values to string for ignore types of values
+    const descriptorValueString = String(descriptorValue);
+    if (checkMode === 'equals')
+        return actualValueString === descriptorValueString;
+    if (checkMode === 'notEquals')
+        return actualValueString !== descriptorValueString;
+    if (checkMode === 'includes')
+        return actualValueString.includes(descriptorValueString);
+    if (checkMode === 'notIncludes')
+        return !actualValueString.includes(descriptorValueString);
+    if (checkMode === 'startsWith')
+        return actualValueString.startsWith(descriptorValueString);
+    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');
+};
+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_1.isPrimitive)(actualValue);
+    const isDescriptorValuePrimitive = (0, isPrimitive_1.isPrimitive)(descriptorValue);
+    if (isActualValuePrimitive && isDescriptorValuePrimitive)
+        return checkFunction(checkMode, actualValue, descriptorValue);
+    // ✅ actual: primitive, descriptor: array
+    const isDescriptorValueArray = Array.isArray(descriptorValue);
+    const isNegativeCheckMode = constants_1.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));
+    }
+    // ✅ actual: primitive, descriptor: object => skip
+    const isDescriptorValueObject = (0, isPlainObject_1.isPlainObject)(descriptorValue) || (0, isRegExp_1.isRegExp)(descriptorValue);
+    if (isActualValuePrimitive && isDescriptorValueObject) {
+        if (checkMode === 'regExp')
+            return checkFunction(checkMode, actualValue, descriptorValue);
+        // ✅ important: resolving primitive with object make no sense
+        return isNegativeCheckMode;
+    }
+    // ✅ 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_1.flatten)(actualValue);
+        const flattenDescriptorValue = (0, flat_1.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;
+    }
+    // ✅ 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_1.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_1.flatten)(actualValue);
+        if (isNegativeCheckMode) {
+            return descriptorValue.every((descriptorValueElement) => {
+                const flattenDescriptorValue = (0, flat_1.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_1.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]));
+        });
+    }
+    // ✅ actual: object, descriptor: object
+    if (isActualValueObject && isDescriptorValueObject) {
+        // ✅ important: any object can not pass RegExp check
+        if (checkMode === 'regExp')
+            return false;
+        const flattenActualValue = (0, flat_1.flatten)(actualValue);
+        const flattenDescriptorValue = (0, flat_1.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]));
+        }
+        return Object.keys(flattenDescriptorValue).every((flattenDescriptorValueKey) => checkFunction(checkMode, flattenActualValue[flattenDescriptorValueKey], flattenDescriptorValue[flattenDescriptorValueKey]));
+    }
+};
+exports.resolveEntityValues = resolveEntityValues;

package/dist/src/utils/helpers/entities/convertToEntityDescriptor/convertToEntityDescriptor.d.ts

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

package/dist/src/utils/helpers/entities/convertToEntityDescriptor/convertToEntityDescriptor.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToEntityDescriptor = void 0;
+const isEntityDescriptor_1 = require("../isEntityDescriptor/isEntityDescriptor");
+const convertToEntityDescriptor = (valueOrDescriptor) => (0, isEntityDescriptor_1.isEntityDescriptor)(valueOrDescriptor)
+    ? valueOrDescriptor
+    : { checkMode: 'equals', value: valueOrDescriptor };
+exports.convertToEntityDescriptor = convertToEntityDescriptor;

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

@@ -0,0 +1,2 @@
+export * from './convertToEntityDescriptor/convertToEntityDescriptor';
+export * from './isEntityDescriptor/isEntityDescriptor';

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./convertToEntityDescriptor/convertToEntityDescriptor"), exports);
+__exportStar(require("./isEntityDescriptor/isEntityDescriptor"), exports);

package/dist/src/utils/helpers/entities/isEntityDescriptor/isEntityDescriptor.d.ts

@@ -0,0 +1 @@
+export declare const isEntityDescriptor: (value: any) => boolean;

package/dist/src/utils/helpers/entities/isEntityDescriptor/isEntityDescriptor.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEntityDescriptor = void 0;
+const isPlainObject_1 = require("../../isPlainObject/isPlainObject");
+const isEntityDescriptor = (value) => (0, isPlainObject_1.isPlainObject)(value) && 'checkMode' in value;
+exports.isEntityDescriptor = isEntityDescriptor;

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

@@ -0,0 +1,3 @@
+import type { Request } from 'express';
+import type { GraphQLInput } from '../../../types';
+export declare const getGraphQLInput: (request: Request) => GraphQLInput;

package/dist/src/utils/helpers/graphql/getGraphQLInput/getGraphQLInput.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphQLInput = void 0;
+const getGraphQLInput = (request) => {
+    if (request.method === 'GET') {
+        const { query, variables } = request.query;
+        return {
+            query: query?.toString(),
+            variables: JSON.parse(variables ?? '{}')
+        };
+    }
+    if (request.method === 'POST') {
+        const { query, variables } = request.body;
+        return {
+            query,
+            variables: variables ?? {}
+        };
+    }
+    throw new Error('Not allowed request method for graphql request');
+};
+exports.getGraphQLInput = getGraphQLInput;

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

@@ -0,0 +1,3 @@
+export * from './parseGraphQLRequest/parseGraphQLRequest';
+export * from './parseQuery/parseQuery';
+export * from './getGraphQLInput/getGraphQLInput';

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parseGraphQLRequest/parseGraphQLRequest"), exports);
+__exportStar(require("./parseQuery/parseQuery"), exports);
+__exportStar(require("./getGraphQLInput/getGraphQLInput"), exports);

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

@@ -0,0 +1,3 @@
+import type { Request } from 'express';
+import { parseQuery } from '../parseQuery/parseQuery';
+export declare const parseGraphQLRequest: (request: Request) => ReturnType<typeof parseQuery>;

package/dist/src/utils/helpers/graphql/parseGraphQLRequest/parseGraphQLRequest.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGraphQLRequest = void 0;
+const getGraphQLInput_1 = require("../getGraphQLInput/getGraphQLInput");
+const parseQuery_1 = require("../parseQuery/parseQuery");
+const parseGraphQLRequest = (request) => {
+    const graphQLInput = (0, getGraphQLInput_1.getGraphQLInput)(request);
+    if (!graphQLInput.query)
+        return null;
+    return (0, parseQuery_1.parseQuery)(graphQLInput.query);
+};
+exports.parseGraphQLRequest = parseGraphQLRequest;

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

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

package/dist/src/utils/helpers/graphql/parseQuery/parseQuery.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuery = void 0;
+const graphql_1 = require("graphql");
+const parseDocumentNode = (node) => {
+    const operationDefinition = node.definitions.find((definition) => definition.kind === 'OperationDefinition');
+    return {
+        operationType: operationDefinition.operation,
+        operationName: operationDefinition.name?.value ?? ''
+    };
+};
+const parseQuery = (query) => {
+    try {
+        const document = (0, graphql_1.parse)(query);
+        return parseDocumentNode(document);
+    }
+    catch {
+        return null;
+    }
+};
+exports.parseQuery = parseQuery;

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

@@ -0,0 +1,10 @@
+export * from './isPlainObject/isPlainObject';
+export * from './isPrimitive/isPrimitive';
+export * from './isRegExp/isRegExp';
+export * from './sleep';
+export * from './url';
+export * from './config';
+export * from './entities';
+export * from './interceptors';
+export * from './graphql';
+export * from './asyncHandler';

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

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./isPlainObject/isPlainObject"), exports);
+__exportStar(require("./isPrimitive/isPrimitive"), exports);
+__exportStar(require("./isRegExp/isRegExp"), exports);
+__exportStar(require("./sleep"), exports);
+__exportStar(require("./url"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./entities"), exports);
+__exportStar(require("./interceptors"), exports);
+__exportStar(require("./graphql"), exports);
+__exportStar(require("./asyncHandler"), exports);

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callRequestInterceptor = void 0;
+const setDelay_1 = require("../helpers/setDelay");
+const callRequestInterceptor = async (params) => {
+    const { request, interceptor } = params;
+    const getHeader = (field) => request.headers[field];
+    const getHeaders = () => request.headers;
+    const getCookie = (name) => request.cookies[name];
+    const requestInterceptorParams = {
+        request,
+        setDelay: setDelay_1.setDelay,
+        getHeader,
+        getHeaders,
+        getCookie
+    };
+    await interceptor(requestInterceptorParams);
+};
+exports.callRequestInterceptor = callRequestInterceptor;

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

@@ -0,0 +1,15 @@
+import type { Request, Response } from 'express';
+import type { Data, ResponseInterceptor } from '../../../types';
+interface CallResponseInterceptorsParams {
+    data: Data;
+    request: Request;
+    response: Response;
+    interceptors?: {
+        routeInterceptor?: ResponseInterceptor;
+        requestInterceptor?: ResponseInterceptor;
+        apiInterceptor?: ResponseInterceptor;
+        serverInterceptor?: ResponseInterceptor;
+    };
+}
+export declare const callResponseInterceptors: (params: CallResponseInterceptorsParams) => Promise<Data>;
+export {};

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callResponseInterceptors = void 0;
+const setDelay_1 = require("../helpers/setDelay");
+const callResponseInterceptors = async (params) => {
+    const { data, request, response, interceptors } = params;
+    const getHeader = (field) => response.getHeader(field);
+    const getHeaders = () => response.getHeaders();
+    const getCookie = (name) => request.cookies[name];
+    const setStatusCode = (statusCode) => {
+        response.statusCode = statusCode;
+    };
+    const setHeader = (field, value) => response.set(field, value);
+    const appendHeader = (field, value) => response.append(field, value);
+    const setCookie = (name, value, options) => {
+        if (options) {
+            response.cookie(name, value, options);
+        }
+        response.cookie(name, value);
+    };
+    const clearCookie = (name, options) => response.clearCookie(name, options);
+    const attachment = (filename) => response.attachment(filename);
+    const ResponseInterceptorParams = {
+        request,
+        response,
+        setDelay: setDelay_1.setDelay,
+        setStatusCode,
+        setHeader,
+        appendHeader,
+        getHeader,
+        getHeaders,
+        setCookie,
+        getCookie,
+        clearCookie,
+        attachment
+    };
+    let updatedData = data;
+    if (interceptors?.routeInterceptor) {
+        updatedData = await interceptors.routeInterceptor(updatedData, ResponseInterceptorParams);
+    }
+    if (interceptors?.requestInterceptor) {
+        updatedData = await interceptors.requestInterceptor(updatedData, ResponseInterceptorParams);
+    }
+    if (interceptors?.apiInterceptor) {
+        updatedData = await interceptors.apiInterceptor(updatedData, ResponseInterceptorParams);
+    }
+    if (interceptors?.serverInterceptor) {
+        updatedData = await interceptors.serverInterceptor(updatedData, ResponseInterceptorParams);
+    }
+    return updatedData;
+};
+exports.callResponseInterceptors = callResponseInterceptors;

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

@@ -0,0 +1 @@
+export declare const setDelay: (delay: number) => Promise<void>;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDelay = void 0;
+const sleep_1 = require("../../sleep");
+const setDelay = async (delay) => {
+    await (0, sleep_1.sleep)(delay === Infinity ? 99999999 : delay);
+};
+exports.setDelay = setDelay;

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

@@ -0,0 +1,2 @@
+export * from './callRequestInterceptor/callRequestInterceptor';
+export * from './callResponseInterceptors/callResponseInterceptors';

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./callRequestInterceptor/callRequestInterceptor"), exports);
+__exportStar(require("./callResponseInterceptors/callResponseInterceptors"), exports);

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

@@ -0,0 +1 @@
+export declare const isPlainObject: (value: any) => value is Record<string, unknown>;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = void 0;
+const isPlainObject = (value) => typeof value === 'object' &&
+    !Array.isArray(value) &&
+    value !== null &&
+    !(value instanceof RegExp);
+exports.isPlainObject = isPlainObject;

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

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

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimitive = void 0;
+const isPrimitive = (value) => value !== Object(value);
+exports.isPrimitive = isPrimitive;

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

@@ -0,0 +1 @@
+export declare const isRegExp: (value: any) => value is RegExp;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegExp = void 0;
+const isRegExp = (value) => value instanceof RegExp;
+exports.isRegExp = isRegExp;