mock-config-server 4.0.3 → 5.0.0-beta.1

package/dist/src/core/graphql/createGraphQLRoute/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './calculateGraphQLRouteConfigWeight/calculateGraphQLRouteConfigWeight';
+export * from './matchGraphQLRequestArtifacts/matchGraphQLRequestArtifacts';
+export * from './prepareGraphQLRequestArtifacts/prepareGraphQLRequestArtifacts';

package/dist/src/core/graphql/createGraphQLRoute/helpers/index.js

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

package/dist/src/core/graphql/createGraphQLRoute/helpers/matchGraphQLRequestArtifacts/matchGraphQLRequestArtifacts.d.ts

@@ -0,0 +1,12 @@
+import type { GraphQLRequestArtifact } from '../../../../../utils/types';
+interface MatchGraphQLRequestArtifactsParams {
+    artifacts: GraphQLRequestArtifact[];
+    meta: {
+        path: string;
+        operationType: string;
+        query?: string;
+        operationName?: string;
+    };
+}
+export declare const matchGraphQLRequestArtifacts: ({ artifacts, meta }: MatchGraphQLRequestArtifactsParams) => GraphQLRequestArtifact[];
+export {};

package/dist/src/core/graphql/createGraphQLRoute/helpers/matchGraphQLRequestArtifacts/matchGraphQLRequestArtifacts.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "matchGraphQLRequestArtifacts", {
+    enumerable: true,
+    get: function() {
+        return matchGraphQLRequestArtifacts;
+    }
+});
+const _graphql = require("graphql");
+const _helpers = require("../../../../../utils/helpers");
+const matchGraphQLRequestArtifacts = ({ artifacts, meta })=>artifacts.filter((artifact)=>{
+        if ((0, _helpers.normalizeUrl)(meta.path) !== (0, _helpers.normalizeUrl)(artifact.baseUrl)) {
+            return false;
+        }
+        if (artifact.operationType !== meta.operationType) return false;
+        if (artifact.query) {
+            if (!meta.query) return false;
+            return (0, _graphql.stripIgnoredCharacters)((0, _graphql.print)((0, _graphql.parse)(artifact.query))) === (0, _graphql.stripIgnoredCharacters)((0, _graphql.print)((0, _graphql.parse)(meta.query)));
+        }
+        if (artifact.operationName) {
+            if (!meta.operationName) return false;
+            return artifact.operationName instanceof RegExp ? new RegExp(artifact.operationName).test(meta.operationName) : artifact.operationName === meta.operationName;
+        }
+        console.warn(`[mock-config] GraphQL artifact with no query or operationName was skipped: ${JSON.stringify(artifact)}`);
+        return false;
+    });

package/dist/src/core/graphql/createGraphQLRoute/helpers/prepareGraphQLRequestArtifacts/prepareGraphQLRequestArtifacts.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLRequestArtifact } from '../../../../../utils/types';
+export declare const prepareGraphQLRequestArtifacts: (requestArtifacts: GraphQLRequestArtifact[]) => GraphQLRequestArtifact[];

package/dist/src/core/graphql/createGraphQLRoute/helpers/prepareGraphQLRequestArtifacts/prepareGraphQLRequestArtifacts.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "prepareGraphQLRequestArtifacts", {
+    enumerable: true,
+    get: function() {
+        return prepareGraphQLRequestArtifacts;
+    }
+});
+const prepareGraphQLRequestArtifacts = (requestArtifacts)=>requestArtifacts.toSorted((first, second)=>second.weight - first.weight);

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

