mock-config-server 1.0.3 → 2.0.0

package/dist/bin/resolveExportsFromSourceCode.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveExportsFromSourceCode = void 0;
-const resolveExportsFromSourceCode = (sourceCode) => {
-    // @ts-ignore
-    const moduleInstance = new module.constructor();
-    // eslint-disable-next-line no-underscore-dangle
-    moduleInstance._compile(sourceCode, '');
-    return moduleInstance.exports;
-};
-exports.resolveExportsFromSourceCode = resolveExportsFromSourceCode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExportsFromSourceCode = void 0;
+const resolveExportsFromSourceCode = (sourceCode) => {
+    // @ts-ignore
+    const moduleInstance = new module.constructor();
+    // eslint-disable-next-line no-underscore-dangle
+    moduleInstance._compile(sourceCode, '');
+    return moduleInstance.exports;
+};
+exports.resolveExportsFromSourceCode = resolveExportsFromSourceCode;

package/dist/bin/validateMockServerConfig/validateBaseUrl/validateBaseUrl.d.ts

@@ -0,0 +1 @@
+export declare const validateBaseUrl: (baseUrl: unknown) => void;

package/dist/bin/validateMockServerConfig/validateBaseUrl/validateBaseUrl.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBaseUrl = void 0;
+const validateBaseUrl = (baseUrl) => {
+    if (typeof baseUrl !== 'string' && typeof baseUrl !== 'undefined') {
+        throw new Error('baseUrl');
+    }
+    if (typeof baseUrl === 'string' && !baseUrl.startsWith('/')) {
+        throw new Error('baseUrl');
+    }
+};
+exports.validateBaseUrl = validateBaseUrl;

package/dist/bin/validateMockServerConfig/validateCors/validateCors.d.ts

@@ -0,0 +1 @@
+export declare const validateCors: (cors: unknown) => void;

package/dist/bin/validateMockServerConfig/validateCors/validateCors.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCors = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateOrigin = (origin) => {
+    const isOriginArray = Array.isArray(origin);
+    if (isOriginArray) {
+        origin.forEach((originElement, index) => {
+            const isOriginElementStringOrRegExp = typeof originElement === 'string' || originElement instanceof RegExp;
+            if (!isOriginElementStringOrRegExp) {
+                throw new Error(`origin[${index}]`);
+            }
+        });
+        return;
+    }
+    const isOriginStringOrRegexp = typeof origin === 'string' || origin instanceof RegExp;
+    const isOriginFunction = typeof origin === 'function';
+    if (!isOriginStringOrRegexp && !isOriginFunction) {
+        throw new Error('origin');
+    }
+};
+const validateMethods = (methods) => {
+    const isMethodsArray = Array.isArray(methods);
+    if (isMethodsArray) {
+        const allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
+        methods.forEach((method, index) => {
+            // ✅ important:
+            // compare without 'toUpperCase' because 'Access-Control-Allow-Methods' value is case-sensitive
+            if (!allowedMethods.includes(method)) {
+                throw new Error(`methods[${index}]`);
+            }
+        });
+        return;
+    }
+    if (typeof methods !== 'undefined') {
+        throw new Error('methods');
+    }
+};
+const validateHeaders = (headers) => {
+    const isHeadersArray = Array.isArray(headers);
+    if (isHeadersArray) {
+        headers.forEach((header, index) => {
+            if (typeof header !== 'string') {
+                throw new Error(`headers[${index}]`);
+            }
+        });
+        return;
+    }
+    if (typeof headers !== 'undefined') {
+        throw new Error('headers');
+    }
+};
+const validateCredentials = (credentials) => {
+    if (typeof credentials !== 'boolean' && typeof credentials !== 'undefined') {
+        throw new Error('credentials');
+    }
+};
+const validateMaxAge = (maxAge) => {
+    if (typeof maxAge !== 'number' && typeof maxAge !== 'undefined') {
+        throw new Error('maxAge');
+    }
+};
+const validateCors = (cors) => {
+    const isCorsObject = (0, helpers_1.isPlainObject)(cors);
+    if (isCorsObject) {
+        try {
+            validateOrigin(cors.origin);
+            validateMethods(cors.methods);
+            validateHeaders(cors.headers);
+            validateCredentials(cors.credentials);
+            validateMaxAge(cors.maxAge);
+        }
+        catch (error) {
+            throw new Error(`cors.${error.message}`);
+        }
+        return;
+    }
+    if (typeof cors !== 'undefined') {
+        throw new Error('cors');
+    }
+};
+exports.validateCors = validateCors;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateGraphqlConfig.d.ts

