mock-config-server 3.7.1 → 4.0.0

package/dist/src/core/database/createOrm/createOrm.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createOrm", {
+    enumerable: true,
+    get: function() {
+        return createOrm;
+    }
+});
+const _flat = require("flat");
+const _helpers = require("../createDatabaseRoutes/helpers");
+const createOrm = (storage)=>{
+    const { shallowDatabase, nestedDatabase } = (0, _helpers.splitDatabaseByNesting)(storage.read());
+    const nestedOrm = Object.keys(nestedDatabase).reduce((orm, key)=>{
+        orm[key] = {
+            create: (item)=>{
+                const collection = storage.read(key);
+                const newResourceId = (0, _helpers.createNewId)(collection);
+                const newResource = {
+                    ...item,
+                    id: newResourceId
+                };
+                storage.write([
+                    key,
+                    collection.length
+                ], newResource);
+                return newResource;
+            },
+            update: (id, item)=>{
+                const collection = storage.read(key);
+                const currentResourceIndex = (0, _helpers.findIndexById)(collection, id);
+                const currentResource = storage.read([
+                    key,
+                    currentResourceIndex
+                ]);
+                const updatedResource = {
+                    ...currentResource,
+                    ...item,
+                    id
+                };
+                storage.write([
+                    key,
+                    currentResourceIndex
+                ], updatedResource);
+            },
+            delete: (id)=>{
+                const collection = storage.read(key);
+                const currentResourceIndex = (0, _helpers.findIndexById)(collection, id);
+                storage.delete([
+                    key,
+                    currentResourceIndex
+                ]);
+            },
+            createMany (items) {
+                items.forEach((item)=>this.create(item));
+            },
+            updateMany (ids, item) {
+                ids.forEach((id)=>this.update(id, item));
+                return ids.length;
+            },
+            deleteMany (ids) {
+                ids.forEach((id)=>this.delete(id));
+            },
+            findById: (id)=>{
+                const collection = storage.read(key);
+                const currentResourceIndex = (0, _helpers.findIndexById)(collection, id);
+                return storage.read([
+                    key,
+                    currentResourceIndex
+                ]);
+            },
+            findMany: (filters)=>{
+                const collection = storage.read(key);
+                if (!filters) return collection;
+                const flattenedFilters = (0, _flat.flatten)(filters);
+                return collection.filter((resource)=>{
+                    const flattenedResource = (0, _flat.flatten)(resource);
+                    return Object.entries(flattenedFilters).every(([key, value])=>flattenedResource[key] === value);
+                });
+            },
+            findFirst: (filters)=>{
+                const collection = storage.read(key);
+                if (!filters) return collection[0];
+                const flattenedFilters = (0, _flat.flatten)(filters);
+                return collection.find((resource)=>{
+                    const flattenedResource = (0, _flat.flatten)(resource);
+                    return Object.entries(flattenedFilters).every(([key, value])=>flattenedResource[key] === value);
+                });
+            },
+            exists: (filters)=>{
+                const collection = storage.read(key);
+                const flattenedFilters = (0, _flat.flatten)(filters);
+                return collection.some((resource)=>{
+                    const flattenedResource = (0, _flat.flatten)(resource);
+                    return Object.entries(flattenedFilters).every(([key, value])=>flattenedResource[key] === value);
+                });
+            },
+            count: ()=>storage.read(key).length
+        };
+        orm[key].createMany = orm[key].createMany.bind(orm[key]);
+        orm[key].updateMany = orm[key].updateMany.bind(orm[key]);
+        orm[key].deleteMany = orm[key].deleteMany.bind(orm[key]);
+        return orm;
+    }, {});
+    const shallowOrm = Object.keys(shallowDatabase).reduce((orm, key)=>{
+        orm[key] = {
+            get: ()=>storage.read(key),
+            update: (data)=>{
+                storage.write(key, data);
+            }
+        };
+        return orm;
+    }, {});
+    return {
+        ...nestedOrm,
+        ...shallowOrm
+    };
+};

package/dist/src/core/database/createStorage/createStorage.d.ts

@@ -0,0 +1,2 @@
+import { FileStorage, MemoryStorage } from '../createDatabaseRoutes/storages';
+export declare const createStorage: <Data extends `${string}.json` | Record<string, unknown>>(data: Data) => FileStorage<Record<import("../../..").StorageIndex, any>> | MemoryStorage<Record<import("../../..").StorageIndex, any>>;

