mock-config-server 3.7.1 → 4.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,36 @@
+export interface Database extends Record<string, unknown> {
+}
 export type ShallowDatabase = Record<string, unknown>;
 export type NestedDatabaseId = number | string;
 export type NestedDatabase = Record<string, {
     id: NestedDatabaseId;
     [key: string]: unknown;
 }[]>;
+export type StorageIndex = number | string;
+export interface Storage {
+    delete: (key: StorageIndex | StorageIndex[]) => void;
+    read: (key?: StorageIndex | StorageIndex[]) => any;
+    write: (key: StorageIndex | StorageIndex[], value: unknown) => void;
+}
+export interface ShallowOrm<Item = unknown> {
+    get: () => Item;
+    update: (data: Item) => void;
+}
+export interface NestedOrm<Item = Record<string, unknown>> {
+    count: () => number;
+    create: (item: Omit<Item, 'id'>) => Item;
+    createMany: (items: Omit<Item, 'id'>[]) => void;
+    delete: (id: StorageIndex) => void;
+    deleteMany: (ids: StorageIndex[]) => void;
+    exists: (filters: Partial<Item>) => boolean;
+    findById: (id: StorageIndex) => Item | undefined;
+    findFirst: (filters?: Partial<Item>) => Item | undefined;
+    findMany: (filters?: Partial<Item>) => Item[];
+    update: (id: StorageIndex, item: Partial<Omit<Item, 'id'>>) => void;
+    updateMany: (ids: StorageIndex[], item: Partial<Omit<Item, 'id'>>) => number;
+}
+export type Orm<Database extends Record<string, unknown>> = {
+    [Key in keyof Database]: Database[Key] extends Array<infer Item> ? Item extends {
+        id: StorageIndex;
+    } ? NestedOrm<Item> : ShallowOrm<Database[Key]> : ShallowOrm<Database[Key]>;
+};

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

@@ -1,48 +1,18 @@
-import type { CheckActualValueCheckMode, CheckFunction, CheckMode, CompareWithDescriptorAnyValueCheckMode, CompareWithDescriptorStringValueCheckMode, CompareWithDescriptorValueCheckMode } from './checkModes';
+import type { CheckActualValueCheckMode, CheckFunction, CheckMode, CompareWithDescriptorAnyValueCheckMode, CompareWithDescriptorStringValueCheckMode, CompareWithDescriptorValueCheckMode, EntityDescriptor } from './checkModes';
 import type { NestedObjectOrArray } from './utils';
-type PlainEntityValue = string | number | boolean | null;
-export type TopLevelPlainEntityDescriptor<Check extends CheckMode = CheckMode> = Check extends 'function' ? {
-    checkMode: Check;
-    value: (actualValue: NestedObjectOrArray<PlainEntityValue>, checkFunction: CheckFunction) => boolean;
-} : Check extends CompareWithDescriptorAnyValueCheckMode ? {
-    checkMode: Check;
-    value: NestedObjectOrArray<PlainEntityValue>;
-} : Check extends CheckActualValueCheckMode ? {
-    checkMode: Check;
-} : never;
-type PropertyLevelPlainEntityDescriptor<Check extends CheckMode = CheckMode> = Check extends 'function' ? {
-    checkMode: Check;
-    value: (actualValue: PlainEntityValue | NestedObjectOrArray<PlainEntityValue>, checkFunction: CheckFunction) => boolean;
-} : Check extends CompareWithDescriptorAnyValueCheckMode ? {
-    checkMode: Check;
-    value: PlainEntityValue | NestedObjectOrArray<PlainEntityValue>;
-} : Check extends 'regExp' ? {
-    checkMode: Check;
-    value: RegExp | RegExp[];
-} : Check extends CompareWithDescriptorStringValueCheckMode ? {
-    checkMode: Check;
-    value: PlainEntityValue | PlainEntityValue[];
-} : Check extends CheckActualValueCheckMode ? {
-    checkMode: Check;
-} : never;
+type PlainEntityPrimitiveValue = boolean | number | string | null;
+type PlainEntityObjectiveValue = NestedObjectOrArray<PlainEntityPrimitiveValue>;
+export type EntityFunctionDescriptorValue<ActualValue> = (actualValue: ActualValue, checkFunction: CheckFunction) => boolean;
+export type TopLevelPlainEntityDescriptor<Check extends CheckMode = CheckMode> = Check extends 'function' ? EntityDescriptor<Check, EntityFunctionDescriptorValue<PlainEntityObjectiveValue>> : Check extends CompareWithDescriptorAnyValueCheckMode ? EntityDescriptor<Check, PlainEntityObjectiveValue> : Check extends CheckActualValueCheckMode ? EntityDescriptor<Check> : never;
+type PropertyLevelPlainEntityDescriptor<Check extends CheckMode = CheckMode> = Check extends 'function' ? EntityDescriptor<Check, EntityFunctionDescriptorValue<PlainEntityObjectiveValue | PlainEntityPrimitiveValue>> : Check extends 'regExp' ? EntityDescriptor<Check, RegExp> : Check extends CompareWithDescriptorAnyValueCheckMode ? EntityDescriptor<Check, PlainEntityObjectiveValue | PlainEntityPrimitiveValue> : Check extends CompareWithDescriptorStringValueCheckMode ? EntityDescriptor<Check, PlainEntityPrimitiveValue> : Check extends CheckActualValueCheckMode ? EntityDescriptor<Check> : never;
 type NonCheckMode<T extends object> = T & {
     checkMode?: never;
 };