@@ -1 +1,2 @@
-export * from './createGraphQLRoutes/createGraphQLRoutes';
+export * from './createGraphQLRoute/createGraphQLRoute';
+export * from './createGraphQLRoute/helpers';

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./createGraphQLRoutes/createGraphQLRoutes"), exports);
+_export_star(require("./createGraphQLRoute/createGraphQLRoute"), exports);
+_export_star(require("./createGraphQLRoute/helpers"), 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/middlewares/contextMiddleware/contextMiddleware.d.ts

@@ -1,17 +1,19 @@
 import type { Express } from 'express';
-import type { GraphQLEntity, GraphQLOperationName, GraphQLOperationType, MockServerConfig } from '../../../utils/types';
+import type { DatabaseConfig, GraphQLEntity, GraphQLOperationName, GraphQLOperationType } from '../../../utils/types';
 declare global {
     namespace Express {
         interface Request {
-            id: number;
-            timestamp: number;
             graphQL: {
                 operationType: GraphQLOperationType;
                 operationName?: GraphQLOperationName;
                 query: string;
                 variables?: GraphQLEntity<'variables'>;
             } | null;
+            id: number;
+            timestamp: number;
         }
     }
 }
-export declare const contextMiddleware: (server: Express, { database }: Pick<MockServerConfig, "database">) => void;
+export declare const contextMiddleware: (server: Express, { database }: {
+    database?: DatabaseConfig;
+}) => void;

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

@@ -0,0 +1,8 @@
+import type { Express } from 'express';
+import type { RestRequestArtifact } from '../../../utils/types';
+interface CreateRestRoutesParams {
+    restRequestArtifacts: RestRequestArtifact[];
+    server: Express;
+}
+export declare const createRestRoute: ({ server, restRequestArtifacts }: CreateRestRoutesParams) => Express;
+export {};

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRestRoute", {
+    enumerable: true,
+    get: function() {
+        return createRestRoute;
+    }
+});
+const _flat = require("flat");
+const _helpers = require("../../../utils/helpers");
+const _helpers1 = require("./helpers");
+const extractPathParams = (artifact, path)=>{
+    var _fullPath_match;
+    if (artifact.path instanceof RegExp) return {};
+    const fullPath = (0, _helpers.urlJoin)(artifact.baseUrl, artifact.path);
+    var _fullPath_match_map;
+    const keys = (_fullPath_match_map = (_fullPath_match = fullPath.match(/:[^/]+/g)) === null || _fullPath_match === void 0 ? void 0 : _fullPath_match.map((key)=>key.slice(1))) !== null && _fullPath_match_map !== void 0 ? _fullPath_match_map : [];
+    if (!keys.length) return {};
+    const match = path.match((0, _helpers1.generatePathRegex)(fullPath));
+    if (!match) return {};
+    return keys.reduce((acc, key, index)=>{
+        acc[key] = decodeURIComponent(match[index + 1]);
+        return acc;
+    }, {});
+};
+const createRestRoute = ({ server, restRequestArtifacts })=>server.use((0, _helpers.asyncHandler)(async (request, response, next)=>{
+        var _matchedRouteConfig_config_settings, _matchedRouteConfig_config_settings1;
+        const requestMethod = request.method.toLowerCase();
+        const previousParams = {
+            ...request.params
+        };
+        const matchedRequestArtifacts = (0, _helpers1.matchRestRequestArtifacts)({
+            artifacts: restRequestArtifacts,
+            meta: {
+                method: requestMethod,
+                path: (0, _helpers.normalizeUrl)(request.path)
+            }
+        });
+        if (!matchedRequestArtifacts.length) return next();
+        const matchedRouteConfig = matchedRequestArtifacts.find((artifact)=>{
+            request.params = extractPathParams(artifact, request.path);
+            const { config } = artifact;
+            if (!config.entities) return true;
+            const entityEntries = Object.entries(config.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) {
+                    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) {
+                    if (!Array.isArray(request.body)) return false;
+                    return (0, _helpers.resolveEntityValues)({
+                        actualValue: request.body,
+                        descriptorValue: entityDescriptorOrValue,
+                        checkMode: 'equals'
+                    });
+                }
+                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
+                    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
+                    });
+                });
+            });
+        });
+        if (!matchedRouteConfig) {
+            request.params = previousParams;
+            return next();
+        }
+        if (matchedRouteConfig.componentRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.componentRequestInterceptor
+            });
+        }
+        if (matchedRouteConfig.requestRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.requestRequestInterceptor
+            });
+        }
+        if (matchedRouteConfig.routeRequestInterceptor) {
+            await (0, _helpers.callRequestInterceptor)({
+                request,
+                interceptor: matchedRouteConfig.routeRequestInterceptor
+            });
+        }
+        if ((_matchedRouteConfig_config_settings = matchedRouteConfig.config.settings) === null || _matchedRouteConfig_config_settings === void 0 ? void 0 : _matchedRouteConfig_config_settings.status) {
+            response.statusCode = matchedRouteConfig.config.settings.status;
+        }
+        // ✅ important:
+        // 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-store');
+        var _matchedRouteConfig_config_entities;
+        const params = {
+            request,
+            response,
+            next,
+            entities: (_matchedRouteConfig_config_entities = matchedRouteConfig.config.entities) !== null && _matchedRouteConfig_config_entities !== void 0 ? _matchedRouteConfig_config_entities : {},
+            appendHeader: (field, value)=>{
+                response.append(field, value);
+            },
+            attachment: (filename)=>{
+                response.attachment(filename);
+            },
+            clearCookie: (name, options)=>{
+                response.clearCookie(name, options);
+            },
+            getCookie: (name)=>request.cookies[name],
+            getRequestHeader: (field)=>request.headers[field],
+            getRequestHeaders: ()=>request.headers,
+            getResponseHeader: (field)=>response.getHeader(field),
+            getResponseHeaders: ()=>response.getHeaders(),
+            setCookie: (name, value, options)=>{
+                if (options) {
+                    response.cookie(name, value, options);
+                    return;
+                }
+                response.cookie(name, value);
+            },
+            setDelay: async (delay)=>{
+                await (0, _helpers.sleep)(delay === Infinity ? 99999999 : delay);
+            },
+            setHeader: (field, value)=>{
+                response.set(field, value);
+            },
+            setStatusCode: (statusCode)=>{
+                response.statusCode = statusCode;
+            }
+        };
+        const resolvedData = typeof matchedRouteConfig.config.data === 'function' ? await matchedRouteConfig.config.data(params) : matchedRouteConfig.config.data;
+        if (response.headersSent) {
+            return;
+        }
+        const data = await (0, _helpers.callResponseInterceptors)({
+            data: resolvedData,
+            request,
+            response,
+            interceptors: {
+                routeInterceptor: matchedRouteConfig.routeResponseInterceptor,
+                requestInterceptor: matchedRouteConfig.requestResponseInterceptor,
+                componentInterceptor: matchedRouteConfig.componentResponseInterceptor,
+                serverInterceptor: matchedRouteConfig.serverResponseInterceptor
+            }
+        });
+        if ((_matchedRouteConfig_config_settings1 = matchedRouteConfig.config.settings) === null || _matchedRouteConfig_config_settings1 === void 0 ? void 0 : _matchedRouteConfig_config_settings1.delay) {
+            await (0, _helpers.sleep)(matchedRouteConfig.config.settings.delay);
+        }
+        if (response.headersSent) {
+            return;
+        }
+        if (response.getHeader('content-type')) {
+            return response.send(data);
+        }
+        return response.json(data);
+    }));