package/dist/src/core/database/createStorage/createStorage.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createStorage", {
+    enumerable: true,
+    get: function() {
+        return createStorage;
+    }
+});
+const _storages = require("../createDatabaseRoutes/storages");
+const isVariableJsonFile = (variable)=>typeof variable === 'string' && variable.endsWith('.json');
+const createStorage = (data)=>isVariableJsonFile(data) ? new _storages.FileStorage(data) : new _storages.MemoryStorage(data);

package/dist/src/core/database/index.d.ts

@@ -1 +1,3 @@
 export * from './createDatabaseRoutes/createDatabaseRoutes';
+export * from './createOrm/createOrm';
+export * from './createStorage/createStorage';

package/dist/src/core/database/index.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./createDatabaseRoutes/createDatabaseRoutes"), exports);
+_export_star(require("./createOrm/createOrm"), exports);
+_export_star(require("./createStorage/createStorage"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/src/core/graphql/createGraphQLRoutes/createGraphQLRoutes.d.ts

@@ -1,8 +1,8 @@
 import type { IRouter } from 'express';
 import type { GraphqlConfig, Interceptors } from '../../../utils/types';
 interface CreateGraphQLRoutesParams {
-    router: IRouter;
     graphqlConfig: GraphqlConfig;
+    router: IRouter;
     serverResponseInterceptor?: Interceptors<'graphql'>['response'];
 }
 export declare const createGraphQLRoutes: ({ router, graphqlConfig, serverResponseInterceptor }: CreateGraphQLRoutesParams) => IRouter;

package/dist/src/core/graphql/createGraphQLRoutes/createGraphQLRoutes.js

@@ -30,11 +30,10 @@ const createGraphQLRoutes = ({ router, graphqlConfig, serverResponseInterceptor
         const matchedRequestConfig = preparedGraphQLRequestConfig.find((requestConfig)=>{
             var _graphQLInput_query;
             if (requestConfig.operationType !== query.operationType) return false;
-            if ('query' in requestConfig && requestConfig.query.replace(/\s+/gi, ' ') !== ((_graphQLInput_query = graphQLInput.query) === null || _graphQLInput_query === void 0 ? void 0 : _graphQLInput_query.replace(/\s+/gi, ' '))) return false;
+            if ('query' in requestConfig && requestConfig.query.replace(/\s+/g, '') !== ((_graphQLInput_query = graphQLInput.query) === null || _graphQLInput_query === void 0 ? void 0 : _graphQLInput_query.replace(/\s+/g, ''))) return false;
             if ('operationName' in requestConfig) {
                 if (!query.operationName) return false;
-                if (requestConfig.operationName instanceof RegExp) return new RegExp(requestConfig.operationName).test(query.operationName);
-                return requestConfig.operationName === query.operationName;
+                return requestConfig.operationName instanceof RegExp ? new RegExp(requestConfig.operationName).test(query.operationName) : requestConfig.operationName === query.operationName;
             }
             return true;
         });
@@ -49,24 +48,47 @@ const createGraphQLRoutes = ({ router, graphqlConfig, serverResponseInterceptor
         }
         const matchedRouteConfig = matchedRequestConfig.routes.find(({ entities })=>{
             if (!entities) return true;
-            const entries = Object.entries(entities);
-            return entries.every(([entityName, entityDescriptorOrValue])=>{
-                const { checkMode, value: entityDescriptorValue } = (0, _helpers.convertToEntityDescriptor)(entityDescriptorOrValue);
-                // ✅ important: check whole variables as plain value strictly if descriptor used for variables
+            const entityEntries = Object.entries(entities);
+            return entityEntries.every(([entityName, entityDescriptorOrValue])=>{
+                // ✅ important:
+                // check whole variables as plain value strictly if descriptor used for variables
                 const isEntityVariablesByTopLevelDescriptor = entityName === 'variables' && (0, _helpers.isEntityDescriptor)(entityDescriptorOrValue);
                 if (isEntityVariablesByTopLevelDescriptor) {
-                    return (0, _helpers.resolveEntityValues)(checkMode, graphQLInput.variables, entityDescriptorValue);
+                    const variablesDescriptor = entityDescriptorOrValue;
+                    if (variablesDescriptor.checkMode === 'exists' || variablesDescriptor.checkMode === 'notExists') {
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: graphQLInput.variables,
+                            checkMode: variablesDescriptor.checkMode
+                        });
+                    }
+                    var _variablesDescriptor_oneOf;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: graphQLInput.variables,
+                        descriptorValue: variablesDescriptor.value,
+                        checkMode: variablesDescriptor.checkMode,
+                        oneOf: (_variablesDescriptor_oneOf = variablesDescriptor.oneOf) !== null && _variablesDescriptor_oneOf !== void 0 ? _variablesDescriptor_oneOf : false
+                    });
                 }
-                const isEntityVariablesByTopLevelArray = entityName === 'variables' && Array.isArray(entityDescriptorOrValue);
-                if (isEntityVariablesByTopLevelArray) {
-                    return entityDescriptorOrValue.some((entityDescriptorOrValueElement)=>(0, _helpers.resolveEntityValues)(checkMode, graphQLInput.variables, entityDescriptorOrValueElement));
-                }
-                const recordOrArrayEntries = Object.entries(entityDescriptorOrValue);
-                return recordOrArrayEntries.every(([entityKey, entityValue])=>{
-                    const { checkMode, value: descriptorValue } = (0, _helpers.convertToEntityDescriptor)(entityValue);
-                    const flattenEntity = (0, _flat.flatten)(entityName === 'variables' ? graphQLInput.variables : request[entityName]);
+                const actualEntity = (0, _flat.flatten)(entityName === 'variables' ? graphQLInput.variables : request[entityName]);
+                const entityValueEntries = Object.entries(entityDescriptorOrValue);
+                return entityValueEntries.every(([entityPropertyKey, entityPropertyDescriptorOrValue])=>{
+                    const entityPropertyDescriptor = (0, _helpers.convertToEntityDescriptor)(entityPropertyDescriptorOrValue);
                     // ✅ important: transform header keys to lower case because browsers send headers in lowercase
-                    return (0, _helpers.resolveEntityValues)(checkMode, flattenEntity[entityName === 'headers' ? entityKey.toLowerCase() : entityKey], descriptorValue);
+                    const actualPropertyKey = entityName === 'headers' ? entityPropertyKey.toLowerCase() : entityPropertyKey;
+                    const actualPropertyValue = actualEntity[actualPropertyKey];
+                    if (entityPropertyDescriptor.checkMode === 'exists' || entityPropertyDescriptor.checkMode === 'notExists') {
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: actualPropertyValue,
+                            checkMode: entityPropertyDescriptor.checkMode
+                        });
+                    }
+                    var _entityPropertyDescriptor_oneOf;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: actualPropertyValue,
+                        descriptorValue: entityPropertyDescriptor.value,
+                        checkMode: entityPropertyDescriptor.checkMode,
+                        oneOf: (_entityPropertyDescriptor_oneOf = entityPropertyDescriptor.oneOf) !== null && _entityPropertyDescriptor_oneOf !== void 0 ? _entityPropertyDescriptor_oneOf : false
+                    });
                 });
             });
         });

package/dist/src/core/graphql/createGraphQLRoutes/helpers/prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs.js

@@ -18,7 +18,7 @@ const calculateRouteConfigWeight = (graphQLRouteConfig)=>{
     if (cookies) routeConfigWeight += Object.keys(cookies).length;
     if (query) routeConfigWeight += Object.keys(query).length;
     if (variables) {
-        if ((0, _helpers.isPlainObject)(variables) && variables.checkMode) {
+        if (variables.checkMode) {
             // ✅ important:
             // check that actual value check modes does not have `value` for compare
             if (variables.checkMode === 'exists' || variables.checkMode === 'notExists') {
@@ -28,7 +28,7 @@ const calculateRouteConfigWeight = (graphQLRouteConfig)=>{
             routeConfigWeight += (0, _helpers.isPlainObject)(variables.value) ? Object.keys(variables.value).length : 1;
             return routeConfigWeight;
         }
-        routeConfigWeight += (0, _helpers.isPlainObject)(variables) ? Object.keys(variables).length : 1;
+        routeConfigWeight += Object.keys(variables).length;
     }
     return routeConfigWeight;
 };

package/dist/src/core/middlewares/contextMiddleware/contextMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { Express } from 'express';
-import type { GraphQLEntity, GraphQLOperationName, GraphQLOperationType } from '../../../utils/types';
+import type { GraphQLEntity, GraphQLOperationName, GraphQLOperationType, MockServerConfig } from '../../../utils/types';
 declare global {
     namespace Express {
         interface Request {
@@ -14,4 +14,4 @@ declare global {
         }
     }
 }
-export declare const contextMiddleware: (server: Express) => void;
+export declare const contextMiddleware: (server: Express, { database }: Pick<MockServerConfig, "database">) => void;

package/dist/src/core/middlewares/contextMiddleware/contextMiddleware.js

@@ -8,9 +8,18 @@ Object.defineProperty(exports, "contextMiddleware", {
         return contextMiddleware;
     }
 });
+const _database = require("../../database");
 const _helpers = require("../../../utils/helpers");
-const contextMiddleware = (server)=>{
+const contextMiddleware = (server, { database })=>{
     let requestId = 0;
+    const context = {
+        orm: {}
+    };
+    if (database) {
+        const storage = (0, _database.createStorage)(database.data);
+        const orm = (0, _database.createOrm)(storage);
+        context.orm = orm;
+    }
     server.use((request, _response, next)=>{
         requestId += 1;
         request.id = requestId;
@@ -30,6 +39,7 @@ const contextMiddleware = (server)=>{
             }
         }
         request.graphQL = null;
+        request.context = context;
         return next();
     });
 };

package/dist/src/core/middlewares/destroyerMiddleware/destroyerMiddleware.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import type { Server } from 'http';
+import type { Server } from 'node:http';
 type ServerWithDestroyer = Server & {
     destroy: Server['close'];
 };

package/dist/src/core/middlewares/index.d.ts

@@ -4,6 +4,5 @@ export * from './corsMiddleware/corsMiddleware';
 export * from './destroyerMiddleware/destroyerMiddleware';
 export * from './errorMiddleware/errorMiddleware';
 export * from './noCorsMiddleware/noCorsMiddleware';
-export * from './notFoundMiddleware/notFoundMiddleware';
 export * from './requestInterceptorMiddleware/requestInterceptorMiddleware';
 export * from './staticMiddleware/staticMiddleware';

package/dist/src/core/middlewares/index.js

@@ -8,7 +8,6 @@ _export_star(require("./corsMiddleware/corsMiddleware"), exports);
 _export_star(require("./destroyerMiddleware/destroyerMiddleware"), exports);
 _export_star(require("./errorMiddleware/errorMiddleware"), exports);
 _export_star(require("./noCorsMiddleware/noCorsMiddleware"), exports);
-_export_star(require("./notFoundMiddleware/notFoundMiddleware"), exports);
 _export_star(require("./requestInterceptorMiddleware/requestInterceptorMiddleware"), exports);
 _export_star(require("./staticMiddleware/staticMiddleware"), exports);
 function _export_star(from, to) {

package/dist/src/core/middlewares/requestInterceptorMiddleware/requestInterceptorMiddleware.d.ts

@@ -1,9 +1,9 @@
 import type { Express } from 'express';
 import type { RequestInterceptor } from '../../../utils/types';
 interface RequestInterceptorMiddlewareParams {
-    server: Express;
-    path?: string;
     interceptor: RequestInterceptor;
+    path?: string;
+    server: Express;
 }
 export declare const requestInterceptorMiddleware: ({ server, path, interceptor }: RequestInterceptorMiddlewareParams) => void;
 export {};

package/dist/src/core/rest/createRestRoutes/createRestRoutes.d.ts

@@ -1,8 +1,8 @@
 import type { IRouter } from 'express';
 import type { Interceptors, RestConfig } from '../../../utils/types';
 interface CreateRestRoutesParams {
-    router: IRouter;
     restConfig: RestConfig;
+    router: IRouter;
     serverResponseInterceptor?: Interceptors<'rest'>['response'];
 }
 export declare const createRestRoutes: ({ router, restConfig, serverResponseInterceptor }: CreateRestRoutesParams) => IRouter;

package/dist/src/core/rest/createRestRoutes/createRestRoutes.js

@@ -9,7 +9,8 @@ Object.defineProperty(exports, "createRestRoutes", {
     }
 });
 const _flat = require("flat");
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _helpers = require("../../../utils/helpers");
 const _helpers1 = require("./helpers");
 function _interop_require_default(obj) {
@@ -29,29 +30,56 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
             }
             const matchedRouteConfig = requestConfig.routes.find(({ entities })=>{
                 if (!entities) return true;
-                const entries = Object.entries(entities);
-                return entries.every(([entityName, entityDescriptorOrValue])=>{
-                    const { checkMode, value: descriptorValue } = (0, _helpers.convertToEntityDescriptor)(entityDescriptorOrValue);
+                const entityEntries = Object.entries(entities);
+                return entityEntries.every(([entityName, entityDescriptorOrValue])=>{
                     // ✅ important:
                     // check whole body as plain value strictly if descriptor used for body
                     const isEntityBodyByTopLevelDescriptor = entityName === 'body' && (0, _helpers.isEntityDescriptor)(entityDescriptorOrValue);
                     if (isEntityBodyByTopLevelDescriptor) {
-                        // ✅ important:
-                        // bodyParser sets body to empty object if body not sent or invalid, so assume {} as undefined
-                        return (0, _helpers.resolveEntityValues)(checkMode, Object.keys(request.body).length ? request.body : undefined, descriptorValue);
+                        const bodyDescriptor = entityDescriptorOrValue;
+                        if (bodyDescriptor.checkMode === 'exists' || bodyDescriptor.checkMode === 'notExists') {
+                            return (0, _helpers.resolveEntityValues)({
+                                actualValue: request.body,
+                                checkMode: bodyDescriptor.checkMode
+                            });
+                        }
+                        var _bodyDescriptor_oneOf;
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: request.body,
+                            descriptorValue: bodyDescriptor.value,
+                            checkMode: bodyDescriptor.checkMode,
+                            oneOf: (_bodyDescriptor_oneOf = bodyDescriptor.oneOf) !== null && _bodyDescriptor_oneOf !== void 0 ? _bodyDescriptor_oneOf : false
+                        });
                     }
                     const isEntityBodyByTopLevelArray = entityName === 'body' && Array.isArray(entityDescriptorOrValue);
                     if (isEntityBodyByTopLevelArray) {
-                        return entityDescriptorOrValue.some((entityDescriptorOrValueElement)=>// ✅ important:
-                            // bodyParser sets body to empty object if body not sent or invalid, so assume {} as undefined
-                            (0, _helpers.resolveEntityValues)(checkMode, Object.keys(request.body).length ? request.body : undefined, entityDescriptorOrValueElement));
+                        if (!Array.isArray(request.body)) return false;
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: request.body,
+                            descriptorValue: entityDescriptorOrValue,
+                            checkMode: 'equals'
+                        });
                     }
-                    const recordOrArrayEntries = Object.entries(entityDescriptorOrValue);
-                    return recordOrArrayEntries.every(([entityKey, mappedEntityDescriptor])=>{
-                        const { checkMode, value: descriptorValue } = (0, _helpers.convertToEntityDescriptor)(mappedEntityDescriptor);
-                        const flattenEntity = (0, _flat.flatten)(request[entityName]);
+                    const actualEntity = (0, _flat.flatten)(request[entityName]);
+                    const entityValueEntries = Object.entries(entityDescriptorOrValue);
+                    return entityValueEntries.every(([entityPropertyKey, entityPropertyDescriptorOrValue])=>{
+                        const entityPropertyDescriptor = (0, _helpers.convertToEntityDescriptor)(entityPropertyDescriptorOrValue);
                         // ✅ important: transform header keys to lower case because browsers send headers in lowercase
-                        return (0, _helpers.resolveEntityValues)(checkMode, flattenEntity[entityName === 'headers' ? entityKey.toLowerCase() : entityKey], descriptorValue);
+                        const actualPropertyKey = entityName === 'headers' ? entityPropertyKey.toLowerCase() : entityPropertyKey;
+                        const actualPropertyValue = actualEntity[actualPropertyKey];
+                        if (entityPropertyDescriptor.checkMode === 'exists' || entityPropertyDescriptor.checkMode === 'notExists') {
+                            return (0, _helpers.resolveEntityValues)({
+                                actualValue: actualPropertyValue,
+                                checkMode: entityPropertyDescriptor.checkMode
+                            });
+                        }
+                        var _entityPropertyDescriptor_oneOf;
+                        return (0, _helpers.resolveEntityValues)({
+                            actualValue: actualPropertyValue,
+                            descriptorValue: entityPropertyDescriptor.value,
+                            checkMode: entityPropertyDescriptor.checkMode,
+                            oneOf: (_entityPropertyDescriptor_oneOf = entityPropertyDescriptor.oneOf) !== null && _entityPropertyDescriptor_oneOf !== void 0 ? _entityPropertyDescriptor_oneOf : false
+                        });
                     });
                 });
             });
@@ -62,13 +90,13 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
                     interceptor: matchedRouteConfig.interceptors.request
                 });
             }
-            let matchedRouteConfigData = null;
+            const matchedRouteConfigDataDescriptor = {};
             if (((_matchedRouteConfig_settings = matchedRouteConfig.settings) === null || _matchedRouteConfig_settings === void 0 ? void 0 : _matchedRouteConfig_settings.polling) && 'queue' in matchedRouteConfig) {
                 if (!matchedRouteConfig.queue.length) return next();
                 const shallowMatchedRouteConfig = matchedRouteConfig;
                 var _shallowMatchedRouteConfig___pollingIndex;
                 let index = (_shallowMatchedRouteConfig___pollingIndex = shallowMatchedRouteConfig.__pollingIndex) !== null && _shallowMatchedRouteConfig___pollingIndex !== void 0 ? _shallowMatchedRouteConfig___pollingIndex : 0;
-                const { time, data } = matchedRouteConfig.queue[index];
+                const { time } = matchedRouteConfig.queue[index];
                 const updateIndex = ()=>{
                     if (matchedRouteConfig.queue.length - 1 === index) {
                         index = 0;
@@ -77,6 +105,7 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
                     }
                     shallowMatchedRouteConfig.__pollingIndex = index;
                 };
+                const queueItem = matchedRouteConfig.queue[index];
                 if (time && !shallowMatchedRouteConfig.__timeoutInProgress) {
                     shallowMatchedRouteConfig.__timeoutInProgress = true;
                     setTimeout(()=>{
@@ -87,16 +116,21 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
                 if (!time && !shallowMatchedRouteConfig.__timeoutInProgress) {
                     updateIndex();
                 }
-                matchedRouteConfigData = data;
+                if ('data' in queueItem) {
+                    matchedRouteConfigDataDescriptor.data = queueItem.data;
+                }
+                if ('file' in queueItem) {
+                    if (!(0, _helpers.isFilePathValid)(queueItem.file)) return next();
+                    matchedRouteConfigDataDescriptor.file = queueItem.file;
+                }
             }
             if ('data' in matchedRouteConfig) {
-                matchedRouteConfigData = matchedRouteConfig.data;
+                matchedRouteConfigDataDescriptor.data = matchedRouteConfig.data;
             }
             if ('file' in matchedRouteConfig) {
                 if (!(0, _helpers.isFilePathValid)(matchedRouteConfig.file)) return next();
+                matchedRouteConfigDataDescriptor.file = matchedRouteConfig.file;
             }
-            var _matchedRouteConfig_entities;
-            const resolvedData = typeof matchedRouteConfigData === 'function' ? await matchedRouteConfigData(request, (_matchedRouteConfig_entities = matchedRouteConfig.entities) !== null && _matchedRouteConfig_entities !== void 0 ? _matchedRouteConfig_entities : {}) : matchedRouteConfigData;
             if ((_matchedRouteConfig_settings1 = matchedRouteConfig.settings) === null || _matchedRouteConfig_settings1 === void 0 ? void 0 : _matchedRouteConfig_settings1.status) {
                 response.statusCode = matchedRouteConfig.settings.status;
             }
@@ -104,6 +138,18 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
             // set 'Cache-Control' header for explicit browsers response revalidate: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
             // this code should place before response interceptors for giving opportunity to rewrite 'Cache-Control' header
             if (request.method === 'GET') response.set('Cache-control', 'no-cache');
+            let resolvedData = null;
+            if (matchedRouteConfigDataDescriptor.data) {
+                var _matchedRouteConfig_entities;
+                resolvedData = typeof matchedRouteConfigDataDescriptor.data === 'function' ? await matchedRouteConfigDataDescriptor.data(request, (_matchedRouteConfig_entities = matchedRouteConfig.entities) !== null && _matchedRouteConfig_entities !== void 0 ? _matchedRouteConfig_entities : {}) : matchedRouteConfigDataDescriptor.data;
+            }
+            if (matchedRouteConfigDataDescriptor.file) {
+                const buffer = _nodefs.default.readFileSync(_nodepath.default.resolve(matchedRouteConfigDataDescriptor.file));
+                resolvedData = {
+                    path: matchedRouteConfigDataDescriptor.file,
+                    file: buffer
+                };
+            }
             const data = await (0, _helpers.callResponseInterceptors)({
                 data: resolvedData,
                 request,
@@ -118,10 +164,20 @@ const createRestRoutes = ({ router, restConfig, serverResponseInterceptor })=>{
             if ((_matchedRouteConfig_settings2 = matchedRouteConfig.settings) === null || _matchedRouteConfig_settings2 === void 0 ? void 0 : _matchedRouteConfig_settings2.delay) {
                 await (0, _helpers.sleep)(matchedRouteConfig.settings.delay);
             }
-            if ('file' in matchedRouteConfig) {
-                return response.sendFile(_path.default.resolve(matchedRouteConfig.file));
+            if ((0, _helpers.isFileDescriptor)(data)) {
+                const isFilePathChanged = matchedRouteConfigDataDescriptor.file !== data.path;
+                if (isFilePathChanged) {
+                    if (!(0, _helpers.isFilePathValid)(data.path)) return next();
+                    data.file = _nodefs.default.readFileSync(_nodepath.default.resolve(data.path));
+                }
+                // ✅ important: replace backslashes because windows can use them in file path
+                const fileName = data.path.replaceAll('\\', '/').split('/').at(-1);
+                const fileExtension = fileName.split('.').at(-1);
+                response.type(fileExtension);
+                response.set('Content-Disposition', `filename=${fileName}`);
+                return response.send(data.file);
             }
-            return response.json(data);
+            response.json(data);
         }));
     });
     return router;

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

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

package/dist/src/server/createDatabaseMockServer/createDatabaseMockServer.js

@@ -12,7 +12,6 @@ const _bodyparser = /*#__PURE__*/ _interop_require_default(require("body-parser"
 const _express = /*#__PURE__*/ _interop_require_default(require("express"));
 const _database = require("../../core/database");
 const _middlewares = require("../../core/middlewares");
-const _helpers = require("../../utils/helpers");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -21,9 +20,6 @@ function _interop_require_default(obj) {
 const createDatabaseMockServer = (databaseMockServerConfig, server = (0, _express.default)())=>{
     var _databaseMockServerConfig_interceptors;
     const { cors, staticPath, data, routes } = databaseMockServerConfig;
-    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
     }));
@@ -32,7 +28,12 @@ const createDatabaseMockServer = (databaseMockServerConfig, server = (0, _expres
     }));
     server.set('json spaces', 2);
     server.use(_bodyparser.default.text());
-    (0, _middlewares.contextMiddleware)(server);
+    (0, _middlewares.contextMiddleware)(server, {
+        database: {
+            data,
+            routes
+        }
+    });
     (0, _middlewares.cookieParseMiddleware)(server);
     const serverRequestInterceptor = (_databaseMockServerConfig_interceptors = databaseMockServerConfig.interceptors) === null || _databaseMockServerConfig_interceptors === void 0 ? void 0 : _databaseMockServerConfig_interceptors.request;
     if (serverRequestInterceptor) {
@@ -56,7 +57,6 @@ const createDatabaseMockServer = (databaseMockServerConfig, server = (0, _expres
         routes
     });
     server.use(baseUrl, routerWithDatabaseRoutes);
-    (0, _middlewares.notFoundMiddleware)(server, databaseMockServerConfig);
     (0, _middlewares.errorMiddleware)(server);
     return server;
 };

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

@@ -0,0 +1,3 @@
+import type { Express } from 'express';
+import type { FlatMockServerConfig } from '../../utils/types';
+export declare const createFlatMockServer: (flatMockServerConfig: FlatMockServerConfig, server?: Express) => Express;