-type TopLevelPlainEntityRecord = NonCheckMode<Record<string, PropertyLevelPlainEntityDescriptor | NonCheckMode<NestedObjectOrArray<PlainEntityValue>> | PlainEntityValue>>;
-export type TopLevelPlainEntityArray = Array<NestedObjectOrArray<PlainEntityValue>>;
-export type PlainEntity = TopLevelPlainEntityDescriptor | TopLevelPlainEntityRecord | TopLevelPlainEntityArray;
-type MappedEntityValue = string | number | boolean;
-type MappedEntityDescriptor<Check extends CheckMode = CheckMode> = Check extends 'function' ? {
-    checkMode: Check;
-    value: (actualValue: MappedEntityValue, checkFunction: CheckFunction) => boolean;
-} : Check extends 'regExp' ? {
-    checkMode: Check;
-    value: RegExp | RegExp[];
-} : Check extends CompareWithDescriptorValueCheckMode ? {
-    checkMode: Check;
-    value: MappedEntityValue | MappedEntityValue[];
-} : Check extends CheckActualValueCheckMode ? {
-    checkMode: Check;
-} : never;
-export type MappedEntity = Record<string, MappedEntityDescriptor | MappedEntityValue | MappedEntityValue[]>;
+type TopLevelPlainEntityRecord = NonCheckMode<Record<string, NonCheckMode<PlainEntityObjectiveValue> | PlainEntityPrimitiveValue | PropertyLevelPlainEntityDescriptor>>;
+export type TopLevelPlainEntityArray = Array<PlainEntityObjectiveValue | PlainEntityPrimitiveValue>;
+export type BodyPlainEntity = TopLevelPlainEntityArray | TopLevelPlainEntityDescriptor | TopLevelPlainEntityRecord;
+export type VariablesPlainEntity = TopLevelPlainEntityDescriptor | TopLevelPlainEntityRecord;
+type MappedEntityValue = boolean | number | string;
+type MappedEntityDescriptor<Check extends CheckMode = CheckMode> = Check extends 'function' ? EntityDescriptor<Check, EntityFunctionDescriptorValue<MappedEntityValue>> : Check extends 'regExp' ? EntityDescriptor<Check, RegExp> : Check extends CompareWithDescriptorValueCheckMode ? EntityDescriptor<Check, MappedEntityValue> : Check extends CheckActualValueCheckMode ? EntityDescriptor<Check> : never;
+export type MappedEntity = Record<string, MappedEntityDescriptor | MappedEntityValue>;
 export {};

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

@@ -0,0 +1,5 @@
+import type { Buffer } from 'node:buffer';
+export interface FileDescriptor {
+    file: Buffer;
+    path: string;
+}

package/dist/src/utils/types/files.js

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

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

@@ -1,40 +1,41 @@
 import type { Request } from 'express';
-import type { MappedEntity, PlainEntity } from './entities';
+import type { MappedEntity, VariablesPlainEntity } from './entities';
 import type { Interceptors } from './interceptors';
 import type { Data } from './values';