package/dist/src/core/rest/createRestRoute/helpers/calculateRestRouteConfigWeight/calculateRestRouteConfigWeight.d.ts

@@ -0,0 +1,2 @@
+import type { RestMethod, RestRouteConfig } from '../../../../../utils/types';
+export declare const calculateRestRouteConfigWeight: (restRouteConfig: RestRouteConfig<RestMethod>) => number;

package/dist/src/core/rest/createRestRoute/helpers/calculateRestRouteConfigWeight/calculateRestRouteConfigWeight.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "calculateRestRouteConfigWeight", {
+    enumerable: true,
+    get: function() {
+        return calculateRestRouteConfigWeight;
+    }
+});
+const _helpers = require("../../../../../utils/helpers");
+const calculateRestRouteConfigWeight = (restRouteConfig)=>{
+    const { entities } = restRouteConfig;
+    if (!entities) return 0;
+    let routeConfigWeight = 0;
+    const { headers, cookies, query, params, body } = entities;
+    if (headers) routeConfigWeight += Object.keys(headers).length;
+    if (cookies) routeConfigWeight += Object.keys(cookies).length;
+    if (query) routeConfigWeight += Object.keys(query).length;
+    if (params) routeConfigWeight += Object.keys(params).length;
+    if (body) {
+        if ((0, _helpers.isPlainObject)(body) && body.checkMode) {
+            // ✅ important:
+            // check that actual value check modes does not have `value` for compare
+            if (body.checkMode === 'exists' || body.checkMode === 'notExists') {
+                routeConfigWeight += 1;
+                return routeConfigWeight;
+            }
+            routeConfigWeight += (0, _helpers.isPlainObject)(body.value) ? Object.keys(body.value).length : 1;
+            return routeConfigWeight;
+        }
+        routeConfigWeight += (0, _helpers.isPlainObject)(body) ? Object.keys(body).length : 1;
+    }
+    return routeConfigWeight;
+};

package/dist/src/core/rest/createRestRoute/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './calculateRestRouteConfigWeight/calculateRestRouteConfigWeight';
+export * from './matchRestRequestArtifacts/matchRestRequestArtifacts';
+export * from './prepareRestRequestArtifacts/prepareRestRequestArtifacts';

package/dist/src/core/rest/createRestRoute/helpers/index.js

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

package/dist/src/core/rest/createRestRoute/helpers/matchRestRequestArtifacts/matchRestRequestArtifacts.d.ts