@@ -0,0 +1 @@
+export declare const validateGraphqlConfig: (graphqlConfig: unknown) => void;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateGraphqlConfig.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGraphqlConfig = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateBaseUrl_1 = require("../validateBaseUrl/validateBaseUrl");
+const validateInterceptors_1 = require("../validateInterceptors/validateInterceptors");
+const validateRoutes_1 = require("./validateRoutes/validateRoutes");
+const validateConfigs = (configs) => {
+    const isConfigsArray = Array.isArray(configs);
+    if (isConfigsArray) {
+        configs.forEach((config, index) => {
+            const { operationType, operationName } = config;
+            if (operationType !== 'query' && operationType !== 'mutation') {
+                throw new Error(`configs[${index}].operationType`);
+            }
+            const isOperationNameStringOrRegExp = typeof operationName === 'string' || operationName instanceof RegExp;
+            if (!isOperationNameStringOrRegExp) {
+                throw new Error(`configs[${index}].operationName`);
+            }
+            try {
+                (0, validateRoutes_1.validateRoutes)(config.routes, operationType);
+                (0, validateInterceptors_1.validateInterceptors)(config.interceptors);
+            }
+            catch (error) {
+                throw new Error(`configs[${index}].${error.message}`);
+            }
+        });
+        return;
+    }
+    throw new Error('configs');
+};
+const validateGraphqlConfig = (graphqlConfig) => {
+    const isGraphqlConfigObject = (0, helpers_1.isPlainObject)(graphqlConfig);
+    if (isGraphqlConfigObject) {
+        try {
+            (0, validateBaseUrl_1.validateBaseUrl)(graphqlConfig.baseUrl);
+            validateConfigs(graphqlConfig.configs);
+        }
+        catch (error) {
+            throw new Error(`graphql.${error.message}`);
+        }
+        return;
+    }
+    if (typeof graphqlConfig !== 'undefined') {
+        throw new Error('graphql');
+    }
+};
+exports.validateGraphqlConfig = validateGraphqlConfig;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateRoutes/validateRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLOperationType } from '../../../../src';
+export declare const validateRoutes: (routes: unknown, operationType: GraphQLOperationType) => void;

package/dist/bin/validateMockServerConfig/validateGraphqlConfig/validateRoutes/validateRoutes.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoutes = void 0;
+const helpers_1 = require("../../../../src/utils/helpers");
+const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
+const ALLOWED_ENTITIES_BY_OPERATION_TYPE = {
+    query: ['headers', 'query', 'variables'],
+    mutation: ['headers', 'query', 'variables']
+};
+const validateHeadersOrQuery = (headersOrQuery, entity) => {
+    const isHeadersOrQueryObject = (0, helpers_1.isPlainObject)(headersOrQuery);
+    if (isHeadersOrQueryObject) {
+        Object.entries(headersOrQuery).forEach(([headerOrQueryKey, headerOrQueryValue]) => {
+            if (typeof headerOrQueryValue !== 'string') {
+                throw new Error(`${entity}.${headerOrQueryKey}`);
+            }
+        });
+        return;
+    }
+    throw new Error(entity);
+};
+const validateEntities = (entities, operationType) => {
+    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
+    if (isEntitiesObject) {
+        Object.keys(entities).forEach((entity) => {
+            const isEntityAllowed = ALLOWED_ENTITIES_BY_OPERATION_TYPE[operationType].includes(entity);
+            if (!isEntityAllowed) {
+                throw new Error(`entities.${entity}`);
+            }
+            if (entity === 'headers' || entity === 'query') {
+                try {
+                    const headersOrQuery = entities[entity];
+                    return validateHeadersOrQuery(headersOrQuery, entity);
+                }
+                catch (error) {
+                    throw new Error(`entities.${error.message}`);
+                }
+            }
+        });
+        return;
+    }
+    if (typeof entities !== 'undefined') {
+        throw new Error('entities');
+    }
+};
+const validateRoutes = (routes, operationType) => {
+    const isRoutesArray = Array.isArray(routes);
+    if (isRoutesArray) {
+        routes.forEach((route, index) => {
+            const isRouteObject = (0, helpers_1.isPlainObject)(route);
+            if (isRouteObject) {
+                const isRouteHasDataProperty = 'data' in route;
+                if (!isRouteHasDataProperty) {
+                    throw new Error(`routes[${index}]`);
+                }
+                try {
+                    validateEntities(route.entities, operationType);
+                    (0, validateInterceptors_1.validateInterceptors)(route.interceptors);
+                }
+                catch (error) {
+                    throw new Error(`routes[${index}].${error.message}`);
+                }
+                return;
+            }
+            throw new Error(`routes[${index}]`);
+        });
+        return;
+    }
+    throw new Error('routes');
+};
+exports.validateRoutes = validateRoutes;

