next-api-mock 1.0.0

package/.eslintrc.js

@@ -0,0 +1,19 @@
+module.exports = {
+    root: true,
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    extends: [
+        'eslint:recommended',
+        'plugin:@typescript-eslint/recommended',
+    ],
+    env: {
+        node: true,
+        jest: true,
+    },
+    settings: {
+        react: {
+            version: 'detect',
+        },
+    },
+};
+

package/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+  </profile>
+</component>

package/.idea/misc.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DiscordProjectSettings">
+    <option name="show" value="ASK" />
+    <option name="description" value="" />
+    <option name="applicationTheme" value="default" />
+    <option name="iconsTheme" value="default" />
+    <option name="button1Title" value="" />
+    <option name="button1Url" value="" />
+    <option name="button2Title" value="" />
+    <option name="button2Url" value="" />
+    <option name="customApplicationId" value="" />
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_18" default="true" project-jdk-name="18" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/next-api-mock.iml" filepath="$PROJECT_DIR$/.idea/next-api-mock.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/next-api-mock.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/README.md

@@ -0,0 +1,34 @@
+<div align="center">
+
+# 🎭 next-api-mock
+
+[![npm version](https://img.shields.io/npm/v/next-api-mock.svg?style=flat-square)](https://www.npmjs.com/package/next-api-mock)
+[![license](https://img.shields.io/npm/l/next-api-mock.svg?style=flat-square)](https://github.com/yourusername/next-api-mock/blob/main/LICENSE)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A powerful, flexible, and production-ready API mocking library for Next.js applications.
+
+[Features](#-features) •
+[Installation](#-installation) •
+[Quick Start](#-quick-start) •
+[Documentation](#-documentation) •
+[Contributing](#-contributing)
+
+</div>
+
+## 🚀 Features
+
+- 🔧 Easy configuration and setup
+- 🔄 Support for dynamic and conditional responses
+- 📊 Built-in pagination handling
+- 🚦 Simulated network conditions (delay, errors)
+- 🔍 GraphQL mocking support
+- 🖥️ Server Component and Server Action mocking
+- 🧩 Flexible middleware and interceptors
+- 🗄️ Efficient caching mechanism
+
+## 📦 Installation
+
+```bash
+npm install next-api-mock
+```

package/__tests__/configValidator.test.ts

@@ -0,0 +1,69 @@
+import { validateConfig } from '../src/configValidator'
+import { MockConfig, MockFunction } from '../src/types'
+import { NextApiRequest } from 'next'
+import { NextRequest } from 'next/server'
+
+describe('Config Validator', () => {
+    it('should pass for valid configurations', () => {
+        const validConfig: MockConfig = {
+            '/api/test': {
+                status: 200,
+                data: { message: 'Test successful' },
+            },
+            '/api/function': ((req: NextApiRequest | NextRequest) => ({
+                status: 200,
+                data: { method: req.method },
+            })) as MockFunction,
+        }
+        expect(() => validateConfig(validConfig)).not.toThrow()
+    })
+
+    it('should throw for invalid value types', () => {
+        const invalidConfig = {
+            '/api/test': 'not an object or function',
+        } as unknown as MockConfig;
+        expect(() => validateConfig(invalidConfig)).toThrow(/Invalid configuration for path \/api\/test/)
+    })
+
+    it('should throw for missing data property', () => {
+        const invalidConfig = {
+            '/api/test': {
+                status: 200,
+            },
+        } as unknown as MockConfig;
+        expect(() => validateConfig(invalidConfig)).toThrow(/Invalid configuration for path \/api\/test/)
+    })
+
+    it('should throw for missing status property', () => {
+        const invalidConfig = {
+            '/api/test': {
+                data: { message: 'Test' },
+            },
+        } as unknown as MockConfig;
+        expect(() => validateConfig(invalidConfig)).toThrow(/Invalid configuration for path \/api\/test/)
+    })
+
+    it('should throw for partially valid configurations', () => {
+        const partiallyValidConfig = {
+            '/api/valid': {
+                status: 200,
+                data: { message: 'Valid' },
+            },
+            '/api/invalid': {
+                status: 200,
+            },
+        } as unknown as MockConfig;
+        expect(() => validateConfig(partiallyValidConfig)).toThrow(/Invalid configuration for path \/api\/invalid/)
+    })
+
+    it('should pass for valid function configurations', () => {
+        const validConfig: MockConfig = {
+            '/api/function': ((req: NextApiRequest | NextRequest) => ({
+                status: 200,
+                data: { method: req.method },
+            })) as MockFunction,
+        }
+        expect(() => validateConfig(validConfig)).not.toThrow()
+    })
+})
+

package/__tests__/graphqlMock.test.ts

@@ -0,0 +1,53 @@
+import { createGraphQLMockHandler } from '../src/graphqlMock'
+import { GraphQLSchema, GraphQLObjectType, GraphQLString } from 'graphql'
+import { NextApiRequest } from 'next'
+
+describe('GraphQL Mock Handler', () => {
+    const schema = new GraphQLSchema({
+        query: new GraphQLObjectType({
+            name: 'Query',
+            fields: {
+                hello: {
+                    type: GraphQLString,
+                    resolve: () => 'Hello, world!',
+                },
+            },
+        }),
+    })
+
+    const handler = createGraphQLMockHandler(schema)
+
+    it('should return 405 for non-POST requests', async () => {
+        const req = { method: 'GET' } as NextApiRequest
+        const result = await handler(req)
+        expect(result.status).toBe(405)
+        expect(result.data).toEqual({ errors: [{ message: 'Method not allowed' }] })
+    })
+
+    it('should return 400 if query is missing', async () => {
+        const req = { method: 'POST', body: {} } as NextApiRequest
+        const result = await handler(req)
+        expect(result.status).toBe(400)
+        expect(result.data).toEqual({ errors: [{ message: 'Query is required' }] })
+    })
+
+    it('should execute a valid GraphQL query', async () => {
+        const req = {
+            method: 'POST',
+            body: { query: '{ hello }' },
+        } as NextApiRequest
+        const result = await handler(req)
+        expect(result.status).toBe(200)
+        expect(result.data).toEqual({ data: { hello: 'Hello, world!' } })
+    })
+
+    it('should handle GraphQL errors', async () => {
+        const req = {
+            method: 'POST',
+            body: { query: '{ invalidField }' },
+        } as NextApiRequest
+        const result = await handler(req)
+        expect(result.status).toBe(200)
+        expect(result.data).toHaveProperty('errors')
+    })
+})

package/dist/cache.d.ts

@@ -0,0 +1,19 @@
+import { MockResponse } from './types';
+/**
+ * Caches a mock response.
+ * @param key The cache key.
+ * @param value The mock response to cache.
+ * @param ttl The time-to-live for the cache entry in milliseconds.
+ */
+export declare function cacheResponse(key: string, value: MockResponse, ttl?: number): void;
+/**
+ * Retrieves a cached mock response.
+ * @param key The cache key.
+ * @returns The cached mock response, or undefined if not found.
+ */
+export declare function getCachedResponse(key: string): MockResponse | undefined;
+/**
+ * Clears the entire cache.
+ */
+export declare function clearCache(): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAStC;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAElF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEvE;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAEjC"}

package/dist/cache.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheResponse = cacheResponse;
+exports.getCachedResponse = getCachedResponse;
+exports.clearCache = clearCache;
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const options = {
+    max: 500,
+    ttl: 1000 * 60 * 5 // 5 minutes
+};
+const cache = new lru_cache_1.default(options);
+/**
+ * Caches a mock response.
+ * @param key The cache key.
+ * @param value The mock response to cache.
+ * @param ttl The time-to-live for the cache entry in milliseconds.
+ */
+function cacheResponse(key, value, ttl) {
+    cache.set(key, value, ttl ? { ttl } : undefined);
+}
+/**
+ * Retrieves a cached mock response.
+ * @param key The cache key.
+ * @returns The cached mock response, or undefined if not found.
+ */
+function getCachedResponse(key) {
+    return cache.get(key);
+}
+/**
+ * Clears the entire cache.
+ */
+function clearCache() {
+    cache.clear();
+}

package/dist/configValidator.d.ts

@@ -0,0 +1,8 @@
+import { MockConfig } from './types';
+/**
+ * Validates the provided mock configuration.
+ * @param config The mock configuration to validate.
+ * @throws Error if the configuration is invalid.
+ */
+export declare function validateConfig(config: MockConfig): void;
+//# sourceMappingURL=configValidator.d.ts.map

package/dist/configValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configValidator.d.ts","sourceRoot":"","sources":["../src/configValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAcvD"}

package/dist/configValidator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+/**
+ * Validates the provided mock configuration.
+ * @param config The mock configuration to validate.
+ * @throws Error if the configuration is invalid.
+ */
+function validateConfig(config) {
+    Object.entries(config).forEach(([path, value]) => {
+        if (typeof value !== 'function' && typeof value !== 'object') {
+            throw new Error(`Invalid configuration for path ${path}. Expected function or object, got ${typeof value}`);
+        }
+        if (typeof value === 'object' && value !== null) {
+            if (!Object.prototype.hasOwnProperty.call(value, 'data')) {
+                throw new Error(`Invalid configuration for path ${path}. Missing 'data' property`);
+            }
+            if (!Object.prototype.hasOwnProperty.call(value, 'status')) {
+                throw new Error(`Invalid configuration for path ${path}. Missing 'status' property`);
+            }
+        }
+    });
+}

package/dist/graphqlMock.d.ts

@@ -0,0 +1,5 @@
+import { NextApiRequest } from 'next';
+import { GraphQLSchema } from 'graphql';
+import { MockResponse } from './types';
+export declare function createGraphQLMockHandler(schema: GraphQLSchema): (req: NextApiRequest) => Promise<MockResponse>;
+//# sourceMappingURL=graphqlMock.d.ts.map

package/dist/graphqlMock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlMock.d.ts","sourceRoot":"","sources":["../src/graphqlMock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAA;AACrC,OAAO,EAAW,aAAa,EAAE,MAAM,SAAS,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEtC,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,SACvC,cAAc,KAAG,OAAO,CAAC,YAAY,CAAC,CAqC5D"}

package/dist/graphqlMock.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLMockHandler = createGraphQLMockHandler;
+const graphql_1 = require("graphql");
+function createGraphQLMockHandler(schema) {
+    return (req) => __awaiter(this, void 0, void 0, function* () {
+        if (req.method !== 'POST') {
+            return {
+                status: 405,
+                data: { errors: [{ message: 'Method not allowed' }] }
+            };
+        }
+        const { query, variables, operationName } = req.body;
+        if (!query) {
+            return {
+                status: 400,
+                data: { errors: [{ message: 'Query is required' }] }
+            };
+        }
+        try {
+            const result = yield (0, graphql_1.graphql)({
+                schema,
+                source: query,
+                variableValues: variables,
+                operationName
+            });
+            return {
+                status: 200,
+                data: result
+            };
+        }
+        catch (error) {
+            console.error('GraphQL execution error:', error);
+            return {
+                status: 500,
+                data: { errors: [{ message: 'Internal server error' }] }
+            };
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import { MockResponse, MockConfig, RequestLogger, MockInterceptor, MockOptions, MiddlewareFunction } from './types';
+import { createMockDatabase } from './mockDatabase';
+import { createGraphQLMockHandler } from './graphqlMock';
+import { configureServerMocks, resetServerMocks, mockServerAction, createServerComponentMock } from './serverMock';
+import { registerPlugin } from './plugins';
+import { reportMetrics } from './monitoring';
+import { createRequestValidator } from './validation';
+export declare function configureMocksAsync(configPromise: Promise<MockConfig>, options?: Partial<MockOptions>): Promise<void>;
+export declare function configureMocks(loadedConfig: MockConfig, options?: Partial<MockOptions>): void;
+export declare function resetMocks(): void;
+export declare function setGlobalDelay(delay: number): void;
+export declare function setRequestLogger(logger: RequestLogger): void;
+export declare function setMockInterceptor(interceptor: MockInterceptor): void;
+export declare function onMockResponse(listener: (path: string, response: MockResponse<unknown>) => void): () => void;
+export declare function addMiddleware(middleware: MiddlewareFunction): void;
+export declare function createMockHandler(path: string): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
+export { createMockDatabase, createGraphQLMockHandler, configureServerMocks, resetServerMocks, mockServerAction, createServerComponentMock, registerPlugin, reportMetrics, createRequestValidator };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,MAAM,CAAA;AAOtD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,kBAAkB,EAAgB,MAAM,SAAS,CAAA;AACjI,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAIxD,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AAClH,OAAO,EAAqB,cAAc,EAAE,MAAM,WAAW,CAAA;AAE7D,OAAO,EAAkB,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AA6BrD,wBAAsB,mBAAmB,CAAC,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ3H;AAED,wBAAgB,cAAc,CAAC,YAAY,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,CAgB7F;AAED,wBAAgB,UAAU,IAAI,IAAI,CAQjC;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI,CAErE;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAG5G;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI,CAElE;AAeD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,SACvB,cAAc,OAAO,eAAe,KAAG,OAAO,CAAC,IAAI,CAAC,CAsF1E;AAED,OAAO,EACH,kBAAkB,EAClB,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,yBAAyB,EACzB,cAAc,EACd,aAAa,EACb,sBAAsB,EACzB,CAAA"}

package/dist/index.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestValidator = exports.reportMetrics = exports.registerPlugin = exports.createServerComponentMock = exports.mockServerAction = exports.resetServerMocks = exports.configureServerMocks = exports.createGraphQLMockHandler = exports.createMockDatabase = void 0;
+exports.configureMocksAsync = configureMocksAsync;
+exports.configureMocks = configureMocks;
+exports.resetMocks = resetMocks;
+exports.setGlobalDelay = setGlobalDelay;
+exports.setRequestLogger = setRequestLogger;
+exports.setMockInterceptor = setMockInterceptor;
+exports.onMockResponse = onMockResponse;
+exports.addMiddleware = addMiddleware;
+exports.createMockHandler = createMockHandler;
+const url_1 = require("url");
+const path_to_regexp_1 = require("path-to-regexp");
+const events_1 = require("events");
+const winston = __importStar(require("winston"));
+const config_1 = __importDefault(require("config"));
+const express_rate_limit_1 = require("express-rate-limit");
+const mockDatabase_1 = require("./mockDatabase");
+Object.defineProperty(exports, "createMockDatabase", { enumerable: true, get: function () { return mockDatabase_1.createMockDatabase; } });
+const graphqlMock_1 = require("./graphqlMock");
+Object.defineProperty(exports, "createGraphQLMockHandler", { enumerable: true, get: function () { return graphqlMock_1.createGraphQLMockHandler; } });
+const configValidator_1 = require("./configValidator");
+const middleware_1 = require("./middleware");
+const cache_1 = require("./cache");
+const serverMock_1 = require("./serverMock");
+Object.defineProperty(exports, "configureServerMocks", { enumerable: true, get: function () { return serverMock_1.configureServerMocks; } });
+Object.defineProperty(exports, "resetServerMocks", { enumerable: true, get: function () { return serverMock_1.resetServerMocks; } });
+Object.defineProperty(exports, "mockServerAction", { enumerable: true, get: function () { return serverMock_1.mockServerAction; } });
+Object.defineProperty(exports, "createServerComponentMock", { enumerable: true, get: function () { return serverMock_1.createServerComponentMock; } });
+const plugins_1 = require("./plugins");
+Object.defineProperty(exports, "registerPlugin", { enumerable: true, get: function () { return plugins_1.registerPlugin; } });
+const security_1 = require("./security");
+const monitoring_1 = require("./monitoring");
+Object.defineProperty(exports, "reportMetrics", { enumerable: true, get: function () { return monitoring_1.reportMetrics; } });
+const validation_1 = require("./validation");
+Object.defineProperty(exports, "createRequestValidator", { enumerable: true, get: function () { return validation_1.createRequestValidator; } });
+const logger = winston.createLogger({
+    level: config_1.default.get('logLevel') || 'info',
+    format: winston.format.json(),
+    defaultMeta: { service: 'mock-library' },
+    transports: [
+        new winston.transports.Console(),
+        new winston.transports.File({ filename: 'error.log', level: 'error' }),
+        new winston.transports.File({ filename: 'combined.log' }),
+    ],
+});
+const defaultConfig = {};
+const defaultOptions = {
+    enableLogging: false,
+    cacheTimeout: 5 * 60 * 1000, // 5 minutes
+    defaultDelay: 0,
+    errorRate: 0,
+};
+let mockConfig = Object.assign({}, defaultConfig);
+let mockOptions = Object.assign({}, defaultOptions);
+let globalDelay = 0;
+let requestLogger = null;
+let mockInterceptor = null;
+const eventEmitter = new events_1.EventEmitter();
+const middlewarePipeline = [];
+function configureMocksAsync(configPromise, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const loadedConfig = yield configPromise;
+            configureMocks(loadedConfig, options);
+        }
+        catch (error) {
+            logger.error('Error loading configuration:', error);
+            throw new Error('Failed to load mock configuration');
+        }
+    });
+}
+function configureMocks(loadedConfig, options) {
+    try {
+        (0, configValidator_1.validateConfig)(loadedConfig);
+        mockConfig = Object.assign(Object.assign({}, defaultConfig), loadedConfig);
+        mockOptions = Object.assign(Object.assign({}, defaultOptions), options);
+        if (mockOptions.enableLogging) {
+            setRequestLogger(defaultLogger);
+        }
+        if (mockOptions.defaultDelay) {
+            setGlobalDelay(mockOptions.defaultDelay);
+        }
+        (0, plugins_1.initializePlugins)(mockConfig);
+    }
+    catch (error) {
+        logger.error('Error configuring mocks:', error);
+        throw new Error('Failed to configure mocks');
+    }
+}
+function resetMocks() {
+    mockConfig = Object.assign({}, defaultConfig);
+    mockOptions = Object.assign({}, defaultOptions);
+    globalDelay = 0;
+    requestLogger = null;
+    mockInterceptor = null;
+    (0, cache_1.clearCache)();
+    (0, serverMock_1.resetServerMocks)();
+}
+function setGlobalDelay(delay) {
+    globalDelay = delay;
+}
+function setRequestLogger(logger) {
+    requestLogger = logger;
+}
+function setMockInterceptor(interceptor) {
+    mockInterceptor = interceptor;
+}
+function onMockResponse(listener) {
+    eventEmitter.on('mockResponse', listener);
+    return () => eventEmitter.off('mockResponse', listener);
+}
+function addMiddleware(middleware) {
+    middlewarePipeline.push(middleware);
+}
+function defaultLogger(req, res) {
+    logger.info(`${req.method} ${req.url} - Status: ${res.statusCode}`);
+}
+function shouldSimulateError() {
+    return Math.random() < mockOptions.errorRate;
+}
+const limiter = (0, express_rate_limit_1.rateLimit)({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+});
+function createMockHandler(path) {
+    return (req, res) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            (0, security_1.setSecureHeaders)(res);
+            // Fix: Replace empty arrow function with a named function
+            const rateLimitHandler = (err) => {
+                if (err) {
+                    logger.error('Rate limit error:', err);
+                    res.status(429).json({ error: 'Too many requests' });
+                }
+            };
+            limiter(req, res, rateLimitHandler);
+            if (shouldSimulateError()) {
+                throw new Error('Simulated server error');
+            }
+            for (const middleware of middlewarePipeline) {
+                yield middleware(req, res);
+            }
+            const cacheKey = `${req.method}:${path}:${JSON.stringify(req.query)}:${JSON.stringify(req.body)}`;
+            const cachedResponse = (0, cache_1.getCachedResponse)(cacheKey);
+            if (cachedResponse) {
+                res.status(cachedResponse.status || 200).json(cachedResponse.data);
+                return;
+            }
+            const { pathname } = (0, url_1.parse)(req.url || '', true);
+            const matchFn = (0, path_to_regexp_1.match)(path, { decode: decodeURIComponent });
+            if (pathname === null) {
+                res.status(400).json({ error: 'Invalid URL' });
+                return;
+            }
+            const matched = matchFn(pathname);
+            if (!matched) {
+                res.status(404).json({ error: 'Not found' });
+                return;
+            }
+            let mockResponse;
+            const mockConfigItem = mockConfig[path];
+            if (typeof mockConfigItem === 'function') {
+                mockResponse = yield mockConfigItem(req);
+            }
+            else {
+                mockResponse = mockConfigItem;
+            }
+            if (!mockResponse) {
+                res.status(404).json({ error: 'Not found' });
+                return;
+            }
+            mockResponse = yield (0, middleware_1.applyMiddleware)(req, mockResponse, mockInterceptor);
+            if (requestLogger) {
+                requestLogger(req, res);
+            }
+            const delay = mockResponse.delay || globalDelay;
+            if (delay) {
+                yield new Promise(resolve => setTimeout(resolve, delay));
+            }
+            if (mockResponse.headers) {
+                Object.entries(mockResponse.headers).forEach(([key, value]) => {
+                    res.setHeader(key, value);
+                });
+            }
+            eventEmitter.emit('mockResponse', path, mockResponse);
+            (0, monitoring_1.collectMetrics)(req, res, mockResponse);
+            (0, cache_1.cacheResponse)(cacheKey, mockResponse, mockOptions.cacheTimeout);
+            res.status(mockResponse.status || 200).json(mockResponse.data);
+        }
+        catch (error) {
+            logger.error('Error in mock handler:', error);
+            res.status(500).json({ error: 'Internal server error', details: error.message });
+        }
+    });
+}