mock-config-server 3.7.0 → 4.0.0

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';

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

@@ -1,8 +1,8 @@
 import type { PlainObject } from './values';
-export type ValueOf<T extends PlainObject | Array<any>> = T extends Array<any> ? T[number] : T[keyof T];
-export type Entries<T extends PlainObject | Array<any>> = ValueOf<{
+export type ValueOf<T extends Array<any> | PlainObject> = T extends Array<any> ? T[number] : T[keyof T];
+export type Entries<T extends Array<any> | PlainObject> = ValueOf<{
     [K in keyof T]-?: [K, T[K]];
 }>[];
-export type NestedObjectOrArray<T> = {
+export type NestedObjectOrArray<T> = Array<NestedObjectOrArray<T> | T> | {
     [key: string]: NestedObjectOrArray<T> | T;
-} | Array<NestedObjectOrArray<T> | T>;
+};

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

@@ -1,8 +1,7 @@
-/// <reference types="node" />
-import type { ParamsDictionary, Query as ExpressQuery } from 'express-serve-static-core';
-import type { IncomingHttpHeaders } from 'http';
+import type { Query as ExpressQuery, ParamsDictionary } from 'express-serve-static-core';
+import type { IncomingHttpHeaders } from 'node:http';
 export type PlainObject = Record<string, any>;
-export type Primitive = boolean | number | bigint | string | null | undefined | symbol;
+export type Primitive = bigint | boolean | number | string | symbol | null | undefined;
 export type Headers = IncomingHttpHeaders;
 export type Query = ExpressQuery;
 export type Params = ParamsDictionary;

package/dist/{bin/validateMockServerConfig → src/utils/validate}/corsSchema/corsSchema.d.ts

@@ -8,14 +8,14 @@ export declare const corsSchema: z.ZodObject<{
     maxAge: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
     origin: string | RegExp | (string | RegExp)[] | ((...args: unknown[]) => unknown);
-    methods?: ("GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "OPTIONS")[] | undefined;
+    methods?: ("DELETE" | "GET" | "OPTIONS" | "PATCH" | "POST" | "PUT")[] | undefined;
     allowedHeaders?: string[] | undefined;
     exposedHeaders?: string[] | undefined;
     credentials?: boolean | undefined;
     maxAge?: number | undefined;
 }, {
     origin: string | RegExp | (string | RegExp)[] | ((...args: unknown[]) => unknown);
-    methods?: ("GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "OPTIONS")[] | undefined;
+    methods?: ("DELETE" | "GET" | "OPTIONS" | "PATCH" | "POST" | "PUT")[] | undefined;
     allowedHeaders?: string[] | undefined;
     exposedHeaders?: string[] | undefined;
     credentials?: boolean | undefined;

package/dist/{bin/helpers → src/utils/validate}/getMostSpecificPathFromError.d.ts

@@ -1,2 +1,2 @@
 import { z } from 'zod';
-export declare const getMostSpecificPathFromError: (error: z.ZodError) => (string | number)[];
+export declare const getMostSpecificPathFromError: (error: z.ZodError) => (number | string)[];

package/dist/src/utils/validate/getValidationMessageFromPath.d.ts

@@ -0,0 +1 @@
+export declare const getValidationMessageFromPath: (path: (number | string)[]) => string | number;