@@ -0,0 +1,11 @@
+import type { RestRequestArtifact } from '../../../../../utils/types';
+export declare const generatePathRegex: (path: string) => RegExp;
+interface MatchRestRequestArtifactsParams {
+    artifacts: RestRequestArtifact[];
+    meta: {
+        method: string;
+        path: string;
+    };
+}
+export declare const matchRestRequestArtifacts: ({ artifacts, meta }: MatchRestRequestArtifactsParams) => RestRequestArtifact[];
+export {};

package/dist/src/core/rest/createRestRoute/helpers/matchRestRequestArtifacts/matchRestRequestArtifacts.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generatePathRegex () {
+        return generatePathRegex;
+    },
+    get matchRestRequestArtifacts () {
+        return matchRestRequestArtifacts;
+    }
+});
+const _helpers = require("../../../../../utils/helpers");
+const generatePathRegex = (path)=>new RegExp(`^${path.split('/').map((part)=>part.startsWith(':') ? '([^/]+)' : part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('/')}$`);
+const matchRestRequestArtifacts = ({ artifacts, meta })=>artifacts.filter((artifact)=>{
+        if (!meta.path.startsWith(artifact.baseUrl)) return false;
+        if (artifact.method !== meta.method) return false;
+        if (artifact.path instanceof RegExp) {
+            if (artifact.baseUrl === '/') return new RegExp(artifact.path).test(meta.path);
+            const tail = meta.path === artifact.baseUrl ? '' : meta.path.slice(artifact.baseUrl.length);
+            if (!tail) return false;
+            return new RegExp(artifact.path).test(tail);
+        }
+        return generatePathRegex((0, _helpers.urlJoin)(artifact.baseUrl, artifact.path)).test(meta.path);
+    });

package/dist/src/core/rest/createRestRoute/helpers/prepareRestRequestArtifacts/prepareRestRequestArtifacts.d.ts

@@ -0,0 +1,2 @@
+import type { RestRequestArtifact } from '../../../../../utils/types';
+export declare const prepareRestRequestArtifacts: (requestArtifacts: RestRequestArtifact[]) => RestRequestArtifact[];

package/dist/src/core/rest/createRestRoute/helpers/prepareRestRequestArtifacts/prepareRestRequestArtifacts.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "prepareRestRequestArtifacts", {
+    enumerable: true,
+    get: function() {
+        return prepareRestRequestArtifacts;
+    }
+});
+const prepareRestRequestArtifacts = (requestArtifacts)=>{
+    const sortedByPathRequestArtifacts = requestArtifacts.toSorted((first, second)=>second.weight - first.weight).toSorted(({ path: firstPath }, { path: secondPath })=>{
+        // ✅ important:
+        // do not compare RegExp paths and non-parameterized paths
+        if (firstPath instanceof RegExp || secondPath instanceof RegExp) return 0;
+        if (!firstPath.includes('/:') && !secondPath.includes('/:')) return 0;
+        const firstPathParts = firstPath.split('/');
+        const secondPathParts = secondPath.split('/');
+        const minimalPathPartsLength = Math.min(firstPathParts.length, secondPathParts.length);
+        // ✅ important:
+        // need to find the leftmost parameter/non-parameter pair and give priority to non-parameter one
+        for(let i = 0; i < minimalPathPartsLength; i += 1){
+            const firstPathPart = firstPathParts[i];
+            const secondPathPart = secondPathParts[i];
+            const isFirstPathPartParameter = firstPathPart.startsWith(':');
+            const isSecondPathPartParameter = secondPathPart.startsWith(':');
+            if (!isFirstPathPartParameter && !isSecondPathPartParameter) {
+                if (firstPathPart === secondPathPart) continue;
+                return 0;
+            }
+            if (isFirstPathPartParameter && isSecondPathPartParameter) continue;
+            return +isFirstPathPartParameter - +isSecondPathPartParameter;
+        }
+        return 0;
+    });
+    return sortedByPathRequestArtifacts;
+};

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

@@ -1 +1,2 @@
-export * from './createRestRoutes/createRestRoutes';
+export * from './createRestRoute/createRestRoute';
+export * from './createRestRoute/helpers';

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./createRestRoutes/createRestRoutes"), exports);
+_export_star(require("./createRestRoute/createRestRoute"), exports);
+_export_star(require("./createRestRoute/helpers"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/src/index.d.ts

@@ -1,2 +1,3 @@
+export * from './core/functions';
 export * from './server';
 export * from './utils/types';

package/dist/src/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./core/functions"), exports);
 _export_star(require("./server"), exports);
 _export_star(require("./utils/types"), exports);
 function _export_star(from, to) {

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

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