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

package/dist/src/utils/helpers/files/isFileDescriptor/isFileDescriptor.js

@@ -8,9 +8,9 @@ Object.defineProperty(exports, "isFileDescriptor", {
         return isFileDescriptor;
     }
 });
-const _nodebuffer = require("node:buffer");
+const _buffer = require("buffer");
 const _zod = require("zod");
 const isFileDescriptor = (value)=>_zod.z.object({
         path: _zod.z.string(),
-        file: _zod.z.instanceof(_nodebuffer.Buffer)
+        file: _zod.z.instanceof(_buffer.Buffer)
     }).strict().safeParse(value).success;

package/dist/src/utils/helpers/files/isFilePathValid/isFilePathValid.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "isFilePathValid", {
         return isFilePathValid;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -16,8 +16,8 @@ function _interop_require_default(obj) {
 }
 const isFilePathValid = (path)=>{
     try {
-        if (!_nodefs.default.existsSync(path)) return false;
-        if (!_nodefs.default.statSync(path).isFile()) return false;
+        if (!_fs.default.existsSync(path)) return false;
+        if (!_fs.default.statSync(path).isFile()) return false;
         return true;
     } catch (error) {
         console.error(error);

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

@@ -2,14 +2,14 @@ import type { Request, Response } from 'express';
 import type { Data, ResponseInterceptor } from '../../../types';
 interface CallResponseInterceptorsParams {
     data: Data;
-    request: Request;
-    response: Response;
     interceptors?: {
         routeInterceptor?: ResponseInterceptor;
         requestInterceptor?: ResponseInterceptor;
-        apiInterceptor?: ResponseInterceptor;
+        componentInterceptor?: ResponseInterceptor;
         serverInterceptor?: ResponseInterceptor;
     };
+    request: Request;
+    response: Response;
 }
 export declare const callResponseInterceptors: (params: CallResponseInterceptorsParams) => Promise<Data>;
 export {};

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

@@ -70,8 +70,8 @@ const callResponseInterceptors = async (params)=>{
     if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.requestInterceptor) {
         updatedData = await interceptors.requestInterceptor(updatedData, responseInterceptorParams);
     }
-    if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.apiInterceptor) {
-        updatedData = await interceptors.apiInterceptor(updatedData, responseInterceptorParams);
+    if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.componentInterceptor) {
+        updatedData = await interceptors.componentInterceptor(updatedData, responseInterceptorParams);
     }
     if (interceptors === null || interceptors === void 0 ? void 0 : interceptors.serverInterceptor) {
         updatedData = await interceptors.serverInterceptor(updatedData, responseInterceptorParams);

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

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

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

@@ -1,4 +1,3 @@
 export * from './convertWin32PathToUnix/convertWin32PathToUnix';
-export * from './getUrlParts/getUrlParts';
-export * from './removeLeadingAndTrailingSlashes/removeLeadingAndTrailingSlashes';
+export * from './normalizeUrl/normalizeUrl';
 export * from './urlJoin/urlJoin';

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

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./convertWin32PathToUnix/convertWin32PathToUnix"), exports);
-_export_star(require("./getUrlParts/getUrlParts"), exports);
-_export_star(require("./removeLeadingAndTrailingSlashes/removeLeadingAndTrailingSlashes"), exports);
+_export_star(require("./normalizeUrl/normalizeUrl"), exports);
 _export_star(require("./urlJoin/urlJoin"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/dist/src/utils/helpers/url/normalizeUrl/normalizeUrl.d.ts

@@ -0,0 +1 @@
+export declare const normalizeUrl: (url: string) => string;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeUrl", {
+    enumerable: true,
+    get: function() {
+        return normalizeUrl;
+    }
+});
+const normalizeUrl = (url)=>{
+    if (!url || url === '/') return '/';
+    const normalizedUrl = url.replace(/\/+$/g, '');
+    return normalizedUrl || '/';
+};

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

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "urlJoin", {
         return urlJoin;
     }
 });
-const _nodeos = /*#__PURE__*/ _interop_require_default(require("node:os"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("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 = _nodeos.default.platform() === 'win32' ? paths.map((path)=>(0, _convertWin32PathToUnix.convertWin32PathToUnix)(path)) : paths;
-    return _nodepath.default.posix.join(...pathsToJoin);
+    const pathsToJoin = _os.default.platform() === 'win32' ? paths.map((path)=>(0, _convertWin32PathToUnix.convertWin32PathToUnix)(path)) : paths;
+    return _path.default.posix.join(...pathsToJoin);
 };

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

@@ -1,6 +1,7 @@
-import type { Request } from 'express';
+import type { CookieOptions, Response as ExpressResponse, Request } from 'express';
 import type { MappedEntity, VariablesPlainEntity } from './entities';
 import type { Interceptors } from './interceptors';
+import type { BaseUrl } from './server';
 import type { Data } from './values';
 export type GraphQLEntityName = 'cookies' | 'headers' | 'query' | 'variables';
 export type GraphQLEntity<EntityName extends GraphQLEntityName = GraphQLEntityName> = EntityName extends 'variables' ? VariablesPlainEntity : MappedEntity;
@@ -9,29 +10,38 @@ export type GraphQLOperationName = string | RegExp;
 export type GraphQLEntitiesByEntityName = {
     [EntityName in GraphQLEntityName]?: GraphQLEntity<EntityName>;
 };
-interface GraphQLSettings {
+export interface GraphQLSettings {
     readonly delay?: number;
-    readonly polling?: boolean;
     readonly status?: number;
 }
-export type GraphqlDataResponse = ((request: Request, entities: GraphQLEntitiesByEntityName) => Data | Promise<Data>) | Data;
-export type GraphQLRouteConfig = ({
-    settings: GraphQLSettings & {
-        polling: true;
-    };
-    queue: Array<{
-        time?: number;
-        data: GraphqlDataResponse;
-    }>;
-} | {
-    settings?: GraphQLSettings & {
-        polling?: false;
-    };
+type GraphQLCookieValue = string | undefined;
+type GraphQLHeaderValue = number | string | string[] | undefined;
+export interface GraphQLParams<Query = Record<string, unknown>, Body = Record<string, unknown>, Params = Record<string, unknown>, Response = any> {
+    entities: GraphQLEntitiesByEntityName;
+    request: Request<Params, Response, Body, Query>;
+    response: ExpressResponse;
+    appendHeader: (field: string, value?: string | string[]) => void;
+    attachment: (filename: string) => void;
+    clearCookie: (name: string, options?: CookieOptions) => void;
+    getCookie: (name: string) => GraphQLCookieValue;
+    getRequestHeader: (field: string) => GraphQLHeaderValue;
+    getRequestHeaders: () => Record<string, GraphQLHeaderValue>;
+    getResponseHeader: (field: string) => GraphQLHeaderValue;
+    getResponseHeaders: () => Record<string, GraphQLHeaderValue>;
+    next: () => void;
+    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 GraphqlDataResponseFunction = (params: GraphQLParams) => Data | Promise<Data>;
+export type GraphqlDataResponse = Data | GraphqlDataResponseFunction;
+export interface GraphQLRouteConfig {
     data: GraphqlDataResponse;
-}) & {
     entities?: GraphQLEntitiesByEntityName;
     interceptors?: Interceptors<'graphql'>;
-};
+    settings?: GraphQLSettings;
+}
 interface BaseGraphQLRequestConfig {
     interceptors?: Interceptors<'graphql'>;
     operationType: GraphQLOperationType;
@@ -44,4 +54,20 @@ interface QueryGraphQLRequestConfig extends BaseGraphQLRequestConfig {
     query: string;
 }
 export type GraphQLRequestConfig = OperationNameGraphQLRequestConfig | QueryGraphQLRequestConfig;
+export interface GraphQLRequestArtifact {
+    baseUrl: BaseUrl;
+    componentRequestInterceptor?: Interceptors<'graphql'>['request'];
+    componentResponseInterceptor?: Interceptors<'graphql'>['response'];
+    config: GraphQLRouteConfig;
+    operationName?: GraphQLOperationName;
+    operationType: GraphQLOperationType;
+    query?: string;
+    requestRequestInterceptor?: Interceptors<'graphql'>['request'];
+    requestResponseInterceptor?: Interceptors<'graphql'>['response'];
+    routeRequestInterceptor?: Interceptors<'graphql'>['request'];
+    routeResponseInterceptor?: Interceptors<'graphql'>['response'];
+    serverRequestInterceptor?: Interceptors<'graphql'>['request'];
+    serverResponseInterceptor?: Interceptors<'graphql'>['response'];
+    weight: number;
+}
 export {};

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

@@ -1,6 +1,7 @@
-import type { Request } from 'express';
+import type { CookieOptions, Response as ExpressResponse, Request } from 'express';
 import type { BodyPlainEntity, MappedEntity } from './entities';
 import type { Interceptors } from './interceptors';
+import type { BaseUrl } from './server';
 import type { Data } from './values';
 export type RestMethod = 'delete' | 'get' | 'options' | 'patch' | 'post' | 'put';
 export type RestEntityName = 'body' | 'cookies' | 'headers' | 'params' | 'query';
@@ -11,40 +12,41 @@ export type RestEntityNamesByMethod = {
 export type RestEntitiesByEntityName<Method extends RestMethod = RestMethod> = {
     [EntityName in RestEntityNamesByMethod[Method]]?: RestEntity<EntityName>;
 };
-interface RestSettings {
+export interface RestSettings {
     readonly delay?: number;
-    readonly polling?: boolean;
     readonly status?: number;
 }
-export type RestDataResponse<Method extends RestMethod = RestMethod> = ((request: Request, entities: RestEntitiesByEntityName<Method>) => Data | Promise<Data>) | Data;
+type RestCookieValue = string | undefined;
+type RestHeaderValue = number | string | string[] | undefined;
+export interface RestParams<Method extends RestMethod = RestMethod, Query = Record<string, unknown>, Body = Record<string, unknown>, Params = Record<string, unknown>, Response = any> {
+    entities: RestEntitiesByEntityName<Method>;
+    request: Request<Params, Response, Body, Query>;
+    response: ExpressResponse;
+    appendHeader: (field: string, value?: string | string[]) => void;
+    attachment: (filename: string) => void;
+    clearCookie: (name: string, options?: CookieOptions) => void;
+    getCookie: (name: string) => RestCookieValue;
+    getRequestHeader: (field: string) => RestHeaderValue;
+    getRequestHeaders: () => Record<string, RestHeaderValue>;
+    getResponseHeader: (field: string) => RestHeaderValue;
+    getResponseHeaders: () => Record<string, RestHeaderValue>;
+    next: () => void;
+    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 RestDataResponseFunction<Method extends RestMethod = RestMethod> = (params: RestParams<Method>) => Data | Promise<Data>;
+export type RestDataResponse<Method extends RestMethod = RestMethod> = Data | RestDataResponseFunction<Method>;
 export type RestFileResponse = string;
-export type RestRouteConfig<Method extends RestMethod> = ({
-    settings: RestSettings & {
-        polling: true;
-    };
-    queue: Array<{
-        time?: number;
-        data: RestDataResponse<Method>;
-    } | {
-        time?: number;
-        file: RestFileResponse;
-    }>;
-} | {
-    settings?: RestSettings & {
-        polling?: false;
-    };
+export interface RestRouteConfig<Method extends RestMethod> {
     data: RestDataResponse<Method>;
-} | {
-    settings?: RestSettings & {
-        polling?: false;
-    };
-    file: RestFileResponse;
-}) & {
     entities?: RestEntitiesByEntityName<Method>;
     interceptors?: Interceptors<'rest'>;
-};
+    settings?: RestSettings;
+}
 export type RestPathString = `/${string}`;
-interface BaseRestRequestConfig<Method extends RestMethod> {
+export interface BaseRestRequestConfig<Method extends RestMethod> {
     interceptors?: Interceptors<'rest'>;
     method: Method;
     path: RegExp | RestPathString;
@@ -57,4 +59,19 @@ type RestDeleteRequestConfig = BaseRestRequestConfig<'delete'>;
 type RestPatchRequestConfig = BaseRestRequestConfig<'patch'>;
 type RestOptionsRequestConfig = BaseRestRequestConfig<'options'>;
 export type RestRequestConfig = RestDeleteRequestConfig | RestGetRequestConfig | RestOptionsRequestConfig | RestPatchRequestConfig | RestPostRequestConfig | RestPutRequestConfig;
+export interface RestRequestArtifact {
+    baseUrl: BaseUrl;
+    componentRequestInterceptor?: Interceptors<'rest'>['request'];
+    componentResponseInterceptor?: Interceptors<'rest'>['response'];
+    config: RestRouteConfig<RestMethod>;
+    method: RestMethod;
+    path: RegExp | RestPathString;
+    requestRequestInterceptor?: Interceptors<'rest'>['request'];
+    requestResponseInterceptor?: Interceptors<'rest'>['response'];
+    routeRequestInterceptor?: Interceptors<'rest'>['request'];
+    routeResponseInterceptor?: Interceptors<'rest'>['response'];
+    serverRequestInterceptor?: Interceptors<'rest'>['request'];
+    serverResponseInterceptor?: Interceptors<'rest'>['response'];
+    weight: number;
+}
 export {};

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

@@ -35,31 +35,14 @@ export interface DatabaseConfig {
     data: `${string}.json` | Record<string, unknown>;
     routes?: `${string}.json` | Record<`/${string}`, `/${string}`>;
 }
-export interface BaseMockServerConfig {
+export interface BaseServerConfig {
     baseUrl?: BaseUrl;
     cors?: Cors;
     interceptors?: Interceptors;
     port?: Port;
     staticPath?: StaticPath;
 }
-export interface MockServerConfig extends BaseMockServerConfig {
-    database?: DatabaseConfig;
-    graphql?: GraphqlConfig;
-    rest?: RestConfig;
-}
-export interface RestMockServerConfig extends BaseMockServerConfig {
-    configs?: RestRequestConfig[];
-    database?: DatabaseConfig;
-}
-export interface GraphQLMockServerConfig extends BaseMockServerConfig {
-    configs?: GraphQLRequestConfig[];
-    database?: DatabaseConfig;
-}
-export interface DatabaseMockServerConfig extends BaseMockServerConfig {
-    data: `${string}.json` | Record<string, unknown>;
-    routes?: `${string}.json` | Record<`/${string}`, `/${string}`>;
-}
-export type MockServerConfigArgv = Arguments<{
+export type MockServerCliArgv = Arguments<{
     baseUrl?: string;
     port?: number;
     staticPath?: string;
@@ -75,13 +58,13 @@ declare global {
         }
     }
 }
-export interface FlatMockServerComponent {
+export interface MockServerComponent {
     baseUrl?: BaseUrl;
     configs: Array<GraphQLRequestConfig | RestRequestConfig>;
     interceptors?: Interceptors;
     name?: string;
 }
-export interface FlatMockServerSettings {
+export interface MockServerSettings {
     baseUrl?: BaseUrl;
     cors?: Cors;
     database?: DatabaseConfig;
@@ -89,8 +72,8 @@ export interface FlatMockServerSettings {
     port?: Port;
     staticPath?: StaticPath;
 }
-export type FlatMockServerConfig = [
-    option: FlatMockServerComponent | FlatMockServerSettings,
-    ...flatMockServerComponents: FlatMockServerComponent[]
+export type MockServerConfig = [
+    option: MockServerComponent | MockServerSettings,
+    ...mockServerComponents: MockServerComponent[]
 ];
 export {};

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

@@ -1,4 +1,5 @@
 import type { Query as ExpressQuery, ParamsDictionary } from 'express-serve-static-core';
+import type { Buffer } from 'node:buffer';
 import type { IncomingHttpHeaders } from 'node:http';
 export type PlainObject = Record<string, any>;
 export type Primitive = bigint | boolean | number | string | symbol | null | undefined;
@@ -6,4 +7,8 @@ export type Headers = IncomingHttpHeaders;
 export type Query = ExpressQuery;
 export type Params = ParamsDictionary;
 export type Cookies = Record<string, string>;
-export type Data = boolean | number | string | any[] | Record<any, any> | null | undefined;
+export type DataPrimitive = boolean | number | string | null | undefined | void;
+export type DataLeaf = Buffer | DataPrimitive;
+export type Data = Data[] | DataLeaf | {
+    [key: string]: Data;
+};