-export type GraphQLEntityName = 'headers' | 'cookies' | 'query' | 'variables';
-export type GraphQLEntity<EntityName extends GraphQLEntityName = GraphQLEntityName> = EntityName extends 'variables' ? PlainEntity : MappedEntity;
-export type GraphQLOperationType = 'query' | 'mutation';
+export type GraphQLEntityName = 'cookies' | 'headers' | 'query' | 'variables';
+export type GraphQLEntity<EntityName extends GraphQLEntityName = GraphQLEntityName> = EntityName extends 'variables' ? VariablesPlainEntity : MappedEntity;
+export type GraphQLOperationType = 'mutation' | 'query';
 export type GraphQLOperationName = string | RegExp;
 export type GraphQLEntitiesByEntityName = {
     [EntityName in GraphQLEntityName]?: GraphQLEntity<EntityName>;
 };
 interface GraphQLSettings {
+    readonly delay?: number;
     readonly polling?: boolean;
     readonly status?: number;
-    readonly delay?: number;
 }
+export type GraphqlDataResponse = ((request: Request, entities: GraphQLEntitiesByEntityName) => Data | Promise<Data>) | Data;
 export type GraphQLRouteConfig = ({
     settings: GraphQLSettings & {
         polling: true;
     };
     queue: Array<{
         time?: number;
-        data: ((request: Request, entities: GraphQLEntitiesByEntityName) => Data | Promise<Data>) | Data;
+        data: GraphqlDataResponse;
     }>;
 } | {
     settings?: GraphQLSettings & {
         polling?: false;
     };
-    data: ((request: Request, entities: GraphQLEntitiesByEntityName) => Data | Promise<Data>) | Data;
+    data: GraphqlDataResponse;
 }) & {
     entities?: GraphQLEntitiesByEntityName;
     interceptors?: Interceptors<'graphql'>;
 };
 interface BaseGraphQLRequestConfig {
+    interceptors?: Interceptors<'graphql'>;
     operationType: GraphQLOperationType;
     routes: GraphQLRouteConfig[];
-    interceptors?: Interceptors<'graphql'>;
 }
 export interface OperationNameGraphQLRequestConfig extends BaseGraphQLRequestConfig {
     operationName: GraphQLOperationName;

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

@@ -1,6 +1,7 @@
 export * from './checkModes';
 export * from './database';
 export * from './entities';
+export * from './files';
 export * from './graphql';
 export * from './interceptors';
 export * from './logger';

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 _export_star(require("./checkModes"), exports);
 _export_star(require("./database"), exports);
 _export_star(require("./entities"), exports);
+_export_star(require("./files"), exports);
 _export_star(require("./graphql"), exports);
 _export_star(require("./interceptors"), exports);
 _export_star(require("./logger"), exports);

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

@@ -1,31 +1,36 @@
 import type { CookieOptions, Request, Response } from 'express';
+import type { Database, Orm } from './database';
 import type { Logger, LoggerTokens } from './logger';
 import type { ApiType } from './shared';
-type RequestInterceptorCookieValue = string | undefined;
-type RequestInterceptorHeaderValue = string | number | string[] | undefined;
+type InterceptorCookieValue = string | undefined;
+type InterceptorHeaderValue = number | string | string[] | undefined;
 export interface RequestInterceptorParams<Api extends ApiType = ApiType> {
+    orm: Orm<Database>;
     request: Request;
-    setDelay: (delay: number) => Promise<void>;
-    getCookie: (name: string) => RequestInterceptorCookieValue;
-    getHeader: (field: string) => RequestInterceptorHeaderValue;
-    getHeaders: () => Record<string, RequestInterceptorHeaderValue>;
+    getCookie: (name: string) => InterceptorCookieValue;
+    getHeader: (field: string) => InterceptorHeaderValue;
+    getHeaders: () => Record<string, InterceptorHeaderValue>;
     log: (logger?: Logger<'request', Api>) => Partial<LoggerTokens>;
+    setDelay: (delay: number) => Promise<void>;
 }
-export type RequestInterceptor<Api extends ApiType = ApiType> = (params: RequestInterceptorParams<Api>) => void | Promise<void>;
+export type RequestInterceptor<Api extends ApiType = ApiType> = (params: RequestInterceptorParams<Api>) => Promise<void> | void;
 export interface ResponseInterceptorParams<Api extends ApiType = ApiType> {
+    orm: Orm<Database>;
     request: Request;
     response: Response;
-    setDelay: (delay: number) => Promise<void>;
-    setStatusCode: (statusCode: number) => void;
-    setHeader: (field: string, value?: string | string[]) => void;
-    appendHeader: (field: string, value?: string[] | string) => void;
-    getHeader: (field: string) => RequestInterceptorHeaderValue;
-    getHeaders: () => Record<string, RequestInterceptorHeaderValue>;
-    setCookie: (name: string, value: string, options?: CookieOptions) => void;
-    getCookie: (name: string) => RequestInterceptorCookieValue;
-    clearCookie: (name: string, options?: CookieOptions) => void;
+    appendHeader: (field: string, value?: string | string[]) => void;
     attachment: (filename: string) => void;
+    clearCookie: (name: string, options?: CookieOptions) => void;
+    getCookie: (name: string) => InterceptorCookieValue;
+    getRequestHeader: (field: string) => InterceptorHeaderValue;
+    getRequestHeaders: () => Record<string, InterceptorHeaderValue>;
+    getResponseHeader: (field: string) => InterceptorHeaderValue;
+    getResponseHeaders: () => Record<string, InterceptorHeaderValue>;
     log: (logger?: Logger<'response', Api>) => Partial<LoggerTokens>;
+    setCookie: (name: string, value: string, options?: CookieOptions) => void;
+    setDelay: (delay: number) => Promise<void>;
+    setHeader: (field: string, value?: string | string[]) => void;
+    setStatusCode: (statusCode: number) => void;
 }
 export type ResponseInterceptor<Data = any, Api extends ApiType = ApiType> = (data: Data, params: ResponseInterceptorParams<Api>) => any;
 export interface Interceptors<Api extends ApiType = ApiType> {

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

@@ -3,37 +3,37 @@ import type { RestMethod } from './rest';
 import type { ApiType } from './shared';
 import type { Cookies, Headers, Params, PlainObject, Query } from './values';
 export interface LoggerBaseTokens {
-    type: string;
+    body: any;
+    cookies: Cookies;
+    headers: Headers;
     id: number;
-    timestamp: number;
     method: RestMethod;
-    url: string;
-    headers: Headers;
-    cookies: Cookies;
-    query: Query;
     params: Params;
-    body: any;
+    query: Query;
+    timestamp: number;
+    type: string;
+    url: string;
 }
 interface LoggerRestRequestTokens extends LoggerBaseTokens {
 }
 interface LoggerRestResponseTokens extends LoggerRestRequestTokens {
-    statusCode: number;
     data: any;
+    statusCode: number;
 }
 interface LoggerGraphQLRequestTokens extends LoggerBaseTokens {
-    graphQLOperationType: GraphQLOperationType | null;
     graphQLOperationName: GraphQLOperationName | null;
+    graphQLOperationType: GraphQLOperationType | null;
     graphQLQuery: string | null;
     variables: PlainObject | null;
 }
 interface LoggerGraphQLResponseTokens extends LoggerGraphQLRequestTokens {
-    statusCode: number;
     data: any;
+    statusCode: number;
 }
 export type LoggerType = 'request' | 'response';
 export type LoggerTokens<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> = Type extends 'request' ? Api extends 'rest' ? LoggerRestRequestTokens : Api extends 'graphql' ? LoggerGraphQLRequestTokens : never : Type extends 'response' ? Api extends 'rest' ? LoggerRestResponseTokens : Api extends 'graphql' ? LoggerGraphQLResponseTokens : never : never;
 type LoggerTokensToLoggerOptions<Type> = {
-    [Key in keyof Type]?: Type[Key] extends PlainObject ? Record<string, boolean> | boolean : boolean;
+    [Key in keyof Type]?: Type[Key] extends PlainObject ? boolean | Record<string, boolean> : boolean;
 };
 export type LoggerOptions<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> = LoggerTokensToLoggerOptions<LoggerTokens<Type, Api>>;
 export interface Logger<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> {

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

@@ -1,49 +1,54 @@
 import type { Request } from 'express';
-import type { MappedEntity, PlainEntity } from './entities';
+import type { BodyPlainEntity, MappedEntity } from './entities';
 import type { Interceptors } from './interceptors';
 import type { Data } from './values';
-export type RestMethod = 'get' | 'post' | 'delete' | 'put' | 'patch' | 'options';
-export type RestEntityName = 'headers' | 'cookies' | 'query' | 'params' | 'body';
-export type RestEntity<EntityName extends RestEntityName = RestEntityName> = EntityName extends 'body' ? PlainEntity : MappedEntity;
+export type RestMethod = 'delete' | 'get' | 'options' | 'patch' | 'post' | 'put';
+export type RestEntityName = 'body' | 'cookies' | 'headers' | 'params' | 'query';
+export type RestEntity<EntityName extends RestEntityName = RestEntityName> = EntityName extends 'body' ? BodyPlainEntity : MappedEntity;
 export type RestEntityNamesByMethod = {
-    [key in RestMethod]: key extends 'get' | 'delete' | 'options' ? Exclude<RestEntityName, 'body'> : RestEntityName;
+    [key in RestMethod]: key extends 'delete' | 'get' | 'options' ? Exclude<RestEntityName, 'body'> : RestEntityName;
 };
 export type RestEntitiesByEntityName<Method extends RestMethod = RestMethod> = {
     [EntityName in RestEntityNamesByMethod[Method]]?: RestEntity<EntityName>;
 };
 interface RestSettings {
+    readonly delay?: number;
     readonly polling?: boolean;
     readonly status?: number;
-    readonly delay?: number;
 }
+export type RestDataResponse<Method extends RestMethod = RestMethod> = ((request: Request, entities: RestEntitiesByEntityName<Method>) => Data | Promise<Data>) | Data;
+export type RestFileResponse = string;
 export type RestRouteConfig<Method extends RestMethod> = ({
     settings: RestSettings & {
         polling: true;
     };
     queue: Array<{
         time?: number;
-        data: ((request: Request, entities: RestEntitiesByEntityName<Method>) => Data | Promise<Data>) | Data;
+        data: RestDataResponse<Method>;
+    } | {
+        time?: number;
+        file: RestFileResponse;
     }>;
 } | {
     settings?: RestSettings & {
         polling?: false;
     };
-    data: ((request: Request, entities: RestEntitiesByEntityName<Method>) => Data | Promise<Data>) | Data;
+    data: RestDataResponse<Method>;
 } | {
     settings?: RestSettings & {
         polling?: false;
     };
-    file: string;
+    file: RestFileResponse;
 }) & {
     entities?: RestEntitiesByEntityName<Method>;
     interceptors?: Interceptors<'rest'>;
 };
 export type RestPathString = `/${string}`;
 interface BaseRestRequestConfig<Method extends RestMethod> {
-    path: RestPathString | RegExp;
+    interceptors?: Interceptors<'rest'>;
     method: Method;
+    path: RegExp | RestPathString;
     routes: RestRouteConfig<Method>[];
-    interceptors?: Interceptors<'rest'>;
 }
 type RestGetRequestConfig = BaseRestRequestConfig<'get'>;
 type RestPostRequestConfig = BaseRestRequestConfig<'post'>;
@@ -51,5 +56,5 @@ type RestPutRequestConfig = BaseRestRequestConfig<'put'>;
 type RestDeleteRequestConfig = BaseRestRequestConfig<'delete'>;
 type RestPatchRequestConfig = BaseRestRequestConfig<'patch'>;
 type RestOptionsRequestConfig = BaseRestRequestConfig<'options'>;
-export type RestRequestConfig = RestGetRequestConfig | RestPostRequestConfig | RestPutRequestConfig | RestDeleteRequestConfig | RestPatchRequestConfig | RestOptionsRequestConfig;
+export type RestRequestConfig = RestDeleteRequestConfig | RestGetRequestConfig | RestOptionsRequestConfig | RestPatchRequestConfig | RestPostRequestConfig | RestPutRequestConfig;
 export {};

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

@@ -1,23 +1,24 @@
 import type { Request } from 'express';
 import type { Arguments } from 'yargs';
+import type { Database, Orm } from './database';
 import type { GraphQLRequestConfig } from './graphql';
 import type { Interceptors } from './interceptors';
 import type { RestMethod, RestRequestConfig } from './rest';
-type StaticPathObject = {
-    prefix: `/${string}`;
+interface StaticPathObject {
     path: `/${string}`;
-};
-export type StaticPath = `/${string}` | StaticPathObject | (StaticPathObject | `/${string}`)[];
+    prefix: `/${string}`;
+}
+export type StaticPath = `/${string}` | (`/${string}` | StaticPathObject)[] | StaticPathObject;
 type CorsHeader = string;
-export type CorsOrigin = string | RegExp | (RegExp | string)[];
-export type Cors = {
-    origin: CorsOrigin | ((request: Request) => Promise<CorsOrigin> | CorsOrigin);
-    methods?: Uppercase<RestMethod>[];
+export type CorsOrigin = string | (string | RegExp)[] | RegExp;
+export interface Cors {
     allowedHeaders?: CorsHeader[];
-    exposedHeaders?: CorsHeader[];
     credentials?: boolean;
+    exposedHeaders?: CorsHeader[];
     maxAge?: number;
-};
+    methods?: Uppercase<RestMethod>[];
+    origin: ((request: Request) => CorsOrigin | Promise<CorsOrigin>) | CorsOrigin;
+}
 type Port = number;
 export type BaseUrl = `/${string}`;
 export interface RestConfig {
@@ -30,21 +31,21 @@ export interface GraphqlConfig {
     configs: GraphQLRequestConfig[];
     interceptors?: Interceptors<'graphql'>;
 }
-export type DatabaseConfig = {
-    data: Record<string, unknown> | `${string}.json`;
-    routes?: Record<`/${string}`, `/${string}`> | `${string}.json`;
-};
+export interface DatabaseConfig {
+    data: `${string}.json` | Record<string, unknown>;
+    routes?: `${string}.json` | Record<`/${string}`, `/${string}`>;
+}
 export interface BaseMockServerConfig {
     baseUrl?: BaseUrl;
+    cors?: Cors;
+    interceptors?: Interceptors;
     port?: Port;
     staticPath?: StaticPath;
-    interceptors?: Interceptors;
-    cors?: Cors;
 }
 export interface MockServerConfig extends BaseMockServerConfig {
-    rest?: RestConfig;
-    graphql?: GraphqlConfig;
     database?: DatabaseConfig;
+    graphql?: GraphqlConfig;
+    rest?: RestConfig;
 }
 export interface RestMockServerConfig extends BaseMockServerConfig {
     configs?: RestRequestConfig[];
@@ -55,8 +56,8 @@ export interface GraphQLMockServerConfig extends BaseMockServerConfig {
     database?: DatabaseConfig;
 }
 export interface DatabaseMockServerConfig extends BaseMockServerConfig {
-    data: Record<string, unknown> | `${string}.json`;
-    routes?: Record<`/${string}`, `/${string}`> | `${string}.json`;
+    data: `${string}.json` | Record<string, unknown>;
+    routes?: `${string}.json` | Record<`/${string}`, `/${string}`>;
 }
 export type MockServerConfigArgv = Arguments<{
     baseUrl?: string;
@@ -65,4 +66,31 @@ export type MockServerConfigArgv = Arguments<{
     config?: string;
     watch?: boolean;
 }>;
+declare global {
+    namespace Express {
+        interface Request {
+            context: {
+                orm: Orm<Database>;
+            };
+        }
+    }
+}
+export interface FlatMockServerComponent {
+    baseUrl?: BaseUrl;
+    configs: Array<GraphQLRequestConfig | RestRequestConfig>;
+    interceptors?: Interceptors;
+    name?: string;
+}
+export interface FlatMockServerSettings {
+    baseUrl?: BaseUrl;
+    cors?: Cors;
+    database?: DatabaseConfig;
+    interceptors?: Interceptors;
+    port?: Port;
+    staticPath?: StaticPath;
+}
+export type FlatMockServerConfig = [
+    option: FlatMockServerComponent | FlatMockServerSettings,
+    ...flatMockServerComponents: FlatMockServerComponent[]
+];
 export {};

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

@@ -1 +1 @@
-export type ApiType = 'rest' | 'graphql';
+export type ApiType = 'graphql' | 'rest';