package/dist/bin/validateMockServerConfig/validateInterceptors/validateInterceptors.d.ts

@@ -0,0 +1 @@
+export declare const validateInterceptors: (interceptors: unknown) => void;

package/dist/bin/validateMockServerConfig/validateInterceptors/validateInterceptors.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInterceptors = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateInterceptors = (interceptors) => {
+    const isInterceptorsObject = (0, helpers_1.isPlainObject)(interceptors);
+    if (isInterceptorsObject) {
+        const { request, response } = interceptors;
+        if (typeof request !== 'function' && typeof request !== 'undefined') {
+            throw new Error('interceptors.request');
+        }
+        if (typeof response !== 'function' && typeof response !== 'undefined') {
+            throw new Error('interceptors.response');
+        }
+        return;
+    }
+    if (typeof interceptors !== 'undefined') {
+        throw new Error('interceptors');
+    }
+};
+exports.validateInterceptors = validateInterceptors;

package/dist/bin/validateMockServerConfig/validateMockServerConfig.d.ts

@@ -0,0 +1 @@
+export declare const validateMockServerConfig: (mockServerConfig: unknown) => void;

package/dist/bin/validateMockServerConfig/validateMockServerConfig.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMockServerConfig = void 0;
+const helpers_1 = require("../../src/utils/helpers");
+const validateBaseUrl_1 = require("./validateBaseUrl/validateBaseUrl");
+const validateCors_1 = require("./validateCors/validateCors");
+const validateGraphqlConfig_1 = require("./validateGraphqlConfig/validateGraphqlConfig");
+const validateInterceptors_1 = require("./validateInterceptors/validateInterceptors");
+const validatePort_1 = require("./validatePort/validatePort");
+const validateRestConfig_1 = require("./validateRestConfig/validateRestConfig");
+const validateStaticPath_1 = require("./validateStaticPath/validateStaticPath");
+const validateMockServerConfig = (mockServerConfig) => {
+    if (!(0, helpers_1.isPlainObject)(mockServerConfig)) {
+        throw new Error('configuration should be plain object; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
+    }
+    if (!mockServerConfig.rest && !mockServerConfig.graphql) {
+        throw new Error('configuration should contain at least one of these configs: rest | graphql; see our doc (https://www.npmjs.com/package/mock-config-server) for more information');
+    }
+    try {
+        if (mockServerConfig.rest)
+            (0, validateRestConfig_1.validateRestConfig)(mockServerConfig.rest);
+        if (mockServerConfig.graphql)
+            (0, validateGraphqlConfig_1.validateGraphqlConfig)(mockServerConfig.graphql);
+        (0, validateBaseUrl_1.validateBaseUrl)(mockServerConfig.baseUrl);
+        (0, validatePort_1.validatePort)(mockServerConfig.port);
+        (0, validateStaticPath_1.validateStaticPath)(mockServerConfig.staticPath);
+        (0, validateInterceptors_1.validateInterceptors)(mockServerConfig.interceptors);
+        (0, validateCors_1.validateCors)(mockServerConfig.cors);
+    }
+    catch (error) {
+        throw new Error(`Validation Error: configuration.${error.message} does not match the API schema. Click here to see correct type: https://github.com/siberiacancode/mock-config-server`);
+    }
+};
+exports.validateMockServerConfig = validateMockServerConfig;

package/dist/bin/validateMockServerConfig/validatePort/validatePort.d.ts

@@ -0,0 +1 @@
+export declare const validatePort: (port: unknown) => void;

package/dist/bin/validateMockServerConfig/validatePort/validatePort.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePort = void 0;
+const validatePort = (port) => {
+    if (typeof port !== 'number' && typeof port !== 'undefined') {
+        throw new Error('port');
+    }
+};
+exports.validatePort = validatePort;

package/dist/bin/validateMockServerConfig/validateRestConfig/validateRestConfig.d.ts

@@ -0,0 +1 @@
+export declare const validateRestConfig: (restConfig: unknown) => void;

package/dist/bin/validateMockServerConfig/validateRestConfig/validateRestConfig.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRestConfig = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateBaseUrl_1 = require("../validateBaseUrl/validateBaseUrl");
+const validateInterceptors_1 = require("../validateInterceptors/validateInterceptors");
+const validateRoutes_1 = require("./validateRoutes/validateRoutes");
+const validateConfigs = (configs) => {
+    const isConfigsArray = Array.isArray(configs);
+    if (isConfigsArray) {
+        configs.forEach((config, index) => {
+            const { path, method } = config;
+            const isPathStringWithLeadingSlash = typeof path === 'string' && path.startsWith('/');
+            if (!isPathStringWithLeadingSlash && !(path instanceof RegExp)) {
+                throw new Error(`configs[${index}].path`);
+            }
+            // ✅ important:
+            // compare without 'toLowerCase' because Express methods names is case-sensitive
+            const allowedMethods = ['get', 'post', 'delete', 'put', 'patch'];
+            const isMethodAllowed = typeof method === 'string' && allowedMethods.includes(method);
+            if (!isMethodAllowed) {
+                throw new Error(`configs[${index}].method`);
+            }
+            try {
+                (0, validateRoutes_1.validateRoutes)(config.routes, method);
+                (0, validateInterceptors_1.validateInterceptors)(config.interceptors);
+            }
+            catch (error) {
+                throw new Error(`configs[${index}].${error.message}`);
+            }
+        });
+        return;
+    }
+    throw new Error('configs');
+};
+const validateRestConfig = (restConfig) => {
+    const isRestConfigObject = (0, helpers_1.isPlainObject)(restConfig);
+    if (isRestConfigObject) {
+        try {
+            (0, validateBaseUrl_1.validateBaseUrl)(restConfig.baseUrl);
+            validateConfigs(restConfig.configs);
+        }
+        catch (error) {
+            throw new Error(`rest.${error.message}`);
+        }
+        return;
+    }
+    if (typeof restConfig !== 'undefined') {
+        throw new Error('rest');
+    }
+};
+exports.validateRestConfig = validateRestConfig;

package/dist/bin/validateMockServerConfig/validateRestConfig/validateRoutes/validateRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { RestMethod } from '../../../../src';
+export declare const validateRoutes: (routes: unknown, method: RestMethod) => void;

package/dist/bin/validateMockServerConfig/validateRestConfig/validateRoutes/validateRoutes.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoutes = void 0;
+const helpers_1 = require("../../../../src/utils/helpers");
+const validateInterceptors_1 = require("../../validateInterceptors/validateInterceptors");
+const ALLOWED_ENTITIES_BY_METHOD = {
+    get: ['headers', 'query', 'params'],
+    delete: ['headers', 'query', 'params'],
+    post: ['headers', 'query', 'params', 'body'],
+    put: ['headers', 'query', 'params', 'body'],
+    patch: ['headers', 'query', 'params', 'body']
+};
+const validateHeadersOrParams = (headersOrParams, entity) => {
+    const isHeadersOrParamsObject = (0, helpers_1.isPlainObject)(headersOrParams);
+    if (isHeadersOrParamsObject) {
+        Object.entries(headersOrParams).forEach(([headerOrParamKey, headerOrParamValue]) => {
+            if (typeof headerOrParamValue !== 'string') {
+                throw new Error(`${entity}.${headerOrParamKey}`);
+            }
+        });
+        return;
+    }
+    throw new Error(entity);
+};
+const validateQuery = (query, entity) => {
+    const isQueryObject = (0, helpers_1.isPlainObject)(query);
+    if (isQueryObject) {
+        Object.entries(query).forEach(([queryKey, queryValue]) => {
+            const isQueryValueArray = Array.isArray(queryValue);
+            if (isQueryValueArray) {
+                queryValue.forEach((queryValueElement, index) => {
+                    if (typeof queryValueElement !== 'string') {
+                        throw new Error(`${entity}.${queryKey}[${index}]`);
+                    }
+                });
+                return;
+            }
+            if (typeof queryValue !== 'string') {
+                throw new Error(`${entity}.${queryKey}`);
+            }
+        });
+        return;
+    }
+    throw new Error(entity);
+};
+const validateEntities = (entities, method) => {
+    const isEntitiesObject = (0, helpers_1.isPlainObject)(entities);
+    if (isEntitiesObject) {
+        Object.keys(entities).forEach((entity) => {
+            const isEntityAllowed = ALLOWED_ENTITIES_BY_METHOD[method].includes(entity);
+            if (!isEntityAllowed) {
+                throw new Error(`entities.${entity}`);
+            }
+            if (entity === 'headers' || entity === 'params') {
+                try {
+                    const headersOrParams = entities[entity];
+                    return validateHeadersOrParams(headersOrParams, entity);
+                }
+                catch (error) {
+                    throw new Error(`entities.${error.message}`);
+                }
+            }
+            if (entity === 'query') {
+                try {
+                    const query = entities[entity];
+                    return validateQuery(query, entity);
+                }
+                catch (error) {
+                    throw new Error(`entities.${error.message}`);
+                }
+            }
+        });
+        return;
+    }
+    if (typeof entities !== 'undefined') {
+        throw new Error('entities');
+    }
+};
+const validateRoutes = (routes, method) => {
+    const isRoutesArray = Array.isArray(routes);
+    if (isRoutesArray) {
+        routes.forEach((route, index) => {
+            const isRouteObject = (0, helpers_1.isPlainObject)(route);
+            if (isRouteObject) {
+                const isRouteHasDataProperty = 'data' in route;
+                if (!isRouteHasDataProperty) {
+                    throw new Error(`routes[${index}]`);
+                }
+                try {
+                    validateEntities(route.entities, method);
+                    (0, validateInterceptors_1.validateInterceptors)(route.interceptors);
+                }
+                catch (error) {
+                    throw new Error(`routes[${index}].${error.message}`);
+                }
+                return;
+            }
+            throw new Error(`routes[${index}]`);
+        });
+        return;
+    }
+    throw new Error('routes');
+};
+exports.validateRoutes = validateRoutes;

package/dist/bin/validateMockServerConfig/validateStaticPath/validateStaticPath.d.ts

@@ -0,0 +1 @@
+export declare const validateStaticPath: (staticPath: unknown) => void;

package/dist/bin/validateMockServerConfig/validateStaticPath/validateStaticPath.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStaticPath = void 0;
+const helpers_1 = require("../../../src/utils/helpers");
+const validateStaticPath = (staticPath) => {
+    const isStaticPathArray = Array.isArray(staticPath);
+    if (isStaticPathArray) {
+        staticPath.forEach((staticPathElement, index) => {
+            const isStaticPathElementObject = (0, helpers_1.isPlainObject)(staticPathElement);
+            if (isStaticPathElementObject) {
+                const { prefix, path } = staticPathElement;
+                if (typeof prefix !== 'string' || !prefix.startsWith('/')) {
+                    throw new Error(`staticPath[${index}].prefix`);
+                }
+                if (typeof path !== 'string' || !path.startsWith('/')) {
+                    throw new Error(`staticPath[${index}].path`);
+                }
+                return;
+            }
+            if (typeof staticPathElement !== 'string' || !staticPathElement.startsWith('/')) {
+                throw new Error(`staticPath[${index}]`);
+            }
+        });
+        return;
+    }
+    const isStaticPathObject = (0, helpers_1.isPlainObject)(staticPath);
+    if (isStaticPathObject) {
+        const { prefix, path } = staticPath;
+        if (typeof prefix !== 'string' || !prefix.startsWith('/')) {
+            throw new Error('staticPath.prefix');
+        }
+        if (typeof path !== 'string' || !path.startsWith('/')) {
+            throw new Error('staticPath.path');
+        }
+        return;
+    }
+    if (typeof staticPath !== 'string' && typeof staticPath !== 'undefined') {
+        throw new Error('staticPath');
+    }
+    if (typeof staticPath === 'string' && !staticPath.startsWith('/')) {
+        throw new Error('staticPath');
+    }
+};
+exports.validateStaticPath = validateStaticPath;

package/dist/index.d.ts

@@ -1 +1 @@
-export * from './src';
+export * from './src';

package/dist/index.js

@@ -1,17 +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("./src"), exports);
+"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("./src"), exports);

package/dist/src/configs/isEntitiesEqual/isEntityValuesEqual.d.ts

@@ -1,2 +1 @@
-import type { Entities, EntitiesValues } from '../../utils/types';
-export declare const isEntityValuesEqual: <Entity extends Entities>(firstEntityValue: EntitiesValues[Entity], secondEntityValue: EntitiesValues[Entity]) => boolean;
+export declare const isEntityValuesEqual: (firstEntityValue: any, secondEntityValue: any) => boolean;

package/dist/src/configs/isEntitiesEqual/isEntityValuesEqual.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEntityValuesEqual = void 0;
-const flat_1 = require("flat");
-const helpers_1 = require("../../utils/helpers");
-const isEntityValuesEqual = (firstEntityValue, secondEntityValue) => {
-    const isValuesArePlainObjects = (0, helpers_1.isPlainObject)(firstEntityValue) && (0, helpers_1.isPlainObject)(secondEntityValue);
-    if (isValuesArePlainObjects) {
-        const flattenFirstEntityValue = (0, flat_1.flatten)(firstEntityValue);
-        const flattenSecondEntityValue = (0, flat_1.flatten)(secondEntityValue);
-        return Object.keys(flattenFirstEntityValue).every((key) => 
-        // ✅ important:
-        // call 'toString' for ignore types of values
-        flattenFirstEntityValue[key].toString() === flattenSecondEntityValue[key]?.toString());
-    }
-    const isValuesAreArrays = Array.isArray(firstEntityValue) && Array.isArray(secondEntityValue);
-    if (isValuesAreArrays) {
-        const flattenFirstEntityValue = (0, flat_1.flatten)(firstEntityValue);
-        const flattenSecondEntityValue = (0, flat_1.flatten)(secondEntityValue);
-        return (Object.keys(flattenFirstEntityValue).length ===
-            Object.keys(flattenSecondEntityValue).length &&
-            Object.keys(flattenFirstEntityValue).every((key) => 
-            // ✅ important:
-            // call 'toString' for ignore types of values
-            flattenFirstEntityValue[key].toString() === flattenSecondEntityValue[key].toString()));
-    }
-    return firstEntityValue.toString() === secondEntityValue.toString();
-};
-exports.isEntityValuesEqual = isEntityValuesEqual;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEntityValuesEqual = void 0;
+const flat_1 = require("flat");
+const helpers_1 = require("../../utils/helpers");
+const isEntityValuesEqual = (firstEntityValue, secondEntityValue) => {
+    const isValuesArePlainObjects = (0, helpers_1.isPlainObject)(firstEntityValue) && (0, helpers_1.isPlainObject)(secondEntityValue);
+    if (isValuesArePlainObjects) {
+        const flattenFirstEntityValue = (0, flat_1.flatten)(firstEntityValue);
+        const flattenSecondEntityValue = (0, flat_1.flatten)(secondEntityValue);
+        return Object.keys(flattenFirstEntityValue).every((key) => 
+        // ✅ important:
+        // call 'toString' for ignore types of values
+        flattenFirstEntityValue[key].toString() === flattenSecondEntityValue[key]?.toString());
+    }
+    const isValuesAreArrays = Array.isArray(firstEntityValue) && Array.isArray(secondEntityValue);
+    if (isValuesAreArrays) {
+        const flattenFirstEntityValue = (0, flat_1.flatten)(firstEntityValue);
+        const flattenSecondEntityValue = (0, flat_1.flatten)(secondEntityValue);
+        return (Object.keys(flattenFirstEntityValue).length ===
+            Object.keys(flattenSecondEntityValue).length &&
+            Object.keys(flattenFirstEntityValue).every((key) => 
+            // ✅ important:
+            // call 'toString' for ignore types of values
+            flattenFirstEntityValue[key].toString() === flattenSecondEntityValue[key].toString()));
+    }
+    return `${firstEntityValue}` === `${secondEntityValue}`;
+};
+exports.isEntityValuesEqual = isEntityValuesEqual;